/
package.d
1735 lines (1529 loc) · 55.8 KB
/
package.d
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/++
$(LINK2 https://en.wikipedia.org/wiki/Regular_expression, Regular expressions)
are a commonly used method of pattern matching
on strings, with $(I regex) being a catchy word for a pattern in this domain
specific language. Typical problems usually solved by regular expressions
include validation of user input and the ubiquitous find $(AMP) replace
in text processing utilities.
$(SCRIPT inhibitQuickIndex = 1;)
$(BOOKTABLE,
$(TR $(TH Category) $(TH Functions))
$(TR $(TD Matching) $(TD
$(LREF bmatch)
$(LREF match)
$(LREF matchAll)
$(LREF matchFirst)
))
$(TR $(TD Building) $(TD
$(LREF ctRegex)
$(LREF escaper)
$(LREF _regex)
))
$(TR $(TD Replace) $(TD
$(LREF replace)
$(LREF replaceAll)
$(LREF replaceAllInto)
$(LREF replaceFirst)
$(LREF replaceFirstInto)
))
$(TR $(TD Split) $(TD
$(LREF split)
$(LREF splitter)
))
$(TR $(TD Objects) $(TD
$(LREF Captures)
$(LREF Regex)
$(LREF RegexException)
$(LREF RegexMatch)
$(LREF Splitter)
$(LREF StaticRegex)
))
)
$(SECTION Synopsis)
---
import std.regex;
import std.stdio;
void main()
{
// Print out all possible dd/mm/yy(yy) dates found in user input.
auto r = regex(r"\b[0-9][0-9]?/[0-9][0-9]?/[0-9][0-9](?:[0-9][0-9])?\b");
foreach (line; stdin.byLine)
{
// matchAll() returns a range that can be iterated
// to get all subsequent matches.
foreach (c; matchAll(line, r))
writeln(c.hit);
}
}
...
// Create a static regex at compile-time, which contains fast native code.
auto ctr = ctRegex!(`^.*/([^/]+)/?$`);
// It works just like a normal regex:
auto c2 = matchFirst("foo/bar", ctr); // First match found here, if any
assert(!c2.empty); // Be sure to check if there is a match before examining contents!
assert(c2[1] == "bar"); // Captures is a range of submatches: 0 = full match.
...
// multi-pattern regex
auto multi = regex([`\d+,\d+`,`(a-z]+):(\d+)`]);
auto m = "abc:43 12,34".matchAll(multi);
assert(m.front.whichPattern == 2);
assert(m.front[1] == "abc");
assert(m.front[2] == "43");
m.popFront();
assert(m.front.whichPattern == 1);
assert(m.front[1] == "12");
...
// The result of the `matchAll/matchFirst` is directly testable with if/assert/while.
// e.g. test if a string consists of letters:
assert(matchFirst("Letter", `^\p{L}+$`));
---
$(SECTION Syntax and general information)
The general usage guideline is to keep regex complexity on the side of simplicity,
as its capabilities reside in purely character-level manipulation.
As such it's ill-suited for tasks involving higher level invariants
like matching an integer number $(U bounded) in an [a,b] interval.
Checks of this sort of are better addressed by additional post-processing.
The basic syntax shouldn't surprise experienced users of regular expressions.
For an introduction to $(D std.regex) see a
$(HTTP dlang.org/regular-expression.html, short tour) of the module API
and its abilities.
There are other web resources on regular expressions to help newcomers,
and a good $(HTTP www.regular-expressions.info, reference with tutorial)
can easily be found.
This library uses a remarkably common ECMAScript syntax flavor
with the following extensions:
$(UL
$(LI Named subexpressions, with Python syntax. )
$(LI Unicode properties such as Scripts, Blocks and common binary properties e.g Alphabetic, White_Space, Hex_Digit etc.)
$(LI Arbitrary length and complexity lookbehind, including lookahead in lookbehind and vise-versa.)
)
$(REG_START Pattern syntax )
$(I std.regex operates on codepoint level,
'character' in this table denotes a single Unicode codepoint.)
$(REG_TABLE
$(REG_TITLE Pattern element, Semantics )
$(REG_TITLE Atoms, Match single characters )
$(REG_ROW any character except [{|*+?()^$, Matches the character itself. )
$(REG_ROW ., In single line mode matches any character.
Otherwise it matches any character except '\n' and '\r'. )
$(REG_ROW [class], Matches a single character
that belongs to this character class. )
$(REG_ROW [^class], Matches a single character that
does $(U not) belong to this character class.)
$(REG_ROW \cC, Matches the control character corresponding to letter C)
$(REG_ROW \xXX, Matches a character with hexadecimal value of XX. )
$(REG_ROW \uXXXX, Matches a character with hexadecimal value of XXXX. )
$(REG_ROW \U00YYYYYY, Matches a character with hexadecimal value of YYYYYY. )
$(REG_ROW \f, Matches a formfeed character. )
$(REG_ROW \n, Matches a linefeed character. )
$(REG_ROW \r, Matches a carriage return character. )
$(REG_ROW \t, Matches a tab character. )
$(REG_ROW \v, Matches a vertical tab character. )
$(REG_ROW \d, Matches any Unicode digit. )
$(REG_ROW \D, Matches any character except Unicode digits. )
$(REG_ROW \w, Matches any word character (note: this includes numbers).)
$(REG_ROW \W, Matches any non-word character.)
$(REG_ROW \s, Matches whitespace, same as \p{White_Space}.)
$(REG_ROW \S, Matches any character except those recognized as $(I \s ). )
$(REG_ROW \\, Matches \ character. )
$(REG_ROW \c where c is one of [|*+?(), Matches the character c itself. )
$(REG_ROW \p{PropertyName}, Matches a character that belongs
to the Unicode PropertyName set.
Single letter abbreviations can be used without surrounding {,}. )
$(REG_ROW \P{PropertyName}, Matches a character that does not belong
to the Unicode PropertyName set.
Single letter abbreviations can be used without surrounding {,}. )
$(REG_ROW \p{InBasicLatin}, Matches any character that is part of
the BasicLatin Unicode $(U block).)
$(REG_ROW \P{InBasicLatin}, Matches any character except ones in
the BasicLatin Unicode $(U block).)
$(REG_ROW \p{Cyrillic}, Matches any character that is part of
Cyrillic $(U script).)
$(REG_ROW \P{Cyrillic}, Matches any character except ones in
Cyrillic $(U script).)
$(REG_TITLE Quantifiers, Specify repetition of other elements)
$(REG_ROW *, Matches previous character/subexpression 0 or more times.
Greedy version - tries as many times as possible.)
$(REG_ROW *?, Matches previous character/subexpression 0 or more times.
Lazy version - stops as early as possible.)
$(REG_ROW +, Matches previous character/subexpression 1 or more times.
Greedy version - tries as many times as possible.)
$(REG_ROW +?, Matches previous character/subexpression 1 or more times.
Lazy version - stops as early as possible.)
$(REG_ROW {n}, Matches previous character/subexpression exactly n times. )
$(REG_ROW {n$(COMMA)}, Matches previous character/subexpression n times or more.
Greedy version - tries as many times as possible. )
$(REG_ROW {n$(COMMA)}?, Matches previous character/subexpression n times or more.
Lazy version - stops as early as possible.)
$(REG_ROW {n$(COMMA)m}, Matches previous character/subexpression n to m times.
Greedy version - tries as many times as possible, but no more than m times. )
$(REG_ROW {n$(COMMA)m}?, Matches previous character/subexpression n to m times.
Lazy version - stops as early as possible, but no less then n times.)
$(REG_TITLE Other, Subexpressions $(AMP) alternations )
$(REG_ROW (regex), Matches subexpression regex,
saving matched portion of text for later retrieval. )
$(REG_ROW (?#comment), An inline comment that is ignored while matching.)
$(REG_ROW (?:regex), Matches subexpression regex,
$(U not) saving matched portion of text. Useful to speed up matching. )
$(REG_ROW A|B, Matches subexpression A, or failing that, matches B. )
$(REG_ROW (?P$(LT)name$(GT)regex), Matches named subexpression
regex labeling it with name 'name'.
When referring to a matched portion of text,
names work like aliases in addition to direct numbers.
)
$(REG_TITLE Assertions, Match position rather than character )
$(REG_ROW ^, Matches at the begining of input or line (in multiline mode).)
$(REG_ROW $, Matches at the end of input or line (in multiline mode). )
$(REG_ROW \b, Matches at word boundary. )
$(REG_ROW \B, Matches when $(U not) at word boundary. )
$(REG_ROW (?=regex), Zero-width lookahead assertion.
Matches at a point where the subexpression
regex could be matched starting from the current position.
)
$(REG_ROW (?!regex), Zero-width negative lookahead assertion.
Matches at a point where the subexpression
regex could $(U not) be matched starting from the current position.
)
$(REG_ROW (?<=regex), Zero-width lookbehind assertion. Matches at a point
where the subexpression regex could be matched ending
at the current position (matching goes backwards).
)
$(REG_ROW (?<!regex), Zero-width negative lookbehind assertion.
Matches at a point where the subexpression regex could $(U not)
be matched ending at the current position (matching goes backwards).
)
)
$(REG_START Character classes )
$(REG_TABLE
$(REG_TITLE Pattern element, Semantics )
$(REG_ROW Any atom, Has the same meaning as outside of a character class.)
$(REG_ROW a-z, Includes characters a, b, c, ..., z. )
$(REG_ROW [a||b]$(COMMA) [a--b]$(COMMA) [a~~b]$(COMMA) [a$(AMP)$(AMP)b],
Where a, b are arbitrary classes, means union, set difference,
symmetric set difference, and intersection respectively.
$(I Any sequence of character class elements implicitly forms a union.) )
)
$(REG_START Regex flags )
$(REG_TABLE
$(REG_TITLE Flag, Semantics )
$(REG_ROW g, Global regex, repeat over the whole input. )
$(REG_ROW i, Case insensitive matching. )
$(REG_ROW m, Multi-line mode, match ^, $ on start and end line separators
as well as start and end of input.)
$(REG_ROW s, Single-line mode, makes . match '\n' and '\r' as well. )
$(REG_ROW x, Free-form syntax, ignores whitespace in pattern,
useful for formatting complex regular expressions. )
)
$(SECTION Unicode support)
This library provides full Level 1 support* according to
$(HTTP unicode.org/reports/tr18/, UTS 18). Specifically:
$(UL
$(LI 1.1 Hex notation via any of \uxxxx, \U00YYYYYY, \xZZ.)
$(LI 1.2 Unicode properties.)
$(LI 1.3 Character classes with set operations.)
$(LI 1.4 Word boundaries use the full set of "word" characters.)
$(LI 1.5 Using simple casefolding to match case
insensitively across the full range of codepoints.)
$(LI 1.6 Respecting line breaks as any of
\u000A | \u000B | \u000C | \u000D | \u0085 | \u2028 | \u2029 | \u000D\u000A.)
$(LI 1.7 Operating on codepoint level.)
)
*With exception of point 1.1.1, as of yet, normalization of input
is expected to be enforced by user.
$(SECTION Replace format string)
A set of functions in this module that do the substitution rely
on a simple format to guide the process. In particular the table below
applies to the $(D format) argument of
$(LREF replaceFirst) and $(LREF replaceAll).
The format string can reference parts of match using the following notation.
$(REG_TABLE
$(REG_TITLE Format specifier, Replaced by )
$(REG_ROW $$(AMP), the whole match. )
$(REG_ROW $(DOLLAR)$(BACKTICK), part of input $(I preceding) the match. )
$(REG_ROW $', part of input $(I following) the match. )
$(REG_ROW $$, '$' character. )
$(REG_ROW \c $(COMMA) where c is any character, the character c itself. )
$(REG_ROW \\, '\' character. )
$(REG_ROW $(DOLLAR)1 .. $(DOLLAR)99, submatch number 1 to 99 respectively. )
)
$(SECTION Slicing and zero memory allocations orientation)
All matches returned by pattern matching functionality in this library
are slices of the original input. The notable exception is the $(D replace)
family of functions that generate a new string from the input.
In cases where producing the replacement is the ultimate goal
$(LREF replaceFirstInto) and $(LREF replaceAllInto) could come in handy
as functions that avoid allocations even for replacement.
Copyright: Copyright Dmitry Olshansky, 2011-
License: $(HTTP boost.org/LICENSE_1_0.txt, Boost License 1.0).
Authors: Dmitry Olshansky,
API and utility constructs are modeled after the original $(D std.regex)
by Walter Bright and Andrei Alexandrescu.
Source: $(PHOBOSSRC std/_regex/_package.d)
Macros:
REG_ROW = $(TR $(TD $(I $1 )) $(TD $+) )
REG_TITLE = $(TR $(TD $(B $1)) $(TD $(B $2)) )
REG_TABLE = <table border="1" cellspacing="0" cellpadding="5" > $0 </table>
REG_START = <h3><div align="center"> $0 </div></h3>
SECTION = <h3><a id="$1" href="#$1" class="anchor">$0</a></h3>
S_LINK = <a href="#$1">$+</a>
+/
module std.regex;
import std.range.primitives, std.traits;
import std.regex.internal.ir;
import std.regex.internal.thompson; //TODO: get rid of this dependency
import std.typecons; // : Flag, Yes, No;
/++
$(D Regex) object holds regular expression pattern in compiled form.
Instances of this object are constructed via calls to $(D regex).
This is an intended form for caching and storage of frequently
used regular expressions.
Example:
Test if this object doesn't contain any compiled pattern.
---
Regex!char r;
assert(r.empty);
r = regex(""); // Note: "" is a valid regex pattern.
assert(!r.empty);
---
Getting a range of all the named captures in the regex.
----
import std.range;
import std.algorithm;
auto re = regex(`(?P<name>\w+) = (?P<var>\d+)`);
auto nc = re.namedCaptures;
static assert(isRandomAccessRange!(typeof(nc)));
assert(!nc.empty);
assert(nc.length == 2);
assert(nc.equal(["name", "var"]));
assert(nc[0] == "name");
assert(nc[1..$].equal(["var"]));
----
+/
public alias Regex(Char) = std.regex.internal.ir.Regex!(Char);
/++
A $(D StaticRegex) is $(D Regex) object that contains D code specially
generated at compile-time to speed up matching.
Implicitly convertible to normal $(D Regex),
however doing so will result in losing this additional capability.
+/
public alias StaticRegex(Char) = std.regex.internal.ir.StaticRegex!(Char);
/++
Compile regular expression pattern for the later execution.
Returns: $(D Regex) object that works on inputs having
the same character width as $(D pattern).
Params:
pattern = A single regular expression to match.
patterns = An array of regular expression strings.
The resulting `Regex` object will match any expression;
use $(LREF whichPattern) to know which.
flags = The _attributes (g, i, m and x accepted)
Throws: $(D RegexException) if there were any errors during compilation.
+/
@trusted public auto regex(S)(S[] patterns, const(char)[] flags="")
if (isSomeString!(S))
{
import std.array : appender;
import std.functional : memoize;
enum cacheSize = 8; //TODO: invent nice interface to control regex caching
S pat;
if (patterns.length > 1)
{
auto app = appender!S();
foreach (i, p; patterns)
{
if (i != 0)
app.put("|");
app.put("(?:");
app.put(patterns[i]);
// terminator for the pattern
// to detect if the pattern unexpectedly ends
app.put("\\");
app.put(cast(dchar)(privateUseStart+i));
app.put(")");
// another one to return correct whichPattern
// for all of potential alternatives in the patterns[i]
app.put("\\");
app.put(cast(dchar)(privateUseStart+i));
}
pat = app.data;
}
else
pat = patterns[0];
if (__ctfe)
return regexImpl(pat, flags);
return memoize!(regexImpl!S, cacheSize)(pat, flags);
}
///ditto
@trusted public auto regex(S)(S pattern, const(char)[] flags="")
if (isSomeString!(S))
{
return regex([pattern], flags);
}
///
@system unittest
{
// multi-pattern regex example
auto multi = regex([`([a-z]+):(\d+)`, `(\d+),\d+`]); // multi regex
auto m = "abc:43 12,34".matchAll(multi);
assert(m.front.whichPattern == 1);
assert(m.front[1] == "abc");
assert(m.front[2] == "43");
m.popFront();
assert(m.front.whichPattern == 2);
assert(m.front[1] == "12");
}
public auto regexImpl(S)(S pattern, const(char)[] flags="")
if (isSomeString!(S))
{
import std.regex.internal.parser : Parser, CodeGen;
auto parser = Parser!(Unqual!(typeof(pattern)), CodeGen)(pattern, flags);
auto r = parser.program;
return r;
}
template ctRegexImpl(alias pattern, string flags=[])
{
import std.regex.internal.backtracking, std.regex.internal.parser;
enum r = regex(pattern, flags);
alias Char = BasicElementOf!(typeof(pattern));
enum source = ctGenRegExCode(r);
alias Matcher = BacktrackingMatcher!(true);
@trusted bool func(ref Matcher!Char matcher)
{
debug(std_regex_ctr) pragma(msg, source);
mixin(source);
}
enum nr = StaticRegex!Char(r, &func);
}
/++
Compile regular expression using CTFE
and generate optimized native machine code for matching it.
Returns: StaticRegex object for faster matching.
Params:
pattern = Regular expression
flags = The _attributes (g, i, m and x accepted)
+/
public enum ctRegex(alias pattern, alias flags=[]) = ctRegexImpl!(pattern, flags).nr;
enum isRegexFor(RegEx, R) = is(RegEx == Regex!(BasicElementOf!R))
|| is(RegEx == StaticRegex!(BasicElementOf!R));
/++
$(D Captures) object contains submatches captured during a call
to $(D match) or iteration over $(D RegexMatch) range.
First element of range is the whole match.
+/
@trusted public struct Captures(R, DIndex = size_t)
if (isSomeString!R)
{//@trusted because of union inside
alias DataIndex = DIndex;
alias String = R;
private:
import std.conv : text;
R _input;
int _nMatch;
enum smallString = 3;
enum SMALL_MASK = 0x8000_0000, REF_MASK= 0x1FFF_FFFF;
union
{
Group!DataIndex[] big_matches;
Group!DataIndex[smallString] small_matches;
}
uint _f, _b;
uint _refcount; // ref count or SMALL MASK + num groups
NamedGroup[] _names;
this()(R input, uint n, NamedGroup[] named)
{
_input = input;
_names = named;
newMatches(n);
_b = n;
_f = 0;
}
this(alias Engine)(ref RegexMatch!(R,Engine) rmatch)
{
_input = rmatch._input;
_names = rmatch._engine.re.dict;
immutable n = rmatch._engine.re.ngroup;
newMatches(n);
_b = n;
_f = 0;
}
@property inout(Group!DataIndex[]) matches() inout
{
return (_refcount & SMALL_MASK) ? small_matches[0 .. _refcount & 0xFF] : big_matches;
}
void newMatches(uint n)
{
import core.stdc.stdlib : calloc;
import std.exception : enforce;
if (n > smallString)
{
auto p = cast(Group!DataIndex*) enforce(
calloc(Group!DataIndex.sizeof,n),
"Failed to allocate Captures struct"
);
big_matches = p[0 .. n];
_refcount = 1;
}
else
{
_refcount = SMALL_MASK | n;
}
}
bool unique()
{
return (_refcount & SMALL_MASK) || _refcount == 1;
}
public:
this(this)
{
if (!(_refcount & SMALL_MASK))
{
_refcount++;
}
}
~this()
{
import core.stdc.stdlib : free;
if (!(_refcount & SMALL_MASK))
{
if (--_refcount == 0)
{
free(big_matches.ptr);
big_matches = null;
}
}
}
///Slice of input prior to the match.
@property R pre()
{
return _nMatch == 0 ? _input[] : _input[0 .. matches[0].begin];
}
///Slice of input immediately after the match.
@property R post()
{
return _nMatch == 0 ? _input[] : _input[matches[0].end .. $];
}
///Slice of matched portion of input.
@property R hit()
{
assert(_nMatch, "attempted to get hit of an empty match");
return _input[matches[0].begin .. matches[0].end];
}
///Range interface.
@property R front()
{
assert(_nMatch, "attempted to get front of an empty match");
return _input[matches[_f].begin .. matches[_f].end];
}
///ditto
@property R back()
{
assert(_nMatch, "attempted to get back of an empty match");
return _input[matches[_b - 1].begin .. matches[_b - 1].end];
}
///ditto
void popFront()
{
assert(!empty);
++_f;
}
///ditto
void popBack()
{
assert(!empty);
--_b;
}
///ditto
@property bool empty() const { return _nMatch == 0 || _f >= _b; }
///ditto
inout(R) opIndex()(size_t i) inout
{
assert(_f + i < _b,text("requested submatch number ", i," is out of range"));
assert(matches[_f + i].begin <= matches[_f + i].end,
text("wrong match: ", matches[_f + i].begin, "..", matches[_f + i].end));
return _input[matches[_f + i].begin .. matches[_f + i].end];
}
/++
Explicit cast to bool.
Useful as a shorthand for !(x.empty) in if and assert statements.
---
import std.regex;
assert(!matchFirst("nothing", "something"));
---
+/
@safe bool opCast(T:bool)() const nothrow { return _nMatch != 0; }
/++
Number of pattern matched counting, where 1 - the first pattern.
Returns 0 on no match.
+/
@safe @property int whichPattern() const nothrow { return _nMatch; }
///
@system unittest
{
import std.regex;
assert(matchFirst("abc", "[0-9]+", "[a-z]+").whichPattern == 2);
}
/++
Lookup named submatch.
---
import std.regex;
import std.range;
auto c = matchFirst("a = 42;", regex(`(?P<var>\w+)\s*=\s*(?P<value>\d+);`));
assert(c["var"] == "a");
assert(c["value"] == "42");
popFrontN(c, 2);
//named groups are unaffected by range primitives
assert(c["var"] =="a");
assert(c.front == "42");
----
+/
R opIndex(String)(String i) /*const*/ //@@@BUG@@@
if (isSomeString!String)
{
size_t index = lookupNamedGroup(_names, i);
return _input[matches[index].begin .. matches[index].end];
}
///Number of matches in this object.
@property size_t length() const { return _nMatch == 0 ? 0 : _b - _f; }
///A hook for compatibility with original std.regex.
@property ref captures(){ return this; }
}
///
@system unittest
{
import std.range.primitives : popFrontN;
auto c = matchFirst("@abc#", regex(`(\w)(\w)(\w)`));
assert(c.pre == "@"); // Part of input preceding match
assert(c.post == "#"); // Immediately after match
assert(c.hit == c[0] && c.hit == "abc"); // The whole match
assert(c[2] == "b");
assert(c.front == "abc");
c.popFront();
assert(c.front == "a");
assert(c.back == "c");
c.popBack();
assert(c.back == "b");
popFrontN(c, 2);
assert(c.empty);
assert(!matchFirst("nothing", "something"));
}
/++
A regex engine state, as returned by $(D match) family of functions.
Effectively it's a forward range of Captures!R, produced
by lazily searching for matches in a given input.
$(D alias Engine) specifies an engine type to use during matching,
and is automatically deduced in a call to $(D match)/$(D bmatch).
+/
@trusted public struct RegexMatch(R, alias Engine = ThompsonMatcher)
if (isSomeString!R)
{
private:
import core.stdc.stdlib : malloc, free;
alias Char = BasicElementOf!R;
alias EngineType = Engine!Char;
EngineType _engine;
R _input;
Captures!(R,EngineType.DataIndex) _captures;
void[] _memory;//is ref-counted
this(RegEx)(R input, RegEx prog)
{
import std.exception : enforce;
_input = input;
immutable size = EngineType.initialMemory(prog)+size_t.sizeof;
_memory = (enforce(malloc(size), "malloc failed")[0 .. size]);
scope(failure) free(_memory.ptr);
*cast(size_t*)_memory.ptr = 1;
_engine = EngineType(prog, Input!Char(input), _memory[size_t.sizeof..$]);
static if (is(RegEx == StaticRegex!(BasicElementOf!R)))
_engine.nativeFn = prog.nativeFn;
_captures = Captures!(R,EngineType.DataIndex)(this);
_captures._nMatch = _engine.match(_captures.matches);
debug(std_regex_allocation) writefln("RefCount (ctor): %x %d", _memory.ptr, counter);
}
@property ref size_t counter(){ return *cast(size_t*)_memory.ptr; }
public:
this(this)
{
if (_memory.ptr)
{
++counter;
debug(std_regex_allocation) writefln("RefCount (postblit): %x %d",
_memory.ptr, *cast(size_t*)_memory.ptr);
}
}
~this()
{
if (_memory.ptr && --*cast(size_t*)_memory.ptr == 0)
{
debug(std_regex_allocation) writefln("RefCount (dtor): %x %d",
_memory.ptr, *cast(size_t*)_memory.ptr);
free(cast(void*)_memory.ptr);
}
}
///Shorthands for front.pre, front.post, front.hit.
@property R pre()
{
return _captures.pre;
}
///ditto
@property R post()
{
return _captures.post;
}
///ditto
@property R hit()
{
return _captures.hit;
}
/++
Functionality for processing subsequent matches of global regexes via range interface:
---
import std.regex;
auto m = matchAll("Hello, world!", regex(`\w+`));
assert(m.front.hit == "Hello");
m.popFront();
assert(m.front.hit == "world");
m.popFront();
assert(m.empty);
---
+/
@property auto front()
{
return _captures;
}
///ditto
void popFront()
{
import std.exception : enforce;
if (counter != 1)
{//do cow magic first
counter--;//we abandon this reference
immutable size = EngineType.initialMemory(_engine.re)+size_t.sizeof;
_memory = (enforce(malloc(size), "malloc failed")[0 .. size]);
_engine = _engine.dupTo(_memory[size_t.sizeof .. size]);
counter = 1;//points to new chunk
}
if (!_captures.unique)
{
// has external references - allocate new space
_captures.newMatches(_engine.re.ngroup);
}
_captures._nMatch = _engine.match(_captures.matches);
}
///ditto
auto save(){ return this; }
///Test if this match object is empty.
@property bool empty() const { return _captures._nMatch == 0; }
///Same as !(x.empty), provided for its convenience in conditional statements.
T opCast(T:bool)(){ return !empty; }
/// Same as .front, provided for compatibility with original std.regex.
@property auto captures() inout { return _captures; }
}
private @trusted auto matchOnce(alias Engine, RegEx, R)(R input, RegEx re)
{
import core.stdc.stdlib : malloc, free;
import std.exception : enforce;
alias Char = BasicElementOf!R;
alias EngineType = Engine!Char;
size_t size = EngineType.initialMemory(re);
void[] memory = enforce(malloc(size), "malloc failed")[0 .. size];
scope(exit) free(memory.ptr);
auto captures = Captures!(R, EngineType.DataIndex)(input, re.ngroup, re.dict);
auto engine = EngineType(re, Input!Char(input), memory);
static if (is(RegEx == StaticRegex!(BasicElementOf!R)))
engine.nativeFn = re.nativeFn;
captures._nMatch = engine.match(captures.matches);
return captures;
}
private auto matchMany(alias Engine, RegEx, R)(R input, RegEx re)
{
re.flags |= RegexOption.global;
return RegexMatch!(R, Engine)(input, re);
}
@system unittest
{
//sanity checks for new API
auto re = regex("abc");
assert(!"abc".matchOnce!(ThompsonMatcher)(re).empty);
assert("abc".matchOnce!(ThompsonMatcher)(re)[0] == "abc");
}
private enum isReplaceFunctor(alias fun, R) =
__traits(compiles, (Captures!R c) { fun(c); });
// the lowest level - just stuff replacements into the sink
private @trusted void replaceCapturesInto(alias output, Sink, R, T)
(ref Sink sink, R input, T captures)
if (isOutputRange!(Sink, dchar) && isSomeString!R)
{
if (captures.empty)
{
sink.put(input);
return;
}
sink.put(captures.pre);
// a hack to get around bogus errors, should be simply output(captures, sink)
// "is a nested function and cannot be accessed from"
static if (isReplaceFunctor!(output, R))
sink.put(output(captures)); //"mutator" type of function
else
output(captures, sink); //"output" type of function
sink.put(captures.post);
}
// ditto for a range of captures
private void replaceMatchesInto(alias output, Sink, R, T)
(ref Sink sink, R input, T matches)
if (isOutputRange!(Sink, dchar) && isSomeString!R)
{
size_t offset = 0;
foreach (cap; matches)
{
sink.put(cap.pre[offset .. $]);
// same hack, see replaceCapturesInto
static if (isReplaceFunctor!(output, R))
sink.put(output(cap)); //"mutator" type of function
else
output(cap, sink); //"output" type of function
offset = cap.pre.length + cap.hit.length;
}
sink.put(input[offset .. $]);
}
// a general skeleton of replaceFirst
private R replaceFirstWith(alias output, R, RegEx)(R input, RegEx re)
if (isSomeString!R && isRegexFor!(RegEx, R))
{
import std.array : appender;
auto data = matchFirst(input, re);
if (data.empty)
return input;
auto app = appender!(R)();
replaceCapturesInto!output(app, input, data);
return app.data;
}
// ditto for replaceAll
// the method parameter allows old API to ride on the back of the new one
private R replaceAllWith(alias output,
alias method=matchAll, R, RegEx)(R input, RegEx re)
if (isSomeString!R && isRegexFor!(RegEx, R))
{
import std.array : appender;
auto matches = method(input, re); //inout(C)[] fails
if (matches.empty)
return input;
auto app = appender!(R)();
replaceMatchesInto!output(app, input, matches);
return app.data;
}
/++
Start matching $(D input) to regex pattern $(D re),
using Thompson NFA matching scheme.
The use of this function is $(RED discouraged) - use either of
$(LREF matchAll) or $(LREF matchFirst).
Delegating the kind of operation
to "g" flag is soon to be phased out along with the
ability to choose the exact matching scheme. The choice of
matching scheme to use depends highly on the pattern kind and
can done automatically on case by case basis.
Returns: a $(D RegexMatch) object holding engine state after first match.
+/
public auto match(R, RegEx)(R input, RegEx re)
if (isSomeString!R && is(RegEx == Regex!(BasicElementOf!R)))
{
import std.regex.internal.thompson : ThompsonMatcher;
return RegexMatch!(Unqual!(typeof(input)),ThompsonMatcher)(input, re);
}
///ditto
public auto match(R, String)(R input, String re)
if (isSomeString!R && isSomeString!String)
{
import std.regex.internal.thompson : ThompsonMatcher;
return RegexMatch!(Unqual!(typeof(input)),ThompsonMatcher)(input, regex(re));
}
public auto match(R, RegEx)(R input, RegEx re)
if (isSomeString!R && is(RegEx == StaticRegex!(BasicElementOf!R)))
{
import std.regex.internal.backtracking : BacktrackingMatcher;
return RegexMatch!(Unqual!(typeof(input)),BacktrackingMatcher!true)(input, re);
}
/++
Find the first (leftmost) slice of the $(D input) that
matches the pattern $(D re). This function picks the most suitable
regular expression engine depending on the pattern properties.
$(D re) parameter can be one of three types:
$(UL
$(LI Plain string(s), in which case it's compiled to bytecode before matching. )
$(LI Regex!char (wchar/dchar) that contains a pattern in the form of
compiled bytecode. )
$(LI StaticRegex!char (wchar/dchar) that contains a pattern in the form of
compiled native machine code. )
)
Returns:
$(LREF Captures) containing the extent of a match together with all submatches
if there was a match, otherwise an empty $(LREF Captures) object.
+/
public auto matchFirst(R, RegEx)(R input, RegEx re)
if (isSomeString!R && is(RegEx == Regex!(BasicElementOf!R)))
{
import std.regex.internal.thompson : ThompsonMatcher;
return matchOnce!ThompsonMatcher(input, re);
}
///ditto
public auto matchFirst(R, String)(R input, String re)
if (isSomeString!R && isSomeString!String)
{
import std.regex.internal.thompson : ThompsonMatcher;
return matchOnce!ThompsonMatcher(input, regex(re));
}
///ditto
public auto matchFirst(R, String)(R input, String[] re...)
if (isSomeString!R && isSomeString!String)
{
import std.regex.internal.thompson : ThompsonMatcher;
return matchOnce!ThompsonMatcher(input, regex(re));