1Regex::Element(3) User Contributed Perl Documentation Regex::Element(3)
2
6 YAPE::Regex::Element - sub-classes for YAPE::Regex elements
7
9 use YAPE::Regex 'MyExt::Mod';
10 # this sets up inheritence in MyExt::Mod
11 # see YAPE::Regex documentation
12
14 The "YAPE" hierarchy of modules is an attempt at a unified means of
15 parsing and extracting content. It attempts to maintain a generic
16 interface, to promote simplicity and reusability. The API is powerful,
17 yet simple. The modules do tokenization (which can be intercepted) and
18 build trees, so that extraction of specific nodes is doable.
19
21 This module provides the classes for the "YAPE::Regex" objects. The
22 base class for these objects is "YAPE::Regex::Element". The objects
23 classes are numerous.
24 Methods for "YAPE::Regex::Element"
26 This class contains fallback methods for the other classes.
27 · "my $str = $obj->text;"
29 Returns a string representation of the content of the regex node
31 itself, not any nodes contained in it. This is "undef" for non-
32 text nodes.
33 · "my $str = $obj->string;"
35 Returns a string representation of the regex node itself, not any
37 nodes contained in it.
38 · "my $str = $obj->fullstring;"
40 Returns a string representation of the regex node, including any
42 nodes contained in it.
43 · "my $quant = $obj->quant;"
45 Returns a string with the quantity, and a "?" if the node is non-
47 greedy. The quantity is one of "*", "+", "?", "{M,N}", or an empty
48 string.
49 · "my $ng = $obj->ngreed;"
51 Returns a "?" if the node is non-greedy, and an empty string
53 otherwise.
54 Methods for "YAPE::Regex::anchor"
56 This class represents anchors. Objects have the following methods:
57 · "my $anchor = YAPE::Regex::anchor->new($type,$q,$ng);"
59 Creates a "YAPE::Regex::anchor" object. Takes three arguments:
61 the anchor ("^", "\A", "$", "\Z", "\z", "\B", "\b", or "\G"), the
62 quantity, and the non-greedy flag. The quantity should be an empty
63 string.
64 my $anc = YAPE::Regex::anchor->new('\A', '', '?');
66 # /\A?/
67 · "my $type = $anchor->type;"
69 Returns the string "anchor".
71 Methods for "YAPE::Regex::macro"
73 This class represents character-class macros. Objects have the
74 following methods:
75 · "my $macro = YAPE::Regex::macro->new($type,$q,$ng);"
77 Creates a "YAPE::Regex::macro" object. Takes three arguments: the
79 macro ("w", "W", "d", "D", "s", or "S"), the quantity, and the non-
80 greedy flag.
81 my $macro = YAPE::Regex::macro->new('s', '{3,5}');
83 # /\s{3,5}/
84 · "my $text = $macro->text;"
86 Returns the macro.
88 print $macro->text; # '\s'
90 · "my $type = $macro->type;"
92 Returns the string "macro".
94 Methods for "YAPE::Regex::oct"
96 This class represents octal escapes. Objects have the following
97 methods:
98 · "my $oct = YAPE::Regex::oct->new($type,$q,$ng);"
100 Creates a "YAPE::Regex::oct" object. Takes three arguments: the
102 octal number (as a string), the quantity, and the non-greedy flag.
103 my $oct = YAPE::Regex::oct->new('040');
105 # /\040/
106 · "my $text = $oct->text;"
108 Returns the octal escape.
110 print $oct->text; # '\040'
112 · "my $type = $oct->type;"
114 Returns the string "oct".
116 Methods for "YAPE::Regex::hex"
118 This class represents hexadecimal escapes. Objects have the following
119 methods:
120 · "my $hex = YAPE::Regex::hex->new($type,$q,$ng);"
122 Creates a "YAPE::Regex::hex" object. Takes three arguments: the
124 hexadecimal number (as a string), the quantity, and the non-greedy
125 flag.
126 my $hex = YAPE::Regex::hex->new('20','{2,}');
128 # /\x20{2,}/
129 · "my $text = $hex->text;"
131 Returns the hexadecimal escape.
133 print $hex->text; # '\x20'
135 · "my $type = $hex->type;"
137 Returns the string "hex".
139 Methods for "YAPE::Regex::utf8hex"
141 This class represents UTF hexadecimal escapes. Objects have the
142 following methods:
143 · "my $hex = YAPE::Regex::utf8hex->new($type,$q,$ng);"
145 Creates a "YAPE::Regex::utf8hex" object. Takes three arguments:
147 the hexadecimal number (as a string), the quantity, and the non-
148 greedy flag.
149 my $utf8hex = YAPE::Regex::utf8hex->new('beef','{0,4}');
151 # /\x{beef}{2,}/
152 · "my $text = $utf8hex->text;"
154 Returns the hexadecimal escape.
156 print $utf8hex->text; # '\x{beef}'
158 · "my $type = $utf8hex->type;"
160 Returns the string "utf8hex".
162 Methods for "YAPE::Regex::backref"
164 This class represents back-references. Objects have the following
165 methods:
166 · "my $bref = YAPE::Regex::bref->new($type,$q,$ng);"
168 Creates a "YAPE::Regex::bref" object. Takes three arguments: the
170 number of the back-reference, the quantity, and the non-greedy
171 flag.
172 my $bref = YAPE::Regex::bref->new(2,'','?');
174 # /\2?/
175 · "my $text = $bref->text;"
177 Returns the backescape.
179 print $bref->text; # '\2'
181 · "my $type = $bref->type;"
183 Returns the string "backref".
185 Methods for "YAPE::Regex::ctrl"
187 This class represents control character escapes. Objects have the
188 following methods:
189 · "my $ctrl = YAPE::Regex::ctrl->new($type,$q,$ng);"
191 Creates a "YAPE::Regex::ctrl" object. Takes three arguments: the
193 control character, the quantity, and the non-greedy flag.
194 my $ctrl = YAPE::Regex::ctrl->new('M');
196 # /\cM/
197 · "my $text = $ctrl->text;"
199 Returns the control character escape.
201 print $ctrl->text; # '\cM'
203 · "my $type = $ctrl->type;"
205 Returns the string "ctrl".
207 Methods for "YAPE::Regex::named"
209 This class represents named characters. Objects have the following
210 methods:
211 · "my $ctrl = YAPE::Regex::named->new($type,$q,$ng);"
213 Creates a "YAPE::Regex::named" object. Takes three arguments: the
215 name of the character, the quantity, and the non-greedy flag.
216 my $named = YAPE::Regex::named->new('GREEK SMALL LETTER BETA');
218 # /\N{GREEK SMALL LETTER BETA}/
219 · "my $text = $named->text;"
221 Returns the character escape text.
223 print $named->text; # '\N{GREEK SMALL LETTER BETA}'
225 · "my $type = $named->type;"
227 Returns the string "named".
229 Methods for "YAPE::Regex::Cchar"
231 This class represents C characters. Objects have the following
232 methods:
233 · "my $ctrl = YAPE::Regex::Cchar->new($q,$ng);"
235 Creates a "YAPE::Regex::Cchar" object. Takes two arguments: the
237 quantity and the non-greedy flag.
238 my $named = YAPE::Regex::Char->new(2);
240 # /\C{2}/
241 · "my $text = $Cchar->text;"
243 Returns the escape sequence.
245 print $Cchar->text; # '\C'
247 · "my $type = $Cchar->type;"
249 Returns the string "Cchar".
251 Methods for "YAPE::Regex::slash"
253 This class represents any other escaped characters. Objects have the
254 following methods:
255 · "my $slash = YAPE::Regex::slash->new($type,$q,$ng);"
257 Creates a "YAPE::Regex::slash" object. Takes three arguments: the
259 backslashed character, the quantity, and the non-greedy flag.
260 my $slash = YAPE::Regex::slash->new('t','','?');
262 # /\t?/
263 · "my $text = $slash->text;"
265 Returns the escaped character.
267 print $slash->text; # '\t'
269 · "my $type = $slash->type;"
271 Returns the string "slash".
273 Methods for "YAPE::Regex::any"
275 This class represents the dot metacharacter. Objects have the
276 following methods:
277 · "my $any = YAPE::Regex::any->new($q,$ng);"
279 Creates a "YAPE::Regex::any" object. Takes two arguments: the
281 quantity, and the non-greedy flag.
282 my $any = YAPE::Regex::any->new('{1,3}');
284 # /.{1,3}/
285 · "my $type = $any->type;"
287 Returns the string "any".
289 Methods for "YAPE::Regex::class"
291 This class represents character classes. Objects have the following
292 methods:
293 · "my $class = YAPE::Regex::class->new($chars,$neg,$q,$ng);"
295 Creates a "YAPE::Regex::class" object. Takes four arguments: the
297 characters in the class, a "^" if the class is negated (an empty
298 string otherwise), the quantity, and the non-greedy flag.
299 my $class = YAPE::Regex::class->new('aeiouy','^');
301 # /[^aeiouy]/
302 · "my $text = $class->text;"
304 Returns the character class.
306 print $class->text; # [^aeiouy]
308 · "my $type = $class->type;"
310 Returns the string "class".
312 Methods for "YAPE::Regex::hex"
314 This class represents hexadecimal escapes. Objects have the following
315 methods:
316 · "my $text = YAPE::Regex::text->new($text,$q,$ng);"
318 Creates a "YAPE::Regex::text" object. Takes three arguments: the
320 text, the quantity, and the non-greedy flag. The quantity and non-
321 greedy modifier should only be present for single-character text,
322 because of the way the parser renders the quantity and non-greedy
323 modifier.
324 my $text = YAPE::Regex::text->new('alphabet','');
326 # /alphabet/
327 my $text = YAPE::Regex::text->new('x','?','?');
329 # /x??/
330 · "my $type = $text->type;"
332 Returns the string "text".
334 Methods for "YAPE::Regex::alt"
336 This class represents alternation. Objects have the following methods:
337 · "my $alt = YAPE::Regex::alt->new;"
339 Creates a "YAPE::Regex::alt" object.
341 my $alt = YAPE::Regex::alt->new;
343 # /|/
344 · "my $type = $oct->type;"
346 Returns the string "alt".
348 Methods for "YAPE::Regex::comment"
350 This class represents in-line comments. Objects have the following
351 methods:
352 · "my $comment = YAPE::Regex::comment->new($comment,$x);"
354 Creates a "YAPE::Regex::comment" object. Takes two arguments: the
356 text of the comment, and whether or not the "/x" regex modifier is
357 in effect for this comment. Note that Perl's regex engine will
358 stop a "(?#...)" comment at the first ")", regardless of what you
359 do.
360 my $comment = YAPE::Regex::comment->new(
362 "match an optional string of digits"
363 );
364 # /(?#match an optional string of digits)/
365 my $comment = YAPE::Regex::comment->new(
367 "match an optional string of digits",
368 1
369 );
370 # /# match an optional string of digits/
371 · "my $type = $comment->type;"
373 Returns the string "comment".
375 · "my $x_on = $comment->xcomm;"
377 Returns true or false, depending on whether the comment is under
379 the "/x" regex modifier.
380 Methods for "YAPE::Regex::whitespace"
382 This class represents whitespace under the "/x" regex modifier.
383 Objects have the following methods:
384 · "my $ws = YAPE::Regex::whitespace->new($text);"
386 Creates a "YAPE::Regex::whitespace" object. Takes one argument:
388 the text of the whitespace.
389 my $ws = YAPE::Regex::whitespace->new(' ');
391 # / /x
392 · "my $text = $ws->text;"
394 Returns the whitespace.
396 print $ws->text; # ' '
398 · "my $type = $ws->type;"
400 Returns the string "whitespace".
402 Methods for "YAPE::Regex::flags"
404 This class represents "(?ismx)" flags. Objects have the following
405 methods:
406 · "my $flags = YAPE::Regex::flags->new($add,$sub);"
408 Creates a "YAPE::Regex::flags" object. Takes two arguments: a
410 string of the modes to have on, and a string of the modes to
411 explicitly turn off. The flags are displayed in alphabetical
412 order.
413 my $flags = YAPE::Regex::flags->new('is','m');
415 # /(?is-m)/
416 · "my $type = $flags->type;"
418 Returns the string "flags".
420 Methods for "YAPE::Regex::cut"
422 This class represents the cut assertion. Objects have the following
423 methods:
424 · "my $look = YAPE::Regex::cut->new(\@nodes);"
426 Creates a "YAPE::Regex::cut" object. Takes one arguments: a
428 reference to an array of objects to be contained in the cut.
429 my $REx = YAPE::Regex::class->new('aeiouy','','+');
431 my $look = YAPE::Regex::cut->new(0,[$REx]);
432 # /(?>[aeiouy]+)/
433 · "my $type = $cut->type;"
435 Returns the string "cut".
437 Methods for "YAPE::Regex::lookahead"
439 This class represents lookaheads. Objects have the following methods:
440 · "my $look = YAPE::Regex::lookahead->new($pos,\@nodes);"
442 Creates a "YAPE::Regex::lookahead" object. Takes two arguments: a
444 boolean value indicating whether or not the lookahead is positive,
445 and a reference to an array of objects to be contained in the
446 lookahead.
447 my $REx = YAPE::Regex::class->new('aeiouy');
449 my $look = YAPE::Regex::lookahead->new(0,[$REx]);
450 # /(?![aeiouy])/
451 · "my $pos = $look->pos;"
453 Returns true if the lookahead is positive.
455 print $look->pos ? 'pos' : 'neg'; # 'neg'
457 · "my $type = $look->type;"
459 Returns the string "lookahead(pos)" or "lookahead(neg)".
461 Methods for "YAPE::Regex::lookbehind"
463 This class represents lookbehinds. Objects have the following methods:
464 · "my $look = YAPE::Regex::lookbehind->new($pos,\@nodes);"
466 Creates a "YAPE::Regex::lookbehind" object. Takes two arguments:
468 a boolean value indicating whether or not the lookbehind is
469 positive, and a reference to an array of objects to be contained in
470 the lookbehind.
471 my $REx = YAPE::Regex::class->new('aeiouy','^');
473 my $look = YAPE::Regex::lookbehind->new(1,[$REx]);
474 # /(?<=[^aeiouy])/
475 · "my $pos = $look->pos;"
477 Returns true if the lookbehind is positive.
479 print $look->pos ? 'pos' : 'neg'; # 'pos'
481 · "my $type = $look->type;"
483 Returns the string "lookbehind(pos)" or "lookbehind(neg)".
485 Methods for "YAPE::Regex::conditional"
487 This class represents conditionals. Objects have the following
488 methods:
489 · "my $cond = YAPE::Regex::conditional->new($br,$t,$f,$q,$ng);"
491 Creates a "YAPE::Regex::hex" object. Takes five arguments: the
493 number of the back-reference (that's all that's supported in the
494 current version), an array reference to the "true" pattern, an
495 array reference to the "false" pattern, and the quantity and non-
496 greedy flag.
497 my $cond = YAPE::Regex::conditional->new(
499 2,
500 [],
501 [ YAPE::Regex::text->new('foo') ],
502 '?',
503 );
504 # /(?(2)|foo)?/
505 · "my $br = $cond->backref;"
507 Returns the number of the back-reference the conditional depends
509 on.
510 print $br->backref; # 2
512 · "my $type = $cond->type;"
514 Returns the string "conditional(N)", where N is the number of the
516 back-reference.
517 Methods for "YAPE::Regex::group"
519 This class represents non-capturing groups. Objects have the following
520 methods:
521 · "my $group = YAPE::Regex::group->new($on,$off,\@nodes,$q,$ng);"
523 Creates a "YAPE::Regex::group" object. Takes five arguments: the
525 modes turned on, the modes explicitly turned off, a reference to an
526 array of objects in the group, the quantity, and the non-greedy
527 flag. The modes are displayed in alphabetical order.
528 my $group = YAPE::Regex::group->new(
530 'i',
531 's',
532 [
533 YAPE::Regex::macro->new('d', '{2}'),
534 YAPE::Regex::macro->new('s'),
535 YAPE::Regex::macro->new('d', '{2}'),
536 ],
537 '?',
538 );
539 # /(?i-s:\d{2}\s\d{2})?/
540 · "my $type = $group->type;"
542 Returns the string "group".
544 Methods for "YAPE::Regex::capture"
546 This class represents capturing groups. Objects have the following
547 methods:
548 · "my $capture = YAPE::Regex::capture->new(\@nodes,$q,$ng);"
550 Creates a "YAPE::Regex::capture" object. Takes three arguments: a
552 reference to an array of objects in the group, the quantity, and
553 the non-greedy flag.
554 my $capture = YAPE::Regex::capture->new(
556 [
557 YAPE::Regex::macro->new('d', '{2}'),
558 YAPE::Regex::macro->new('s'),
559 YAPE::Regex::macro->new('d', '{2}'),
560 ],
561 );
562 # /(\d{2}\s\d{2})/
563 · "my $type = $capture->type;"
565 Returns the string "capture".
567 Methods for "YAPE::Regex::code"
569 This class represents code blocks. Objects have the following methods:
570 · "my $code = YAPE::Regex::code->new($block);"
572 Creates a "YAPE::Regex::code" object. Takes one arguments: a
574 string holding a block of code.
575 my $code = YAPE::Regex::code->new(q({ push @poss, $1 }));
577 # /(?{ push @poss, $1 })/
578 · "my $type = $code->type;"
580 Returns the string "code".
582 Methods for "YAPE::Regex::later"
584 This class represents closed parentheses. Objects have the following
585 methods:
586 · "my $later = YAPE::Regex::later->new($block);"
588 Creates a "YAPE::Regex::later" object. Takes one arguments: a
590 string holding a block of code.
591 my $later = YAPE::Regex::later->new(q({ push @poss, $1 }));
593 # /(?{{ push @poss, $1 }})/
594 · "my $type = $later->type;"
596 Returns the string "later".
598 Methods for "YAPE::Regex::close"
600 This class represents closed parentheses. Objects have the following
601 methods:
602 · "my $close = YAPE::Regex::close->new($q,$ng);"
604 Creates a "YAPE::Regex::close" object. Takes two arguments: the
606 quantity, and the non-greedy flag. This object is never needed in
607 the tree; however, they are returned in the parsing stage, so that
608 you know when they've been reached.
609 my $close = YAPE::Regex::close->new('?','?');
611 # /)??/
612 · "my $type = $close->type;"
614 Returns the string "close".
616
618 This is a listing of things to add to future versions of this module.
619 · None!
621
623 Following is a list of known or reported bugs.
624 · This documentation might be incomplete.
626
628 Visit "YAPE"'s web site at http://www.pobox.com/~japhy/YAPE/.
629
631 The "YAPE::Regex" documentation, for information on the main class.
632
634 Jeff "japhy" Pinyan
635 CPAN ID: PINYAN
636 japhy@pobox.com
637 http://www.pobox.com/~japhy/
638perl v5.12.1 2001-05-03 Regex::Element(3)