File Coverage

blib/lib/Syntax/Highlight/Engine/Kate/Perl.pm
Criterion Covered Total %
statement 367 711 51.6
branch 275 556 49.4
condition 1 3 33.3
subroutine 38 70 54.2
pod 0 67 0.0
total 681 1407 48.4


line stmt bran cond sub pod time code
1             # Copyright (c) 2005 - 2006 Hans Jeuken. All rights reserved.
2             # This program is free software; you can redistribute it and/or
3             # modify it under the same terms as Perl itself.
4              
5             # This file was generated from the 'perl.xml' file of the syntax highlight
6             # engine of the kate text editor (http://www.kate-editor.org
7              
8             #kate xml version 1.20
9             #kate version 2.4
10             #kate author Anders Lund (anders@alweb.dk)
11             #generated: Sun Feb 3 22:02:05 2008, localtime
12              
13             package Syntax::Highlight::Engine::Kate::Perl;
14              
15             our $VERSION = '0.07';
16              
17 4     4   25 use strict;
  4         7  
  4         209  
18 4     4   24 use warnings;
  4         8  
  4         158  
19 4     4   24 use base('Syntax::Highlight::Engine::Kate::Template');
  4         9  
  4         53116  
20              
21             sub new {
22 8     8 0 641 my $proto = shift;
23 8   33     75 my $class = ref($proto) || $proto;
24 8         76 my $self = $class->SUPER::new(@_);
25 8         227 $self->attributes({
26             'Comment' => 'Comment',
27             'Data' => 'Normal',
28             'Data Type' => 'DataType',
29             'Decimal' => 'DecVal',
30             'Float' => 'Float',
31             'Function' => 'Function',
32             'Hex' => 'BaseN',
33             'Keyword' => 'Keyword',
34             'Normal Text' => 'Normal',
35             'Nothing' => 'Comment',
36             'Octal' => 'BaseN',
37             'Operator' => 'Operator',
38             'Pattern' => 'Others',
39             'Pattern Character Class' => 'BaseN',
40             'Pattern Internal Operator' => 'Char',
41             'Pod' => 'Comment',
42             'Pragma' => 'Keyword',
43             'Special Variable' => 'Variable',
44             'String' => 'String',
45             'String (interpolated)' => 'String',
46             'String Special Character' => 'Char',
47             });
48 8         144 $self->listAdd('functions',
49             'abs',
50             'accept',
51             'alarm',
52             'atan2',
53             'bind',
54             'binmode',
55             'bless',
56             'caller',
57             'chdir',
58             'chmod',
59             'chomp',
60             'chop',
61             'chown',
62             'chr',
63             'chroot',
64             'close',
65             'closedir',
66             'connect',
67             'cos',
68             'crypt',
69             'dbmclose',
70             'dbmopen',
71             'defined',
72             'delete',
73             'die',
74             'dump',
75             'endgrent',
76             'endhostent',
77             'endnetent',
78             'endprotoent',
79             'endpwent',
80             'endservent',
81             'eof',
82             'eval',
83             'exec',
84             'exists',
85             'exit',
86             'exp',
87             'fcntl',
88             'fileno',
89             'flock',
90             'fork',
91             'format',
92             'formline',
93             'getc',
94             'getgrent',
95             'getgrgid',
96             'getgrnam',
97             'gethostbyaddr',
98             'gethostbyname',
99             'gethostent',
100             'getlogin',
101             'getnetbyaddr',
102             'getnetbyname',
103             'getnetent',
104             'getpeername',
105             'getpgrp',
106             'getppid',
107             'getpriority',
108             'getprotobyname',
109             'getprotobynumber',
110             'getprotoent',
111             'getpwent',
112             'getpwnam',
113             'getpwuid',
114             'getservbyname',
115             'getservbyport',
116             'getservent',
117             'getsockname',
118             'getsockopt',
119             'glob',
120             'gmtime',
121             'goto',
122             'grep',
123             'hex',
124             'import',
125             'index',
126             'int',
127             'ioctl',
128             'join',
129             'keys',
130             'kill',
131             'last',
132             'lc',
133             'lcfirst',
134             'length',
135             'link',
136             'listen',
137             'localtime',
138             'lock',
139             'log',
140             'lstat',
141             'map',
142             'mkdir',
143             'msgctl',
144             'msgget',
145             'msgrcv',
146             'msgsnd',
147             'oct',
148             'open',
149             'opendir',
150             'ord',
151             'pack',
152             'package',
153             'pipe',
154             'pop',
155             'pos',
156             'print',
157             'printf',
158             'prototype',
159             'push',
160             'quotemeta',
161             'rand',
162             'read',
163             'readdir',
164             'readline',
165             'readlink',
166             'recv',
167             'redo',
168             'ref',
169             'rename',
170             'reset',
171             'return',
172             'reverse',
173             'rewinddir',
174             'rindex',
175             'rmdir',
176             'scalar',
177             'seek',
178             'seekdir',
179             'select',
180             'semctl',
181             'semget',
182             'semop',
183             'send',
184             'setgrent',
185             'sethostent',
186             'setnetent',
187             'setpgrp',
188             'setpriority',
189             'setprotoent',
190             'setpwent',
191             'setservent',
192             'setsockopt',
193             'shift',
194             'shmctl',
195             'shmget',
196             'shmread',
197             'shmwrite',
198             'shutdown',
199             'sin',
200             'sleep',
201             'socket',
202             'socketpair',
203             'sort',
204             'splice',
205             'split',
206             'sprintf',
207             'sqrt',
208             'srand',
209             'stat',
210             'study',
211             'sub',
212             'substr',
213             'symlink',
214             'syscall',
215             'sysread',
216             'sysseek',
217             'system',
218             'syswrite',
219             'tell',
220             'telldir',
221             'tie',
222             'time',
223             'times',
224             'truncate',
225             'uc',
226             'ucfirst',
227             'umask',
228             'undef',
229             'unlink',
230             'unpack',
231             'unshift',
232             'untie',
233             'utime',
234             'values',
235             'vec',
236             'wait',
237             'waitpid',
238             'wantarray',
239             'warn',
240             'write',
241             );
242 8         54 $self->listAdd('keywords',
243             'BEGIN',
244             'END',
245             '__DATA__',
246             '__END__',
247             '__FILE__',
248             '__LINE__',
249             '__PACKAGE__',
250             'break',
251             'continue',
252             'do',
253             'each',
254             'else',
255             'elsif',
256             'for',
257             'foreach',
258             'if',
259             'last',
260             'local',
261             'my',
262             'next',
263             'no',
264             'our',
265             'package',
266             'require',
267             'require',
268             'return',
269             'sub',
270             'unless',
271             'until',
272             'use',
273             'while',
274             );
275 8         58 $self->listAdd('operators',
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             'and',
305             'eq',
306             'ne',
307             'not',
308             'or',
309             '|',
310             '|=',
311             '||',
312             '||=',
313             '~=',
314             );
315 8         36 $self->listAdd('pragmas',
316             'bytes',
317             'constant',
318             'diagnostics',
319             'english',
320             'filetest',
321             'integer',
322             'less',
323             'locale',
324             'open',
325             'sigtrap',
326             'strict',
327             'subs',
328             'utf8',
329             'vars',
330             'warnings',
331             );
332 8         1594 $self->contextdata({
333             'Backticked' => {
334             callback => \&parseBackticked,
335             attribute => 'String (interpolated)',
336             },
337             'comment' => {
338             callback => \&parsecomment,
339             attribute => 'Comment',
340             lineending => '#pop',
341             },
342             'data_handle' => {
343             callback => \&parsedata_handle,
344             attribute => 'Data',
345             },
346             'end_handle' => {
347             callback => \&parseend_handle,
348             attribute => 'Nothing',
349             },
350             'find_here_document' => {
351             callback => \&parsefind_here_document,
352             attribute => 'Normal Text',
353             lineending => '#pop',
354             },
355             'find_pattern' => {
356             callback => \&parsefind_pattern,
357             attribute => 'Pattern',
358             },
359             'find_qqx' => {
360             callback => \&parsefind_qqx,
361             attribute => 'Normal Text',
362             },
363             'find_quoted' => {
364             callback => \&parsefind_quoted,
365             attribute => 'Normal Text',
366             },
367             'find_qw' => {
368             callback => \&parsefind_qw,
369             attribute => 'Normal Text',
370             },
371             'find_subst' => {
372             callback => \&parsefind_subst,
373             attribute => 'Normal Text',
374             },
375             'find_variable' => {
376             callback => \&parsefind_variable,
377             attribute => 'Data Type',
378             lineending => '#pop',
379             fallthrough => '#pop',
380             },
381             'find_variable_unsafe' => {
382             callback => \&parsefind_variable_unsafe,
383             attribute => 'Data Type',
384             lineending => '#pop',
385             fallthrough => '#pop',
386             },
387             'here_document' => {
388             callback => \&parsehere_document,
389             attribute => 'String (interpolated)',
390             dynamic => 1,
391             },
392             'here_document_dumb' => {
393             callback => \&parsehere_document_dumb,
394             attribute => 'Normal Text',
395             dynamic => 1,
396             },
397             'ip_string' => {
398             callback => \&parseip_string,
399             attribute => 'String (interpolated)',
400             },
401             'ip_string_2' => {
402             callback => \&parseip_string_2,
403             attribute => 'String (interpolated)',
404             },
405             'ip_string_3' => {
406             callback => \&parseip_string_3,
407             attribute => 'String (interpolated)',
408             },
409             'ip_string_4' => {
410             callback => \&parseip_string_4,
411             attribute => 'String (interpolated)',
412             },
413             'ip_string_5' => {
414             callback => \&parseip_string_5,
415             attribute => 'String (interpolated)',
416             },
417             'ip_string_6' => {
418             callback => \&parseip_string_6,
419             attribute => 'String (interpolated)',
420             dynamic => 1,
421             },
422             'ipstring_internal' => {
423             callback => \&parseipstring_internal,
424             attribute => 'String (interpolated)',
425             },
426             'normal' => {
427             callback => \&parsenormal,
428             attribute => 'Normal Text',
429             },
430             'package_qualified_blank' => {
431             callback => \&parsepackage_qualified_blank,
432             attribute => 'Normal Text',
433             },
434             'pat_char_class' => {
435             callback => \&parsepat_char_class,
436             attribute => 'Pattern Character Class',
437             },
438             'pat_ext' => {
439             callback => \&parsepat_ext,
440             attribute => 'Pattern Internal Operator',
441             },
442             'pattern' => {
443             callback => \&parsepattern,
444             attribute => 'Pattern',
445             dynamic => 1,
446             },
447             'pattern_brace' => {
448             callback => \&parsepattern_brace,
449             attribute => 'Pattern',
450             },
451             'pattern_bracket' => {
452             callback => \&parsepattern_bracket,
453             attribute => 'Pattern',
454             },
455             'pattern_paren' => {
456             callback => \&parsepattern_paren,
457             attribute => 'Pattern',
458             },
459             'pattern_slash' => {
460             callback => \&parsepattern_slash,
461             attribute => 'Pattern',
462             },
463             'pattern_sq' => {
464             callback => \&parsepattern_sq,
465             attribute => 'Pattern',
466             },
467             'pod' => {
468             callback => \&parsepod,
469             attribute => 'Pod',
470             },
471             'quote_word' => {
472             callback => \&parsequote_word,
473             attribute => 'Normal Text',
474             dynamic => 1,
475             },
476             'quote_word_brace' => {
477             callback => \&parsequote_word_brace,
478             attribute => 'Normal Text',
479             },
480             'quote_word_bracket' => {
481             callback => \&parsequote_word_bracket,
482             attribute => 'Normal Text',
483             },
484             'quote_word_paren' => {
485             callback => \&parsequote_word_paren,
486             attribute => 'Normal Text',
487             },
488             'regex_pattern_internal' => {
489             callback => \&parseregex_pattern_internal,
490             attribute => 'Pattern',
491             },
492             'regex_pattern_internal_ip' => {
493             callback => \&parseregex_pattern_internal_ip,
494             attribute => 'Pattern',
495             },
496             'regex_pattern_internal_rules_1' => {
497             callback => \&parseregex_pattern_internal_rules_1,
498             },
499             'regex_pattern_internal_rules_2' => {
500             callback => \&parseregex_pattern_internal_rules_2,
501             },
502             'slash_safe_escape' => {
503             callback => \&parseslash_safe_escape,
504             attribute => 'Normal Text',
505             lineending => '#pop',
506             fallthrough => '#pop',
507             },
508             'string' => {
509             callback => \&parsestring,
510             attribute => 'String',
511             },
512             'string_2' => {
513             callback => \&parsestring_2,
514             attribute => 'String',
515             },
516             'string_3' => {
517             callback => \&parsestring_3,
518             attribute => 'String',
519             },
520             'string_4' => {
521             callback => \&parsestring_4,
522             attribute => 'String',
523             },
524             'string_5' => {
525             callback => \&parsestring_5,
526             attribute => 'String',
527             },
528             'string_6' => {
529             callback => \&parsestring_6,
530             attribute => 'String',
531             dynamic => 1,
532             },
533             'sub_arg_definition' => {
534             callback => \&parsesub_arg_definition,
535             attribute => 'Normal Text',
536             fallthrough => '#pop#pop',
537             },
538             'sub_name_def' => {
539             callback => \&parsesub_name_def,
540             attribute => 'Normal Text',
541             lineending => '#pop',
542             fallthrough => '#pop',
543             },
544             'subst_bracket_pattern' => {
545             callback => \&parsesubst_bracket_pattern,
546             attribute => 'Pattern',
547             },
548             'subst_bracket_replace' => {
549             callback => \&parsesubst_bracket_replace,
550             attribute => 'String (interpolated)',
551             },
552             'subst_curlybrace_middle' => {
553             callback => \&parsesubst_curlybrace_middle,
554             attribute => 'Normal Text',
555             },
556             'subst_curlybrace_pattern' => {
557             callback => \&parsesubst_curlybrace_pattern,
558             attribute => 'Pattern',
559             },
560             'subst_curlybrace_replace' => {
561             callback => \&parsesubst_curlybrace_replace,
562             attribute => 'String (interpolated)',
563             },
564             'subst_curlybrace_replace_recursive' => {
565             callback => \&parsesubst_curlybrace_replace_recursive,
566             attribute => 'String (interpolated)',
567             },
568             'subst_paren_pattern' => {
569             callback => \&parsesubst_paren_pattern,
570             attribute => 'Pattern',
571             },
572             'subst_paren_replace' => {
573             callback => \&parsesubst_paren_replace,
574             attribute => 'String (interpolated)',
575             },
576             'subst_slash_pattern' => {
577             callback => \&parsesubst_slash_pattern,
578             attribute => 'Pattern',
579             dynamic => 1,
580             },
581             'subst_slash_replace' => {
582             callback => \&parsesubst_slash_replace,
583             attribute => 'String (interpolated)',
584             dynamic => 1,
585             },
586             'subst_sq_pattern' => {
587             callback => \&parsesubst_sq_pattern,
588             attribute => 'Pattern',
589             },
590             'subst_sq_replace' => {
591             callback => \&parsesubst_sq_replace,
592             attribute => 'String',
593             },
594             'tr' => {
595             callback => \&parsetr,
596             attribute => 'Pattern',
597             lineending => '#pop',
598             fallthrough => '#pop',
599             },
600             'var_detect' => {
601             callback => \&parsevar_detect,
602             attribute => 'Data Type',
603             lineending => '#pop#pop',
604             fallthrough => '#pop#pop',
605             },
606             'var_detect_rules' => {
607             callback => \&parsevar_detect_rules,
608             attribute => 'Data Type',
609             lineending => '#pop#pop',
610             },
611             'var_detect_unsafe' => {
612             callback => \&parsevar_detect_unsafe,
613             attribute => 'Data Type',
614             lineending => '#pop#pop',
615             fallthrough => '#pop#pop',
616             },
617             });
618 8         2307 $self->deliminators('\\s||\\.|\\(|\\)|:|\\!|\\+|,|-|<|=|>|\\%|\\&|\\*|\\/|;|\\?|\\[|\\]|\\^|\\{|\\||\\}|\\~|\\\\');
619 8         58 $self->basecontext('normal');
620 8         262 $self->keywordscase(0);
621 8         199 $self->initialize;
622 8         549 bless ($self, $class);
623 8         75 return $self;
624             }
625              
626             sub language {
627 0     0 0 0 return 'Perl';
628             }
629              
630             sub parseBackticked {
631 0     0 0 0 my ($self, $text) = @_;
632             # context => 'ipstring_internal'
633             # type => 'IncludeRules'
634 0 0       0 if ($self->includeRules('ipstring_internal', $text)) {
635 0         0 return 1
636             }
637             # attribute => 'Operator'
638             # char => '`'
639             # context => '#pop'
640             # type => 'DetectChar'
641 0 0       0 if ($self->testDetectChar($text, '`', 0, 0, 0, undef, 0, '#pop', 'Operator')) {
642 0         0 return 1
643             }
644 0         0 return 0;
645             };
646              
647             sub parsecomment {
648 1807     1807 0 2550 my ($self, $text) = @_;
649             # type => 'DetectSpaces'
650 1807 100       6199 if ($self->testDetectSpaces($text, 0, undef, 0, '#stay', undef)) {
651 82         224 return 1
652             }
653             # context => '##Alerts'
654             # type => 'IncludeRules'
655 1725 100       5536 if ($self->includePlugin('Alerts', $text)) {
656 2         8 return 1
657             }
658             # type => 'DetectIdentifier'
659 1723 100       5880 if ($self->testDetectIdentifier($text, 0, undef, 0, '#stay', undef)) {
660 480         1392 return 1
661             }
662 1243         2939 return 0;
663             };
664              
665             sub parsedata_handle {
666 0     0 0 0 my ($self, $text) = @_;
667             # String => '\=(?:head[1-6]|over|back|item|for|begin|end|pod)\s+.*'
668             # attribute => 'Pod'
669             # beginRegion => 'POD'
670             # column => '0'
671             # context => 'pod'
672             # type => 'RegExpr'
673 0 0       0 if ($self->testRegExpr($text, '\\=(?:head[1-6]|over|back|item|for|begin|end|pod)\\s+.*', 0, 0, 0, 0, 0, 'pod', 'Pod')) {
674 0         0 return 1
675             }
676             # String => '__END__'
677             # attribute => 'Keyword'
678             # context => 'normal'
679             # firstNonSpace => 'true'
680             # type => 'StringDetect'
681 0 0       0 if ($self->testStringDetect($text, '__END__', 0, 0, 0, undef, 1, 'normal', 'Keyword')) {
682 0         0 return 1
683             }
684 0         0 return 0;
685             };
686              
687             sub parseend_handle {
688 0     0 0 0 my ($self, $text) = @_;
689             # String => '^\=(?:head[1-6]|over|back|item|for|begin|end|pod)\s*.*'
690             # attribute => 'Pod'
691             # context => 'pod'
692             # type => 'RegExpr'
693 0 0       0 if ($self->testRegExpr($text, '^\\=(?:head[1-6]|over|back|item|for|begin|end|pod)\\s*.*', 0, 0, 0, undef, 0, 'pod', 'Pod')) {
694 0         0 return 1
695             }
696             # String => '__DATA__'
697             # attribute => 'Keyword'
698             # context => 'data_handle'
699             # firstNonSpace => 'true'
700             # type => 'StringDetect'
701 0 0       0 if ($self->testStringDetect($text, '__DATA__', 0, 0, 0, undef, 1, 'data_handle', 'Keyword')) {
702 0         0 return 1
703             }
704 0         0 return 0;
705             };
706              
707             sub parsefind_here_document {
708 3     3 0 7 my ($self, $text) = @_;
709             # String => '(\w+)\s*;?'
710             # attribute => 'Keyword'
711             # context => 'here_document'
712             # type => 'RegExpr'
713 3 100       15 if ($self->testRegExpr($text, '(\\w+)\\s*;?', 0, 0, 0, undef, 0, 'here_document', 'Keyword')) {
714 2         6 return 1
715             }
716             # String => '\s*"([^"]+)"\s*;?'
717             # attribute => 'Keyword'
718             # context => 'here_document'
719             # type => 'RegExpr'
720 1 50       6 if ($self->testRegExpr($text, '\\s*"([^"]+)"\\s*;?', 0, 0, 0, undef, 0, 'here_document', 'Keyword')) {
721 0         0 return 1
722             }
723             # String => '\s*`([^`]+)`\s*;?'
724             # attribute => 'Keyword'
725             # context => 'here_document'
726             # type => 'RegExpr'
727 1 50       6 if ($self->testRegExpr($text, '\\s*`([^`]+)`\\s*;?', 0, 0, 0, undef, 0, 'here_document', 'Keyword')) {
728 0         0 return 1
729             }
730             # String => '\s*'([^']+)'\s*;?'
731             # attribute => 'Keyword'
732             # context => 'here_document_dumb'
733             # type => 'RegExpr'
734 1 50       5 if ($self->testRegExpr($text, '\\s*\'([^\']+)\'\\s*;?', 0, 0, 0, undef, 0, 'here_document_dumb', 'Keyword')) {
735 1         4 return 1
736             }
737 0         0 return 0;
738             };
739              
740             sub parsefind_pattern {
741 3     3 0 9 my ($self, $text) = @_;
742             # String => '\s+#.*'
743             # attribute => 'Comment'
744             # context => '#stay'
745             # type => 'RegExpr'
746 3 50       1852 if ($self->testRegExpr($text, '\\s+#.*', 0, 0, 0, undef, 0, '#stay', 'Comment')) {
747 0         0 return 1
748             }
749             # attribute => 'Operator'
750             # beginRegion => 'Pattern'
751             # char => '{'
752             # context => 'pattern_brace'
753             # type => 'DetectChar'
754 3 50       19 if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'pattern_brace', 'Operator')) {
755 0         0 return 1
756             }
757             # attribute => 'Operator'
758             # beginRegion => 'Pattern'
759             # char => '('
760             # context => 'pattern_paren'
761             # type => 'DetectChar'
762 3 50       16 if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'pattern_paren', 'Operator')) {
763 0         0 return 1
764             }
765             # attribute => 'Operator'
766             # beginRegion => 'Pattern'
767             # char => '['
768             # context => 'pattern_bracket'
769             # type => 'DetectChar'
770 3 50       19 if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'pattern_bracket', 'Operator')) {
771 0         0 return 1
772             }
773             # attribute => 'Operator'
774             # beginRegion => 'Pattern'
775             # char => '''
776             # context => 'pattern_sq'
777             # type => 'DetectChar'
778 3 50       16 if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, 'pattern_sq', 'Operator')) {
779 0         0 return 1
780             }
781             # String => '([^\w\s])'
782             # attribute => 'Operator'
783             # beginRegion => 'Pattern'
784             # context => 'pattern'
785             # type => 'RegExpr'
786 3 50       17 if ($self->testRegExpr($text, '([^\\w\\s])', 0, 0, 0, undef, 0, 'pattern', 'Operator')) {
787 3         11 return 1
788             }
789 0         0 return 0;
790             };
791              
792             sub parsefind_qqx {
793 2     2 0 5 my ($self, $text) = @_;
794             # attribute => 'Operator'
795             # beginRegion => 'String'
796             # char => '('
797             # context => 'ip_string_2'
798             # type => 'DetectChar'
799 2 50       11 if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'ip_string_2', 'Operator')) {
800 0         0 return 1
801             }
802             # attribute => 'Operator'
803             # beginRegion => 'String'
804             # char => '{'
805             # context => 'ip_string_3'
806             # type => 'DetectChar'
807 2 50       10 if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'ip_string_3', 'Operator')) {
808 0         0 return 1
809             }
810             # attribute => 'Operator'
811             # beginRegion => 'String'
812             # char => '['
813             # context => 'ip_string_4'
814             # type => 'DetectChar'
815 2 50       12 if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'ip_string_4', 'Operator')) {
816 0         0 return 1
817             }
818             # attribute => 'Operator'
819             # beginRegion => 'String'
820             # char => '<'
821             # context => 'ip_string_5'
822             # type => 'DetectChar'
823 2 50       11 if ($self->testDetectChar($text, '<', 0, 0, 0, undef, 0, 'ip_string_5', 'Operator')) {
824 0         0 return 1
825             }
826             # String => '([^a-zA-Z0-9_\s[\]{}()])'
827             # attribute => 'Operator'
828             # beginRegion => 'String'
829             # context => 'ip_string_6'
830             # type => 'RegExpr'
831 2 50       10 if ($self->testRegExpr($text, '([^a-zA-Z0-9_\\s[\\]{}()])', 0, 0, 0, undef, 0, 'ip_string_6', 'Operator')) {
832 2         9 return 1
833             }
834             # String => '\s+#.*'
835             # attribute => 'Comment'
836             # context => '#stay'
837             # type => 'RegExpr'
838 0 0       0 if ($self->testRegExpr($text, '\\s+#.*', 0, 0, 0, undef, 0, '#stay', 'Comment')) {
839 0         0 return 1
840             }
841 0         0 return 0;
842             };
843              
844             sub parsefind_quoted {
845 7     7 0 16 my ($self, $text) = @_;
846             # String => 'x\s*(')'
847             # attribute => 'Operator'
848             # beginRegion => 'String'
849             # context => 'string_6'
850             # type => 'RegExpr'
851 7 50       32 if ($self->testRegExpr($text, 'x\\s*(\')', 0, 0, 0, undef, 0, 'string_6', 'Operator')) {
852 0         0 return 1
853             }
854             # String => 'qx'
855             # attribute => 'Operator'
856             # context => 'find_qqx'
857             # type => 'AnyChar'
858 7 100       43 if ($self->testAnyChar($text, 'qx', 0, 0, undef, 0, 'find_qqx', 'Operator')) {
859 2         7 return 1
860             }
861             # attribute => 'Operator'
862             # char => 'w'
863             # context => 'find_qw'
864             # type => 'DetectChar'
865 5 100       25 if ($self->testDetectChar($text, 'w', 0, 0, 0, undef, 0, 'find_qw', 'Operator')) {
866 3         11 return 1
867             }
868             # attribute => 'Operator'
869             # beginRegion => 'String'
870             # char => '('
871             # context => 'string_2'
872             # type => 'DetectChar'
873 2 50       10 if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'string_2', 'Operator')) {
874 0         0 return 1
875             }
876             # attribute => 'Operator'
877             # beginRegion => 'String'
878             # char => '{'
879             # context => 'string_3'
880             # type => 'DetectChar'
881 2 50       9 if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'string_3', 'Operator')) {
882 0         0 return 1
883             }
884             # attribute => 'Operator'
885             # beginRegion => 'String'
886             # char => '['
887             # context => 'string_4'
888             # type => 'DetectChar'
889 2 50       10 if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'string_4', 'Operator')) {
890 0         0 return 1
891             }
892             # attribute => 'Operator'
893             # beginRegion => 'String'
894             # char => '<'
895             # context => 'string_5'
896             # type => 'DetectChar'
897 2 50       11 if ($self->testDetectChar($text, '<', 0, 0, 0, undef, 0, 'string_5', 'Operator')) {
898 0         0 return 1
899             }
900             # String => '([^a-zA-Z0-9_\s[\]{}()])'
901             # attribute => 'Operator'
902             # beginRegion => 'String'
903             # context => 'string_6'
904             # type => 'RegExpr'
905 2 50       11 if ($self->testRegExpr($text, '([^a-zA-Z0-9_\\s[\\]{}()])', 0, 0, 0, undef, 0, 'string_6', 'Operator')) {
906 2         8 return 1
907             }
908             # String => '\s+#.*'
909             # attribute => 'Comment'
910             # context => '#stay'
911             # type => 'RegExpr'
912 0 0       0 if ($self->testRegExpr($text, '\\s+#.*', 0, 0, 0, undef, 0, '#stay', 'Comment')) {
913 0         0 return 1
914             }
915 0         0 return 0;
916             };
917              
918             sub parsefind_qw {
919 3     3 0 9 my ($self, $text) = @_;
920             # attribute => 'Operator'
921             # beginRegion => 'Wordlist'
922             # char => '('
923             # context => 'quote_word_paren'
924             # type => 'DetectChar'
925 3 50       15 if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'quote_word_paren', 'Operator')) {
926 3         9 return 1
927             }
928             # attribute => 'Operator'
929             # beginRegion => 'Wordlist'
930             # char => '{'
931             # context => 'quote_word_brace'
932             # type => 'DetectChar'
933 0 0       0 if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'quote_word_brace', 'Operator')) {
934 0         0 return 1
935             }
936             # attribute => 'Operator'
937             # beginRegion => 'Wordlist'
938             # char => '['
939             # context => 'quote_word_bracket'
940             # type => 'DetectChar'
941 0 0       0 if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'quote_word_bracket', 'Operator')) {
942 0         0 return 1
943             }
944             # String => '([^a-zA-Z0-9_\s[\]{}()])'
945             # attribute => 'Operator'
946             # beginRegion => 'Wordlist'
947             # context => 'quote_word'
948             # type => 'RegExpr'
949 0 0       0 if ($self->testRegExpr($text, '([^a-zA-Z0-9_\\s[\\]{}()])', 0, 0, 0, undef, 0, 'quote_word', 'Operator')) {
950 0         0 return 1
951             }
952             # String => '\s+#.*'
953             # attribute => 'Comment'
954             # context => '#stay'
955             # type => 'RegExpr'
956 0 0       0 if ($self->testRegExpr($text, '\\s+#.*', 0, 0, 0, undef, 0, '#stay', 'Comment')) {
957 0         0 return 1
958             }
959 0         0 return 0;
960             };
961              
962             sub parsefind_subst {
963 26     26 0 69 my ($self, $text) = @_;
964             # String => '\s+#.*'
965             # attribute => 'Comment'
966             # context => '#stay'
967             # type => 'RegExpr'
968 26 50       127 if ($self->testRegExpr($text, '\\s+#.*', 0, 0, 0, undef, 0, '#stay', 'Comment')) {
969 0         0 return 1
970             }
971             # attribute => 'Operator'
972             # beginRegion => 'Pattern'
973             # char => '{'
974             # context => 'subst_curlybrace_pattern'
975             # type => 'DetectChar'
976 26 50       137 if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'subst_curlybrace_pattern', 'Operator')) {
977 0         0 return 1
978             }
979             # attribute => 'Operator'
980             # beginRegion => 'Pattern'
981             # char => '('
982             # context => 'subst_paren_pattern'
983             # type => 'DetectChar'
984 26 50       112 if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'subst_paren_pattern', 'Operator')) {
985 0         0 return 1
986             }
987             # attribute => 'Operator'
988             # beginRegion => 'Pattern'
989             # char => '['
990             # context => 'subst_bracket_pattern'
991             # type => 'DetectChar'
992 26 50       106 if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'subst_bracket_pattern', 'Operator')) {
993 0         0 return 1
994             }
995             # attribute => 'Operator'
996             # beginRegion => 'Pattern'
997             # char => '''
998             # context => 'subst_sq_pattern'
999             # type => 'DetectChar'
1000 26 50       153 if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, 'subst_sq_pattern', 'Operator')) {
1001 0         0 return 1
1002             }
1003             # String => '([^\w\s[\]{}()])'
1004             # attribute => 'Operator'
1005             # beginRegion => 'Pattern'
1006             # context => 'subst_slash_pattern'
1007             # type => 'RegExpr'
1008 26 50       106 if ($self->testRegExpr($text, '([^\\w\\s[\\]{}()])', 0, 0, 0, undef, 0, 'subst_slash_pattern', 'Operator')) {
1009 26         100 return 1
1010             }
1011 0         0 return 0;
1012             };
1013              
1014             sub parsefind_variable {
1015 1086     1086 0 8339 my ($self, $text) = @_;
1016             # String => '\$[0-9]+'
1017             # attribute => 'Special Variable'
1018             # context => 'var_detect'
1019             # type => 'RegExpr'
1020 1086 100       6501 if ($self->testRegExpr($text, '\\$[0-9]+', 0, 0, 0, undef, 0, 'var_detect', 'Special Variable')) {
1021 21         256 return 1
1022             }
1023             # String => '[@\$](?:[\+\-_]\B|ARGV\b|INC\b)'
1024             # attribute => 'Special Variable'
1025             # context => 'var_detect'
1026             # type => 'RegExpr'
1027 1065 100       9265 if ($self->testRegExpr($text, '[@\\$](?:[\\+\\-_]\\B|ARGV\\b|INC\\b)', 0, 0, 0, undef, 0, 'var_detect', 'Special Variable')) {
1028 2         8 return 1
1029             }
1030             # String => '[%\$](?:INC\b|ENV\b|SIG\b)'
1031             # attribute => 'Special Variable'
1032             # context => 'var_detect'
1033             # type => 'RegExpr'
1034 1063 50       5124 if ($self->testRegExpr($text, '[%\\$](?:INC\\b|ENV\\b|SIG\\b)', 0, 0, 0, undef, 0, 'var_detect', 'Special Variable')) {
1035 0         0 return 1
1036             }
1037             # String => '\$\$[\$\w_]'
1038             # attribute => 'Data Type'
1039             # context => 'var_detect'
1040             # type => 'RegExpr'
1041 1063 100       4809 if ($self->testRegExpr($text, '\\$\\$[\\$\\w_]', 0, 0, 0, undef, 0, 'var_detect', 'Data Type')) {
1042 24         87 return 1
1043             }
1044             # String => '\$[#_][\w_]'
1045             # attribute => 'Data Type'
1046             # context => 'var_detect'
1047             # type => 'RegExpr'
1048 1039 50       6303 if ($self->testRegExpr($text, '\\$[#_][\\w_]', 0, 0, 0, undef, 0, 'var_detect', 'Data Type')) {
1049 0         0 return 1
1050             }
1051             # String => '\$+::'
1052             # attribute => 'Data Type'
1053             # context => 'var_detect'
1054             # type => 'RegExpr'
1055 1039 50       4586 if ($self->testRegExpr($text, '\\$+::', 0, 0, 0, undef, 0, 'var_detect', 'Data Type')) {
1056 0         0 return 1
1057             }
1058             # String => '\$[^a-zA-Z0-9\s{][A-Z]?'
1059             # attribute => 'Special Variable'
1060             # context => '#stay'
1061             # type => 'RegExpr'
1062 1039 100       5853 if ($self->testRegExpr($text, '\\$[^a-zA-Z0-9\\s{][A-Z]?', 0, 0, 0, undef, 0, '#stay', 'Special Variable')) {
1063 11         44 return 1
1064             }
1065             # String => '[\$@%]\{[\w_]+\}'
1066             # attribute => 'Data Type'
1067             # context => 'var_detect'
1068             # type => 'RegExpr'
1069 1028 50       4637 if ($self->testRegExpr($text, '[\\$@%]\\{[\\w_]+\\}', 0, 0, 0, undef, 0, 'var_detect', 'Data Type')) {
1070 0         0 return 1
1071             }
1072             # String => '$@%'
1073             # attribute => 'Data Type'
1074             # context => 'var_detect'
1075             # type => 'AnyChar'
1076 1028 100       6170 if ($self->testAnyChar($text, '$@%', 0, 0, undef, 0, 'var_detect', 'Data Type')) {
1077 1014         3311 return 1
1078             }
1079             # String => '\*[a-zA-Z_]+'
1080             # attribute => 'Data Type'
1081             # context => 'var_detect'
1082             # type => 'RegExpr'
1083 14 50       64 if ($self->testRegExpr($text, '\\*[a-zA-Z_]+', 0, 0, 0, undef, 0, 'var_detect', 'Data Type')) {
1084 0         0 return 1
1085             }
1086             # String => '\*[^a-zA-Z0-9\s{][A-Z]?'
1087             # attribute => 'Special Variable'
1088             # context => '#stay'
1089             # type => 'RegExpr'
1090 14 50       72 if ($self->testRegExpr($text, '\\*[^a-zA-Z0-9\\s{][A-Z]?', 0, 0, 0, undef, 0, '#stay', 'Special Variable')) {
1091 0         0 return 1
1092             }
1093             # String => '$@%*'
1094             # attribute => 'Operator'
1095             # context => '#pop'
1096             # type => 'AnyChar'
1097 14 100       69 if ($self->testAnyChar($text, '$@%*', 0, 0, undef, 0, '#pop', 'Operator')) {
1098 1         3 return 1
1099             }
1100 13         42 return 0;
1101             };
1102              
1103             sub parsefind_variable_unsafe {
1104 30     30 0 68 my ($self, $text) = @_;
1105             # String => '\$[0-9]+'
1106             # attribute => 'Special Variable'
1107             # context => 'var_detect_unsafe'
1108             # type => 'RegExpr'
1109 30 100       123 if ($self->testRegExpr($text, '\\$[0-9]+', 0, 0, 0, undef, 0, 'var_detect_unsafe', 'Special Variable')) {
1110 2         7 return 1
1111             }
1112             # String => '[@\$](?:[\+\-_]\B|ARGV\b|INC\b)'
1113             # attribute => 'Special Variable'
1114             # context => 'var_detect_unsafe'
1115             # type => 'RegExpr'
1116 28 50       119 if ($self->testRegExpr($text, '[@\\$](?:[\\+\\-_]\\B|ARGV\\b|INC\\b)', 0, 0, 0, undef, 0, 'var_detect_unsafe', 'Special Variable')) {
1117 0         0 return 1
1118             }
1119             # String => '[%\$](?:INC\b|ENV\b|SIG\b)'
1120             # attribute => 'Special Variable'
1121             # context => 'var_detect_unsafe'
1122             # type => 'RegExpr'
1123 28 50       254 if ($self->testRegExpr($text, '[%\\$](?:INC\\b|ENV\\b|SIG\\b)', 0, 0, 0, undef, 0, 'var_detect_unsafe', 'Special Variable')) {
1124 0         0 return 1
1125             }
1126             # String => '\$\$[\$\w_]'
1127             # attribute => 'Data Type'
1128             # context => 'var_detect_unsafe'
1129             # type => 'RegExpr'
1130 28 50       140 if ($self->testRegExpr($text, '\\$\\$[\\$\\w_]', 0, 0, 0, undef, 0, 'var_detect_unsafe', 'Data Type')) {
1131 0         0 return 1
1132             }
1133             # String => '\$[#_][\w_]'
1134             # attribute => 'Data Type'
1135             # context => 'var_detect_unsafe'
1136             # type => 'RegExpr'
1137 28 50       122 if ($self->testRegExpr($text, '\\$[#_][\\w_]', 0, 0, 0, undef, 0, 'var_detect_unsafe', 'Data Type')) {
1138 0         0 return 1
1139             }
1140             # String => '\$+::'
1141             # attribute => 'Data Type'
1142             # context => 'var_detect_unsafe'
1143             # type => 'RegExpr'
1144 28 50       131 if ($self->testRegExpr($text, '\\$+::', 0, 0, 0, undef, 0, 'var_detect_unsafe', 'Data Type')) {
1145 0         0 return 1
1146             }
1147             # String => '\$[^a-zA-Z0-9\s{][A-Z]?'
1148             # attribute => 'Special Variable'
1149             # context => '#stay'
1150             # type => 'RegExpr'
1151 28 100       125 if ($self->testRegExpr($text, '\\$[^a-zA-Z0-9\\s{][A-Z]?', 0, 0, 0, undef, 0, '#stay', 'Special Variable')) {
1152 1         4 return 1
1153             }
1154             # String => '[\$@%]\{[\w_]+\}'
1155             # attribute => 'Data Type'
1156             # context => 'var_detect_unsafe'
1157             # type => 'RegExpr'
1158 27 50       120 if ($self->testRegExpr($text, '[\\$@%]\\{[\\w_]+\\}', 0, 0, 0, undef, 0, 'var_detect_unsafe', 'Data Type')) {
1159 0         0 return 1
1160             }
1161             # String => '[\$@%]'
1162             # attribute => 'Data Type'
1163             # context => 'var_detect_unsafe'
1164             # type => 'RegExpr'
1165 27 100       137 if ($self->testRegExpr($text, '[\\$@%]', 0, 0, 0, undef, 0, 'var_detect_unsafe', 'Data Type')) {
1166 26         89 return 1
1167             }
1168             # String => '\*\w+'
1169             # attribute => 'Data Type'
1170             # context => 'var_detect_unsafe'
1171             # type => 'RegExpr'
1172 1 50       5 if ($self->testRegExpr($text, '\\*\\w+', 0, 0, 0, undef, 0, 'var_detect_unsafe', 'Data Type')) {
1173 0         0 return 1
1174             }
1175             # String => '$@%*'
1176             # attribute => 'Operator'
1177             # context => '#pop'
1178             # type => 'AnyChar'
1179 1 50       6 if ($self->testAnyChar($text, '$@%*', 0, 0, undef, 0, '#pop', 'Operator')) {
1180 0         0 return 1
1181             }
1182 1         3 return 0;
1183             };
1184              
1185             sub parsehere_document {
1186 34     34 0 52 my ($self, $text) = @_;
1187             # type => 'DetectSpaces'
1188 34 50       115 if ($self->testDetectSpaces($text, 0, undef, 0, '#stay', undef)) {
1189 0         0 return 1
1190             }
1191             # String => '%1'
1192             # attribute => 'Keyword'
1193             # column => '0'
1194             # context => '#pop#pop'
1195             # dynamic => 'true'
1196             # endRegion => 'HereDocument'
1197             # type => 'RegExpr'
1198 34 100       115 if ($self->testRegExpr($text, '%1', 0, 1, 0, 0, 0, '#pop#pop', 'Keyword')) {
1199 2         6 return 1
1200             }
1201             # String => '\=\s*<<\s*["']?([A-Z0-9_\-]+)["']?'
1202             # attribute => 'Keyword'
1203             # beginRegion => 'HEREDoc'
1204             # context => 'here_document'
1205             # type => 'RegExpr'
1206 32 50       111 if ($self->testRegExpr($text, '\\=\\s*<<\\s*["\']?([A-Z0-9_\\-]+)["\']?', 0, 0, 0, undef, 0, 'here_document', 'Keyword')) {
1207 0         0 return 1
1208             }
1209             # context => 'ipstring_internal'
1210             # type => 'IncludeRules'
1211 32 100       115 if ($self->includeRules('ipstring_internal', $text)) {
1212 16         46 return 1
1213             }
1214 16         44 return 0;
1215             };
1216              
1217             sub parsehere_document_dumb {
1218 6     6 0 11 my ($self, $text) = @_;
1219             # type => 'DetectSpaces'
1220 6 50       18 if ($self->testDetectSpaces($text, 0, undef, 0, '#stay', undef)) {
1221 0         0 return 1
1222             }
1223             # String => '%1'
1224             # attribute => 'Keyword'
1225             # column => '0'
1226             # context => '#pop#pop'
1227             # dynamic => 'true'
1228             # endRegion => 'HereDocument'
1229             # type => 'RegExpr'
1230 6 100       22 if ($self->testRegExpr($text, '%1', 0, 1, 0, 0, 0, '#pop#pop', 'Keyword')) {
1231 1         4 return 1
1232             }
1233             # type => 'DetectIdentifier'
1234 5 100       23 if ($self->testDetectIdentifier($text, 0, undef, 0, '#stay', undef)) {
1235 3         8 return 1
1236             }
1237 2         5 return 0;
1238             };
1239              
1240             sub parseip_string {
1241 278     278 0 690 my ($self, $text) = @_;
1242             # attribute => 'Operator'
1243             # char => '"'
1244             # context => '#pop'
1245             # endRegion => 'String'
1246             # type => 'DetectChar'
1247 278 100       1147 if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, '#pop', 'Operator')) {
1248 37         129 return 1
1249             }
1250             # context => 'ipstring_internal'
1251             # type => 'IncludeRules'
1252 241 100       863 if ($self->includeRules('ipstring_internal', $text)) {
1253 124         353 return 1
1254             }
1255 117         498 return 0;
1256             };
1257              
1258             sub parseip_string_2 {
1259 0     0 0 0 my ($self, $text) = @_;
1260             # attribute => 'String (interpolated)'
1261             # char => '('
1262             # char1 => ')'
1263             # context => '#stay'
1264             # type => 'RangeDetect'
1265 0 0       0 if ($self->testRangeDetect($text, '(', ')', 0, 0, undef, 0, '#stay', 'String (interpolated)')) {
1266 0         0 return 1
1267             }
1268             # attribute => 'Operator'
1269             # char => ')'
1270             # context => '#pop#pop#pop'
1271             # endRegion => 'String'
1272             # type => 'DetectChar'
1273 0 0       0 if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Operator')) {
1274 0         0 return 1
1275             }
1276             # context => 'ipstring_internal'
1277             # type => 'IncludeRules'
1278 0 0       0 if ($self->includeRules('ipstring_internal', $text)) {
1279 0         0 return 1
1280             }
1281 0         0 return 0;
1282             };
1283              
1284             sub parseip_string_3 {
1285 0     0 0 0 my ($self, $text) = @_;
1286             # attribute => 'String (interpolated)'
1287             # char => '{'
1288             # char1 => '}'
1289             # context => '#stay'
1290             # type => 'RangeDetect'
1291 0 0       0 if ($self->testRangeDetect($text, '{', '}', 0, 0, undef, 0, '#stay', 'String (interpolated)')) {
1292 0         0 return 1
1293             }
1294             # attribute => 'Operator'
1295             # char => '}'
1296             # context => '#pop#pop#pop'
1297             # endRegion => 'String'
1298             # type => 'DetectChar'
1299 0 0       0 if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Operator')) {
1300 0         0 return 1
1301             }
1302             # context => 'ipstring_internal'
1303             # type => 'IncludeRules'
1304 0 0       0 if ($self->includeRules('ipstring_internal', $text)) {
1305 0         0 return 1
1306             }
1307 0         0 return 0;
1308             };
1309              
1310             sub parseip_string_4 {
1311 0     0 0 0 my ($self, $text) = @_;
1312             # attribute => 'String (interpolated)'
1313             # char => '['
1314             # char1 => ']'
1315             # context => '#stay'
1316             # type => 'RangeDetect'
1317 0 0       0 if ($self->testRangeDetect($text, '[', ']', 0, 0, undef, 0, '#stay', 'String (interpolated)')) {
1318 0         0 return 1
1319             }
1320             # attribute => 'Operator'
1321             # char => ']'
1322             # context => '#pop#pop#pop'
1323             # endRegion => 'String'
1324             # type => 'DetectChar'
1325 0 0       0 if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Operator')) {
1326 0         0 return 1
1327             }
1328             # context => 'ipstring_internal'
1329             # type => 'IncludeRules'
1330 0 0       0 if ($self->includeRules('ipstring_internal', $text)) {
1331 0         0 return 1
1332             }
1333 0         0 return 0;
1334             };
1335              
1336             sub parseip_string_5 {
1337 0     0 0 0 my ($self, $text) = @_;
1338             # attribute => 'String (interpolated)'
1339             # char => '<'
1340             # char1 => '>'
1341             # context => '#stay'
1342             # type => 'RangeDetect'
1343 0 0       0 if ($self->testRangeDetect($text, '<', '>', 0, 0, undef, 0, '#stay', 'String (interpolated)')) {
1344 0         0 return 1
1345             }
1346             # attribute => 'Operator'
1347             # char => '>'
1348             # context => '#pop#pop#pop'
1349             # endRegion => 'String'
1350             # type => 'DetectChar'
1351 0 0       0 if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Operator')) {
1352 0         0 return 1
1353             }
1354             # context => 'ipstring_internal'
1355             # type => 'IncludeRules'
1356 0 0       0 if ($self->includeRules('ipstring_internal', $text)) {
1357 0         0 return 1
1358             }
1359 0         0 return 0;
1360             };
1361              
1362             sub parseip_string_6 {
1363 20     20 0 27 my ($self, $text) = @_;
1364             # String => '\\%1'
1365             # attribute => 'String (interpolated)'
1366             # context => '#stay'
1367             # dynamic => 'true'
1368             # type => 'RegExpr'
1369 20 50       90 if ($self->testRegExpr($text, '\\\\%1', 0, 1, 0, undef, 0, '#stay', 'String (interpolated)')) {
1370 0         0 return 1
1371             }
1372             # attribute => 'Operator'
1373             # char => '1'
1374             # context => '#pop#pop#pop'
1375             # dynamic => 'true'
1376             # endRegion => 'String'
1377             # type => 'DetectChar'
1378 20 100       77 if ($self->testDetectChar($text, '1', 0, 1, 0, undef, 0, '#pop#pop#pop', 'Operator')) {
1379 2         9 return 1
1380             }
1381             # context => 'ipstring_internal'
1382             # type => 'IncludeRules'
1383 18 100       63 if ($self->includeRules('ipstring_internal', $text)) {
1384 8         21 return 1
1385             }
1386 10         26 return 0;
1387             };
1388              
1389             sub parseipstring_internal {
1390 335     335 0 573 my ($self, $text) = @_;
1391             # type => 'DetectIdentifier'
1392 335 100       1203 if ($self->testDetectIdentifier($text, 0, undef, 0, '#stay', undef)) {
1393 118         448 return 1
1394             }
1395             # String => '\\[UuLlEtnaefr]'
1396             # attribute => 'String Special Character'
1397             # context => '#stay'
1398             # type => 'RegExpr'
1399 217 100       901 if ($self->testRegExpr($text, '\\\\[UuLlEtnaefr]', 0, 0, 0, undef, 0, '#stay', 'String Special Character')) {
1400 9         45 return 1
1401             }
1402             # String => '\\.'
1403             # attribute => 'String (interpolated)'
1404             # context => '#stay'
1405             # type => 'RegExpr'
1406 208 100       977 if ($self->testRegExpr($text, '\\\\.', 0, 0, 0, undef, 0, '#stay', 'String (interpolated)')) {
1407 9         39 return 1
1408             }
1409             # String => '(?:[\$@]\S|%[\w{])'
1410             # attribute => 'Normal Text'
1411             # context => 'find_variable_unsafe'
1412             # lookAhead => 'true'
1413             # type => 'RegExpr'
1414 199 100       744 if ($self->testRegExpr($text, '(?:[\\$@]\\S|%[\\w{])', 0, 0, 1, undef, 0, 'find_variable_unsafe', 'Normal Text')) {
1415 24         94 return 1
1416             }
1417 175         707 return 0;
1418             };
1419              
1420             sub parsenormal {
1421 14615     14615 0 31479 my ($self, $text) = @_;
1422             # String => '^#!\/.*'
1423             # attribute => 'Keyword'
1424             # context => '#stay'
1425             # type => 'RegExpr'
1426 14615 100       66075 if ($self->testRegExpr($text, '^#!\\/.*', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
1427 1         4 return 1
1428             }
1429             # String => '__DATA__'
1430             # attribute => 'Keyword'
1431             # context => 'data_handle'
1432             # firstNonSpace => 'true'
1433             # type => 'StringDetect'
1434 14614 50       65593 if ($self->testStringDetect($text, '__DATA__', 0, 0, 0, undef, 1, 'data_handle', 'Keyword')) {
1435 0         0 return 1
1436             }
1437             # String => '__END__'
1438             # attribute => 'Keyword'
1439             # context => '#stay'
1440             # firstNonSpace => 'true'
1441             # type => 'StringDetect'
1442 14614 100       53838 if ($self->testStringDetect($text, '__END__', 0, 0, 0, undef, 1, '#stay', 'Keyword')) {
1443 2         7 return 1
1444             }
1445             # String => '\bsub\s+'
1446             # attribute => 'Keyword'
1447             # context => 'sub_name_def'
1448             # type => 'RegExpr'
1449 14612 100       62597 if ($self->testRegExpr($text, '\\bsub\\s+', 0, 0, 0, undef, 0, 'sub_name_def', 'Keyword')) {
1450 81         329 return 1
1451             }
1452             # String => 'keywords'
1453             # attribute => 'Keyword'
1454             # context => '#stay'
1455             # type => 'keyword'
1456 14531 100       66003 if ($self->testKeyword($text, 'keywords', 0, undef, 0, '#stay', 'Keyword')) {
1457 542         1828 return 1
1458             }
1459             # String => 'operators'
1460             # attribute => 'Operator'
1461             # context => '#stay'
1462             # type => 'keyword'
1463 13989 100       80229 if ($self->testKeyword($text, 'operators', 0, undef, 0, '#stay', 'Operator')) {
1464 51         185 return 1
1465             }
1466             # String => 'functions'
1467             # attribute => 'Function'
1468             # context => '#stay'
1469             # type => 'keyword'
1470 13938 100       58893 if ($self->testKeyword($text, 'functions', 0, undef, 0, '#stay', 'Function')) {
1471 237         936 return 1
1472             }
1473             # String => 'pragmas'
1474             # attribute => 'Pragma'
1475             # context => '#stay'
1476             # type => 'keyword'
1477 13701 100       55787 if ($self->testKeyword($text, 'pragmas', 0, undef, 0, '#stay', 'Pragma')) {
1478 14         51 return 1
1479             }
1480             # String => '\=(?:head[1-6]|over|back|item|for|begin|end|pod)(\s|$)'
1481             # attribute => 'Pod'
1482             # beginRegion => 'POD'
1483             # column => '0'
1484             # context => 'pod'
1485             # type => 'RegExpr'
1486 13687 100       57532 if ($self->testRegExpr($text, '\\=(?:head[1-6]|over|back|item|for|begin|end|pod)(\\s|$)', 0, 0, 0, 0, 0, 'pod', 'Pod')) {
1487 2         10 return 1
1488             }
1489             # type => 'DetectSpaces'
1490 13685 100       64434 if ($self->testDetectSpaces($text, 0, undef, 0, '#stay', undef)) {
1491 58         177 return 1
1492             }
1493             # attribute => 'Comment'
1494             # char => '#'
1495             # context => 'comment'
1496             # type => 'DetectChar'
1497 13627 100       55534 if ($self->testDetectChar($text, '#', 0, 0, 0, undef, 0, 'comment', 'Comment')) {
1498 107         395 return 1
1499             }
1500             # attribute => 'Octal'
1501             # context => 'slash_safe_escape'
1502             # type => 'HlCOct'
1503 13520 50       61259 if ($self->testHlCOct($text, 0, undef, 0, 'slash_safe_escape', 'Octal')) {
1504 0         0 return 1
1505             }
1506             # attribute => 'Hex'
1507             # context => 'slash_safe_escape'
1508             # type => 'HlCHex'
1509 13520 50       68594 if ($self->testHlCHex($text, 0, undef, 0, 'slash_safe_escape', 'Hex')) {
1510 0         0 return 1
1511             }
1512             # attribute => 'Float'
1513             # context => 'slash_safe_escape'
1514             # type => 'Float'
1515 13520 100       59090 if ($self->testFloat($text, 0, undef, 0, 'slash_safe_escape', 'Float')) {
1516 59         205 return 1
1517             }
1518             # attribute => 'Decimal'
1519             # context => 'slash_safe_escape'
1520             # type => 'Int'
1521 13461 100       69479 if ($self->testInt($text, 0, undef, 0, 'slash_safe_escape', 'Decimal')) {
1522 2         7 return 1
1523             }
1524             # String => '\\(["'])[^\1]'
1525             # attribute => 'Normal Text'
1526             # context => '#stay'
1527             # type => 'RegExpr'
1528 13459 50       50840 if ($self->testRegExpr($text, '\\\\(["\'])[^\\1]', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
1529 0         0 return 1
1530             }
1531             # attribute => 'Normal Text'
1532             # char => '&'
1533             # char1 => '''
1534             # context => '#stay'
1535             # type => 'Detect2Chars'
1536 13459 50       61889 if ($self->testDetect2Chars($text, '&', '\'', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
1537 0         0 return 1
1538             }
1539             # attribute => 'Operator'
1540             # beginRegion => 'String'
1541             # char => '"'
1542             # context => 'ip_string'
1543             # type => 'DetectChar'
1544 13459 100       65163 if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, 'ip_string', 'Operator')) {
1545 37         124 return 1
1546             }
1547             # attribute => 'Operator'
1548             # beginRegion => 'String'
1549             # char => '''
1550             # context => 'string'
1551             # type => 'DetectChar'
1552 13422 100       84823 if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, 'string', 'Operator')) {
1553 1102         3947 return 1
1554             }
1555             # attribute => 'Operator'
1556             # char => '`'
1557             # context => 'Backticked'
1558             # type => 'DetectChar'
1559 12320 50       50571 if ($self->testDetectChar($text, '`', 0, 0, 0, undef, 0, 'Backticked', 'Operator')) {
1560 0         0 return 1
1561             }
1562             # String => '(?:[$@]\S|%[\w{]|\*[^\d\*{\$@%=(])'
1563             # attribute => 'Normal Text'
1564             # context => 'find_variable'
1565             # lookAhead => 'true'
1566             # type => 'RegExpr'
1567 12320 100       44591 if ($self->testRegExpr($text, '(?:[$@]\\S|%[\\w{]|\\*[^\\d\\*{\\$@%=(])', 0, 0, 1, undef, 0, 'find_variable', 'Normal Text')) {
1568 1073         4047 return 1
1569             }
1570             # String => '<[A-Z0-9_]+>'
1571             # attribute => 'Keyword'
1572             # context => '#stay'
1573             # type => 'RegExpr'
1574 11247 50       48424 if ($self->testRegExpr($text, '<[A-Z0-9_]+>', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
1575 0         0 return 1
1576             }
1577             # String => '\s*<<(?=\w+|\s*["'])'
1578             # attribute => 'Operator'
1579             # beginRegion => 'HereDocument'
1580             # context => 'find_here_document'
1581             # type => 'RegExpr'
1582 11247 100       47913 if ($self->testRegExpr($text, '\\s*<<(?=\\w+|\\s*["\'])', 0, 0, 0, undef, 0, 'find_here_document', 'Operator')) {
1583 3         13 return 1
1584             }
1585             # String => '\s*\}\s*/'
1586             # attribute => 'Normal Text'
1587             # context => '#stay'
1588             # endRegion => 'Block'
1589             # type => 'RegExpr'
1590 11244 50       45490 if ($self->testRegExpr($text, '\\s*\\}\\s*/', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
1591 0         0 return 1
1592             }
1593             # String => '\s*[)]\s*/'
1594             # attribute => 'Normal Text'
1595             # context => '#stay'
1596             # type => 'RegExpr'
1597 11244 50       44316 if ($self->testRegExpr($text, '\\s*[)]\\s*/', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
1598 0         0 return 1
1599             }
1600             # String => '\w+::'
1601             # attribute => 'Function'
1602             # context => 'sub_name_def'
1603             # type => 'RegExpr'
1604 11244 100       48308 if ($self->testRegExpr($text, '\\w+::', 0, 0, 0, undef, 0, 'sub_name_def', 'Function')) {
1605 6         20 return 1
1606             }
1607             # String => '\w+[=]'
1608             # attribute => 'Normal Text'
1609             # context => '#stay'
1610             # type => 'RegExpr'
1611 11238 50       49110 if ($self->testRegExpr($text, '\\w+[=]', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
1612 0         0 return 1
1613             }
1614             # String => '\bq(?=[qwx]?\s*[^\w\s])'
1615             # attribute => 'Operator'
1616             # context => 'find_quoted'
1617             # type => 'RegExpr'
1618 11238 100       48173 if ($self->testRegExpr($text, '\\bq(?=[qwx]?\\s*[^\\w\\s])', 0, 0, 0, undef, 0, 'find_quoted', 'Operator')) {
1619 7         26 return 1
1620             }
1621             # String => '\bs(?=\s*[^\w\s])'
1622             # attribute => 'Operator'
1623             # context => 'find_subst'
1624             # type => 'RegExpr'
1625 11231 100       43792 if ($self->testRegExpr($text, '\\bs(?=\\s*[^\\w\\s])', 0, 0, 0, undef, 0, 'find_subst', 'Operator')) {
1626 26         119 return 1
1627             }
1628             # String => '\b(?:tr|y)\s*(?=[^\w\s\]})])'
1629             # attribute => 'Operator'
1630             # context => 'tr'
1631             # type => 'RegExpr'
1632 11205 50       46179 if ($self->testRegExpr($text, '\\b(?:tr|y)\\s*(?=[^\\w\\s\\]})])', 0, 0, 0, undef, 0, 'tr', 'Operator')) {
1633 0         0 return 1
1634             }
1635             # String => '\b(?:m|qr)(?=\s*[^\w\s\]})])'
1636             # attribute => 'Operator'
1637             # context => 'find_pattern'
1638             # type => 'RegExpr'
1639 11205 100       62231 if ($self->testRegExpr($text, '\\b(?:m|qr)(?=\\s*[^\\w\\s\\]})])', 0, 0, 0, undef, 0, 'find_pattern', 'Operator')) {
1640 3         12 return 1
1641             }
1642             # String => '[\w_]+\s*/'
1643             # attribute => 'Normal Text'
1644             # context => '#stay'
1645             # type => 'RegExpr'
1646 11202 100       46748 if ($self->testRegExpr($text, '[\\w_]+\\s*/', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
1647 2         8 return 1
1648             }
1649             # String => '[<>"':]/'
1650             # attribute => 'Normal Text'
1651             # context => '#stay'
1652             # type => 'RegExpr'
1653 11200 50       55398 if ($self->testRegExpr($text, '[<>"\':]/', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
1654 0         0 return 1
1655             }
1656             # attribute => 'Operator'
1657             # beginRegion => 'Pattern'
1658             # char => '/'
1659             # context => 'pattern_slash'
1660             # type => 'DetectChar'
1661 11200 100       56709 if ($self->testDetectChar($text, '/', 0, 0, 0, undef, 0, 'pattern_slash', 'Operator')) {
1662 29         123 return 1
1663             }
1664             # String => '-[rwxoRWXOeszfdlpSbctugkTBMAC]'
1665             # attribute => 'Operator'
1666             # context => '#stay'
1667             # type => 'RegExpr'
1668 11171 100       42059 if ($self->testRegExpr($text, '-[rwxoRWXOeszfdlpSbctugkTBMAC]', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
1669 2         8 return 1
1670             }
1671             # attribute => 'Normal Text'
1672             # beginRegion => 'Block'
1673             # char => '{'
1674             # context => '#stay'
1675             # type => 'DetectChar'
1676 11169 100       51590 if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
1677 368         1548 return 1
1678             }
1679             # attribute => 'Normal Text'
1680             # char => '}'
1681             # context => '#stay'
1682             # endRegion => 'Block'
1683             # type => 'DetectChar'
1684 10801 100       51202 if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
1685 368         1480 return 1
1686             }
1687 10433         35955 return 0;
1688             };
1689              
1690             sub parsepackage_qualified_blank {
1691 0     0 0 0 my ($self, $text) = @_;
1692             # String => '[\w_]+'
1693             # attribute => 'Normal Text'
1694             # context => '#pop'
1695             # type => 'RegExpr'
1696 0 0       0 if ($self->testRegExpr($text, '[\\w_]+', 0, 0, 0, undef, 0, '#pop', 'Normal Text')) {
1697 0         0 return 1
1698             }
1699 0         0 return 0;
1700             };
1701              
1702             sub parsepat_char_class {
1703 139     139 0 239 my ($self, $text) = @_;
1704             # attribute => 'Pattern Internal Operator'
1705             # char => '^'
1706             # context => '#stay'
1707             # type => 'DetectChar'
1708 139 100       437 if ($self->testDetectChar($text, '^', 0, 0, 0, undef, 0, '#stay', 'Pattern Internal Operator')) {
1709 4         15 return 1
1710             }
1711             # attribute => 'Pattern Character Class'
1712             # char => '\'
1713             # char1 => '\'
1714             # context => '#stay'
1715             # type => 'Detect2Chars'
1716 135 100       423 if ($self->testDetect2Chars($text, '\\', '\\', 0, 0, 0, undef, 0, '#stay', 'Pattern Character Class')) {
1717 2         8 return 1
1718             }
1719             # attribute => 'Pattern Character Class'
1720             # char => '\'
1721             # char1 => ']'
1722             # context => '#stay'
1723             # type => 'Detect2Chars'
1724 133 50       422 if ($self->testDetect2Chars($text, '\\', ']', 0, 0, 0, undef, 0, '#stay', 'Pattern Character Class')) {
1725 0         0 return 1
1726             }
1727             # String => '\[:^?[a-z]+:\]'
1728             # attribute => 'Pattern Character Class'
1729             # context => '#stay'
1730             # type => 'RegExpr'
1731 133 50       412 if ($self->testRegExpr($text, '\\[:^?[a-z]+:\\]', 0, 0, 0, undef, 0, '#stay', 'Pattern Character Class')) {
1732 0         0 return 1
1733             }
1734             # attribute => 'Pattern Internal Operator'
1735             # char => ']'
1736             # context => '#pop'
1737             # type => 'DetectChar'
1738 133 100       439 if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, '#pop', 'Pattern Internal Operator')) {
1739 18         55 return 1
1740             }
1741 115         300 return 0;
1742             };
1743              
1744             sub parsepat_ext {
1745 3     3 0 7 my ($self, $text) = @_;
1746             # String => '\#[^)]*'
1747             # attribute => 'Comment'
1748             # context => '#pop'
1749             # type => 'RegExpr'
1750 3 50       14 if ($self->testRegExpr($text, '\\#[^)]*', 0, 0, 0, undef, 0, '#pop', 'Comment')) {
1751 0         0 return 1
1752             }
1753             # String => '[:=!><]+'
1754             # attribute => 'Pattern Internal Operator'
1755             # context => '#pop'
1756             # type => 'RegExpr'
1757 3 50       11 if ($self->testRegExpr($text, '[:=!><]+', 0, 0, 0, undef, 0, '#pop', 'Pattern Internal Operator')) {
1758 3         9 return 1
1759             }
1760             # attribute => 'Pattern Internal Operator'
1761             # char => ')'
1762             # context => '#pop'
1763             # type => 'DetectChar'
1764 0 0       0 if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop', 'Pattern Internal Operator')) {
1765 0         0 return 1
1766             }
1767 0         0 return 0;
1768             };
1769              
1770             sub parsepattern {
1771 14     14 0 29 my ($self, $text) = @_;
1772             # String => '\$(?=%1)'
1773             # attribute => 'Pattern Internal Operator'
1774             # context => '#stay'
1775             # dynamic => 'true'
1776             # type => 'RegExpr'
1777 14 50       55 if ($self->testRegExpr($text, '\\$(?=%1)', 0, 1, 0, undef, 0, '#stay', 'Pattern Internal Operator')) {
1778 0         0 return 1
1779             }
1780             # String => '%1[cgimosx]*'
1781             # attribute => 'Operator'
1782             # context => '#pop#pop'
1783             # dynamic => 'true'
1784             # endRegion => 'Pattern'
1785             # type => 'RegExpr'
1786 14 100       62 if ($self->testRegExpr($text, '%1[cgimosx]*', 0, 1, 0, undef, 0, '#pop#pop', 'Operator')) {
1787 3         13 return 1
1788             }
1789             # context => 'regex_pattern_internal_ip'
1790             # type => 'IncludeRules'
1791 11 100       51 if ($self->includeRules('regex_pattern_internal_ip', $text)) {
1792 9         30 return 1
1793             }
1794             # String => '\$(?=\%1)'
1795             # attribute => 'Pattern Internal Operator'
1796             # context => '#stay'
1797             # dynamic => 'true'
1798             # type => 'RegExpr'
1799 2 50       21 if ($self->testRegExpr($text, '\\$(?=\\%1)', 0, 1, 0, undef, 0, '#stay', 'Pattern Internal Operator')) {
1800 0         0 return 1
1801             }
1802 2         8 return 0;
1803             };
1804              
1805             sub parsepattern_brace {
1806 0     0 0 0 my ($self, $text) = @_;
1807             # String => '\}[cgimosx]*'
1808             # attribute => 'Operator'
1809             # context => '#pop#pop'
1810             # endRegion => 'Pattern'
1811             # type => 'RegExpr'
1812 0 0       0 if ($self->testRegExpr($text, '\\}[cgimosx]*', 0, 0, 0, undef, 0, '#pop#pop', 'Operator')) {
1813 0         0 return 1
1814             }
1815             # context => 'regex_pattern_internal_ip'
1816             # type => 'IncludeRules'
1817 0 0       0 if ($self->includeRules('regex_pattern_internal_ip', $text)) {
1818 0         0 return 1
1819             }
1820 0         0 return 0;
1821             };
1822              
1823             sub parsepattern_bracket {
1824 0     0 0 0 my ($self, $text) = @_;
1825             # String => '\][cgimosx]*'
1826             # attribute => 'Operator'
1827             # context => '#pop#pop'
1828             # endRegion => 'Pattern'
1829             # type => 'RegExpr'
1830 0 0       0 if ($self->testRegExpr($text, '\\][cgimosx]*', 0, 0, 0, undef, 0, '#pop#pop', 'Operator')) {
1831 0         0 return 1
1832             }
1833             # context => 'regex_pattern_internal_ip'
1834             # type => 'IncludeRules'
1835 0 0       0 if ($self->includeRules('regex_pattern_internal_ip', $text)) {
1836 0         0 return 1
1837             }
1838 0         0 return 0;
1839             };
1840              
1841             sub parsepattern_paren {
1842 0     0 0 0 my ($self, $text) = @_;
1843             # String => '\)[cgimosx]*'
1844             # attribute => 'Operator'
1845             # context => '#pop#pop'
1846             # endRegion => 'Pattern'
1847             # type => 'RegExpr'
1848 0 0       0 if ($self->testRegExpr($text, '\\)[cgimosx]*', 0, 0, 0, undef, 0, '#pop#pop', 'Operator')) {
1849 0         0 return 1
1850             }
1851             # context => 'regex_pattern_internal_ip'
1852             # type => 'IncludeRules'
1853 0 0       0 if ($self->includeRules('regex_pattern_internal_ip', $text)) {
1854 0         0 return 1
1855             }
1856 0         0 return 0;
1857             };
1858              
1859             sub parsepattern_slash {
1860 176     176 0 291 my ($self, $text) = @_;
1861             # String => '\$(?=/)'
1862             # attribute => 'Pattern Internal Operator'
1863             # context => '#stay'
1864             # type => 'RegExpr'
1865 176 100       635 if ($self->testRegExpr($text, '\\$(?=/)', 0, 0, 0, undef, 0, '#stay', 'Pattern Internal Operator')) {
1866 3         14 return 1
1867             }
1868             # context => 'regex_pattern_internal_ip'
1869             # type => 'IncludeRules'
1870 173 100       642 if ($self->includeRules('regex_pattern_internal_ip', $text)) {
1871 115         686 return 1
1872             }
1873             # String => '/[cgimosx]*'
1874             # attribute => 'Operator'
1875             # context => '#pop'
1876             # endRegion => 'Pattern'
1877             # type => 'RegExpr'
1878 58 100       376 if ($self->testRegExpr($text, '/[cgimosx]*', 0, 0, 0, undef, 0, '#pop', 'Operator')) {
1879 29         100 return 1
1880             }
1881 29         90 return 0;
1882             };
1883              
1884             sub parsepattern_sq {
1885 0     0 0 0 my ($self, $text) = @_;
1886             # String => ''[cgimosx]*'
1887             # attribute => 'Operator'
1888             # context => '#pop#pop'
1889             # endRegion => 'Pattern'
1890             # type => 'RegExpr'
1891 0 0       0 if ($self->testRegExpr($text, '\'[cgimosx]*', 0, 0, 0, undef, 0, '#pop#pop', 'Operator')) {
1892 0         0 return 1
1893             }
1894             # context => 'regex_pattern_internal'
1895             # type => 'IncludeRules'
1896 0 0       0 if ($self->includeRules('regex_pattern_internal', $text)) {
1897 0         0 return 1
1898             }
1899 0         0 return 0;
1900             };
1901              
1902             sub parsepod {
1903 10726     10726 0 21098 my ($self, $text) = @_;
1904             # type => 'DetectSpaces'
1905 10726 100       61125 if ($self->testDetectSpaces($text, 0, undef, 0, '#stay', undef)) {
1906 339         1001 return 1
1907             }
1908             # type => 'DetectIdentifier'
1909 10387 100       42314 if ($self->testDetectIdentifier($text, 0, undef, 0, '#stay', undef)) {
1910 2167         14803 return 1
1911             }
1912             # String => '\=(?:head[1-6]|over|back|item|for|begin|end|pod)\s*.*'
1913             # attribute => 'Pod'
1914             # beginRegion => 'POD'
1915             # column => '0'
1916             # context => '#stay'
1917             # endRegion => 'POD'
1918             # type => 'RegExpr'
1919 8220 100       54409 if ($self->testRegExpr($text, '\\=(?:head[1-6]|over|back|item|for|begin|end|pod)\\s*.*', 0, 0, 0, 0, 0, '#stay', 'Pod')) {
1920 89         257 return 1
1921             }
1922             # String => '\=cut.*$'
1923             # attribute => 'Pod'
1924             # column => '0'
1925             # context => '#pop'
1926             # endRegion => 'POD'
1927             # type => 'RegExpr'
1928 8131 50       38623 if ($self->testRegExpr($text, '\\=cut.*$', 0, 0, 0, 0, 0, '#pop', 'Pod')) {
1929 0         0 return 1
1930             }
1931 8131         49157 return 0;
1932             };
1933              
1934             sub parsequote_word {
1935 0     0 0 0 my ($self, $text) = @_;
1936             # type => 'DetectSpaces'
1937 0 0       0 if ($self->testDetectSpaces($text, 0, undef, 0, '#stay', undef)) {
1938 0         0 return 1
1939             }
1940             # type => 'DetectIdentifier'
1941 0 0       0 if ($self->testDetectIdentifier($text, 0, undef, 0, '#stay', undef)) {
1942 0         0 return 1
1943             }
1944             # String => '\\%1'
1945             # attribute => 'Normal Text'
1946             # context => '#stay'
1947             # dynamic => 'true'
1948             # type => 'RegExpr'
1949 0 0       0 if ($self->testRegExpr($text, '\\\\%1', 0, 1, 0, undef, 0, '#stay', 'Normal Text')) {
1950 0         0 return 1
1951             }
1952             # attribute => 'Operator'
1953             # char => '1'
1954             # context => '#pop#pop#pop'
1955             # dynamic => 'true'
1956             # endRegion => 'Wordlist'
1957             # type => 'DetectChar'
1958 0 0       0 if ($self->testDetectChar($text, '1', 0, 1, 0, undef, 0, '#pop#pop#pop', 'Operator')) {
1959 0         0 return 1
1960             }
1961 0         0 return 0;
1962             };
1963              
1964             sub parsequote_word_brace {
1965 0     0 0 0 my ($self, $text) = @_;
1966             # type => 'DetectSpaces'
1967 0 0       0 if ($self->testDetectSpaces($text, 0, undef, 0, '#stay', undef)) {
1968 0         0 return 1
1969             }
1970             # type => 'DetectIdentifier'
1971 0 0       0 if ($self->testDetectIdentifier($text, 0, undef, 0, '#stay', undef)) {
1972 0         0 return 1
1973             }
1974             # attribute => 'Normal Text'
1975             # char => '\'
1976             # char1 => '}'
1977             # context => '#stay'
1978             # type => 'Detect2Chars'
1979 0 0       0 if ($self->testDetect2Chars($text, '\\', '}', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
1980 0         0 return 1
1981             }
1982             # attribute => 'Operator'
1983             # char => '}'
1984             # context => '#pop#pop#pop'
1985             # endRegion => 'Wordlist'
1986             # type => 'DetectChar'
1987 0 0       0 if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Operator')) {
1988 0         0 return 1
1989             }
1990 0         0 return 0;
1991             };
1992              
1993             sub parsequote_word_bracket {
1994 0     0 0 0 my ($self, $text) = @_;
1995             # type => 'DetectSpaces'
1996 0 0       0 if ($self->testDetectSpaces($text, 0, undef, 0, '#stay', undef)) {
1997 0         0 return 1
1998             }
1999             # type => 'DetectIdentifier'
2000 0 0       0 if ($self->testDetectIdentifier($text, 0, undef, 0, '#stay', undef)) {
2001 0         0 return 1
2002             }
2003             # attribute => 'Normal Text'
2004             # char => '\'
2005             # char1 => ']'
2006             # context => '#stay'
2007             # type => 'Detect2Chars'
2008 0 0       0 if ($self->testDetect2Chars($text, '\\', ']', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
2009 0         0 return 1
2010             }
2011             # attribute => 'Operator'
2012             # char => ']'
2013             # context => '#pop#pop#pop'
2014             # endRegion => 'Wordlist'
2015             # type => 'DetectChar'
2016 0 0       0 if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Operator')) {
2017 0         0 return 1
2018             }
2019 0         0 return 0;
2020             };
2021              
2022             sub parsequote_word_paren {
2023 14     14 0 24 my ($self, $text) = @_;
2024             # type => 'DetectSpaces'
2025 14 50       127 if ($self->testDetectSpaces($text, 0, undef, 0, '#stay', undef)) {
2026 0         0 return 1
2027             }
2028             # type => 'DetectIdentifier'
2029 14 100       54 if ($self->testDetectIdentifier($text, 0, undef, 0, '#stay', undef)) {
2030 7         24 return 1
2031             }
2032             # attribute => 'Normal Text'
2033             # char => '\'
2034             # char1 => ')'
2035             # context => '#stay'
2036             # type => 'Detect2Chars'
2037 7 50       27 if ($self->testDetect2Chars($text, '\\', ')', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
2038 0         0 return 1
2039             }
2040             # attribute => 'Operator'
2041             # char => ')'
2042             # context => '#pop#pop#pop'
2043             # endRegion => 'Wordlist'
2044             # type => 'DetectChar'
2045 7 100       29 if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Operator')) {
2046 3         11 return 1
2047             }
2048 4         12 return 0;
2049             };
2050              
2051             sub parseregex_pattern_internal {
2052 0     0 0 0 my ($self, $text) = @_;
2053             # context => 'regex_pattern_internal_rules_1'
2054             # type => 'IncludeRules'
2055 0 0       0 if ($self->includeRules('regex_pattern_internal_rules_1', $text)) {
2056 0         0 return 1
2057             }
2058             # context => 'regex_pattern_internal_rules_2'
2059             # type => 'IncludeRules'
2060 0 0       0 if ($self->includeRules('regex_pattern_internal_rules_2', $text)) {
2061 0         0 return 1
2062             }
2063 0         0 return 0;
2064             };
2065              
2066             sub parseregex_pattern_internal_ip {
2067 260     260 0 477 my ($self, $text) = @_;
2068             # context => 'regex_pattern_internal_rules_1'
2069             # type => 'IncludeRules'
2070 260 100       925 if ($self->includeRules('regex_pattern_internal_rules_1', $text)) {
2071 36         128 return 1
2072             }
2073             # String => '[$@][^]\s{}()|>']'
2074             # attribute => 'Data Type'
2075             # context => 'find_variable_unsafe'
2076             # lookAhead => 'true'
2077             # type => 'RegExpr'
2078 224 100       923 if ($self->testRegExpr($text, '[$@][^]\\s{}()|>\']', 0, 0, 1, undef, 0, 'find_variable_unsafe', 'Data Type')) {
2079 5         22 return 1
2080             }
2081             # context => 'regex_pattern_internal_rules_2'
2082             # type => 'IncludeRules'
2083 219 100       908 if ($self->includeRules('regex_pattern_internal_rules_2', $text)) {
2084 130         716 return 1
2085             }
2086 89         435 return 0;
2087             };
2088              
2089             sub parseregex_pattern_internal_rules_1 {
2090 260     260 0 392 my ($self, $text) = @_;
2091             # String => '#.*$'
2092             # attribute => 'Comment'
2093             # context => '#stay'
2094             # firstNonSpace => 'true'
2095             # type => 'RegExpr'
2096 260 50       1152 if ($self->testRegExpr($text, '#.*$', 0, 0, 0, undef, 1, '#stay', 'Comment')) {
2097 0         0 return 1
2098             }
2099             # String => '\\[anDdSsWw]'
2100             # attribute => 'Pattern Character Class'
2101             # context => '#stay'
2102             # type => 'RegExpr'
2103 260 100       973 if ($self->testRegExpr($text, '\\\\[anDdSsWw]', 0, 0, 0, undef, 0, '#stay', 'Pattern Character Class')) {
2104 20         89 return 1
2105             }
2106             # String => '\\[ABbEGLlNUuQdQZz]'
2107             # attribute => 'Pattern Internal Operator'
2108             # context => '#stay'
2109             # type => 'RegExpr'
2110 240 50       862 if ($self->testRegExpr($text, '\\\\[ABbEGLlNUuQdQZz]', 0, 0, 0, undef, 0, '#stay', 'Pattern Internal Operator')) {
2111 0         0 return 1
2112             }
2113             # String => '\\[\d]+'
2114             # attribute => 'Special Variable'
2115             # context => '#stay'
2116             # type => 'RegExpr'
2117 240 50       825 if ($self->testRegExpr($text, '\\\\[\\d]+', 0, 0, 0, undef, 0, '#stay', 'Special Variable')) {
2118 0         0 return 1
2119             }
2120             # String => '\\.'
2121             # attribute => 'Pattern'
2122             # context => '#stay'
2123             # type => 'RegExpr'
2124 240 100       920 if ($self->testRegExpr($text, '\\\\.', 0, 0, 0, undef, 0, '#stay', 'Pattern')) {
2125 16         62 return 1
2126             }
2127 224         819 return 0;
2128             };
2129              
2130             sub parseregex_pattern_internal_rules_2 {
2131 219     219 0 360 my ($self, $text) = @_;
2132             # attribute => 'Pattern Internal Operator'
2133             # char => '('
2134             # char1 => '?'
2135             # context => 'pat_ext'
2136             # type => 'Detect2Chars'
2137 219 100       859 if ($self->testDetect2Chars($text, '(', '?', 0, 0, 0, undef, 0, 'pat_ext', 'Pattern Internal Operator')) {
2138 3         13 return 1
2139             }
2140             # attribute => 'Pattern Internal Operator'
2141             # char => '['
2142             # context => 'pat_char_class'
2143             # type => 'DetectChar'
2144 216 100       781 if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'pat_char_class', 'Pattern Internal Operator')) {
2145 18         74 return 1
2146             }
2147             # String => '[()?^*+|]'
2148             # attribute => 'Pattern Internal Operator'
2149             # context => '#stay'
2150             # type => 'RegExpr'
2151 198 100       681 if ($self->testRegExpr($text, '[()?^*+|]', 0, 0, 0, undef, 0, '#stay', 'Pattern Internal Operator')) {
2152 109         471 return 1
2153             }
2154             # String => '\{[\d, ]+\}'
2155             # attribute => 'Pattern Internal Operator'
2156             # context => '#stay'
2157             # type => 'RegExpr'
2158 89 50       349 if ($self->testRegExpr($text, '\\{[\\d, ]+\\}', 0, 0, 0, undef, 0, '#stay', 'Pattern Internal Operator')) {
2159 0         0 return 1
2160             }
2161             # attribute => 'Pattern Internal Operator'
2162             # char => '$'
2163             # context => '#stay'
2164             # type => 'DetectChar'
2165 89 50       380 if ($self->testDetectChar($text, '$', 0, 0, 0, undef, 0, '#stay', 'Pattern Internal Operator')) {
2166 0         0 return 1
2167             }
2168             # String => '\s{3,}#.*$'
2169             # attribute => 'Comment'
2170             # context => '#stay'
2171             # type => 'RegExpr'
2172 89 50       380 if ($self->testRegExpr($text, '\\s{3,}#.*$', 0, 0, 0, undef, 0, '#stay', 'Comment')) {
2173 0         0 return 1
2174             }
2175 89         356 return 0;
2176             };
2177              
2178             sub parseslash_safe_escape {
2179 1117     1117 0 2284 my ($self, $text) = @_;
2180             # String => '\s*\]?\s*/'
2181             # attribute => 'Normal Text'
2182             # context => '#pop'
2183             # type => 'RegExpr'
2184 1117 100       6407 if ($self->testRegExpr($text, '\\s*\\]?\\s*/', 0, 0, 0, undef, 0, '#pop', 'Normal Text')) {
2185 4         18 return 1
2186             }
2187             # String => '\s*\}?\s*/'
2188             # attribute => 'Normal Text'
2189             # context => '#pop'
2190             # endRegion => 'Block'
2191             # type => 'RegExpr'
2192 1113 50       5354 if ($self->testRegExpr($text, '\\s*\\}?\\s*/', 0, 0, 0, undef, 0, '#pop', 'Normal Text')) {
2193 0         0 return 1
2194             }
2195             # String => '\s*\)?\s*/'
2196             # attribute => 'Normal Text'
2197             # context => '#pop'
2198             # type => 'RegExpr'
2199 1113 50       11201 if ($self->testRegExpr($text, '\\s*\\)?\\s*/', 0, 0, 0, undef, 0, '#pop', 'Normal Text')) {
2200 0         0 return 1
2201             }
2202             # String => 'keywords'
2203             # attribute => 'Keyword'
2204             # context => '#pop'
2205             # type => 'keyword'
2206 1113 50       6452 if ($self->testKeyword($text, 'keywords', 0, undef, 0, '#pop', 'Keyword')) {
2207 0         0 return 1
2208             }
2209 1113         5299 return 0;
2210             };
2211              
2212             sub parsestring {
2213 3137     3137 0 5152 my ($self, $text) = @_;
2214             # type => 'DetectIdentifier'
2215 3137 100       12613 if ($self->testDetectIdentifier($text, 0, undef, 0, '#stay', undef)) {
2216 1131         3553 return 1
2217             }
2218             # attribute => 'String Special Character'
2219             # char => '\'
2220             # char1 => '''
2221             # context => '#stay'
2222             # type => 'Detect2Chars'
2223 2006 100       7984 if ($self->testDetect2Chars($text, '\\', '\'', 0, 0, 0, undef, 0, '#stay', 'String Special Character')) {
2224 2         9 return 1
2225             }
2226             # attribute => 'String Special Character'
2227             # char => '\'
2228             # char1 => '\'
2229             # context => '#stay'
2230             # type => 'Detect2Chars'
2231 2004 100       7238 if ($self->testDetect2Chars($text, '\\', '\\', 0, 0, 0, undef, 0, '#stay', 'String Special Character')) {
2232 3         12 return 1
2233             }
2234             # attribute => 'Operator'
2235             # char => '''
2236             # context => '#pop'
2237             # endRegion => 'String'
2238             # type => 'DetectChar'
2239 2001 100       13006 if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, '#pop', 'Operator')) {
2240 1102         3894 return 1
2241             }
2242 899         2295 return 0;
2243             };
2244              
2245             sub parsestring_2 {
2246 0     0 0 0 my ($self, $text) = @_;
2247             # type => 'DetectIdentifier'
2248 0 0       0 if ($self->testDetectIdentifier($text, 0, undef, 0, '#stay', undef)) {
2249 0         0 return 1
2250             }
2251             # attribute => 'String Special Character'
2252             # char => '\'
2253             # char1 => ')'
2254             # context => '#stay'
2255             # type => 'Detect2Chars'
2256 0 0       0 if ($self->testDetect2Chars($text, '\\', ')', 0, 0, 0, undef, 0, '#stay', 'String Special Character')) {
2257 0         0 return 1
2258             }
2259             # attribute => 'String Special Character'
2260             # char => '\'
2261             # char1 => '\'
2262             # context => '#stay'
2263             # type => 'Detect2Chars'
2264 0 0       0 if ($self->testDetect2Chars($text, '\\', '\\', 0, 0, 0, undef, 0, '#stay', 'String Special Character')) {
2265 0         0 return 1
2266             }
2267             # attribute => 'String'
2268             # char => '('
2269             # char1 => ')'
2270             # context => '#stay'
2271             # type => 'RangeDetect'
2272 0 0       0 if ($self->testRangeDetect($text, '(', ')', 0, 0, undef, 0, '#stay', 'String')) {
2273 0         0 return 1
2274             }
2275             # attribute => 'Operator'
2276             # char => ')'
2277             # context => '#pop#pop'
2278             # endRegion => 'String'
2279             # type => 'DetectChar'
2280 0 0       0 if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop#pop', 'Operator')) {
2281 0         0 return 1
2282             }
2283 0         0 return 0;
2284             };
2285              
2286             sub parsestring_3 {
2287 0     0 0 0 my ($self, $text) = @_;
2288             # type => 'DetectIdentifier'
2289 0 0       0 if ($self->testDetectIdentifier($text, 0, undef, 0, '#stay', undef)) {
2290 0         0 return 1
2291             }
2292             # attribute => 'String Special Character'
2293             # char => '\'
2294             # char1 => '}'
2295             # context => '#stay'
2296             # type => 'Detect2Chars'
2297 0 0       0 if ($self->testDetect2Chars($text, '\\', '}', 0, 0, 0, undef, 0, '#stay', 'String Special Character')) {
2298 0         0 return 1
2299             }
2300             # attribute => 'String Special Character'
2301             # char => '\'
2302             # char1 => '\'
2303             # context => '#stay'
2304             # type => 'Detect2Chars'
2305 0 0       0 if ($self->testDetect2Chars($text, '\\', '\\', 0, 0, 0, undef, 0, '#stay', 'String Special Character')) {
2306 0         0 return 1
2307             }
2308             # attribute => 'String'
2309             # char => '{'
2310             # char1 => '}'
2311             # context => '#stay'
2312             # type => 'RangeDetect'
2313 0 0       0 if ($self->testRangeDetect($text, '{', '}', 0, 0, undef, 0, '#stay', 'String')) {
2314 0         0 return 1
2315             }
2316             # attribute => 'Operator'
2317             # char => '}'
2318             # context => '#pop#pop'
2319             # endRegion => 'String'
2320             # type => 'DetectChar'
2321 0 0       0 if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop#pop', 'Operator')) {
2322 0         0 return 1
2323             }
2324 0         0 return 0;
2325             };
2326              
2327             sub parsestring_4 {
2328 0     0 0 0 my ($self, $text) = @_;
2329             # type => 'DetectIdentifier'
2330 0 0       0 if ($self->testDetectIdentifier($text, 0, undef, 0, '#stay', undef)) {
2331 0         0 return 1
2332             }
2333             # attribute => 'String Special Character'
2334             # char => '\'
2335             # char1 => ']'
2336             # context => '#stay'
2337             # type => 'Detect2Chars'
2338 0 0       0 if ($self->testDetect2Chars($text, '\\', ']', 0, 0, 0, undef, 0, '#stay', 'String Special Character')) {
2339 0         0 return 1
2340             }
2341             # attribute => 'String Special Character'
2342             # char => '\'
2343             # char1 => '\'
2344             # context => '#stay'
2345             # type => 'Detect2Chars'
2346 0 0       0 if ($self->testDetect2Chars($text, '\\', '\\', 0, 0, 0, undef, 0, '#stay', 'String Special Character')) {
2347 0         0 return 1
2348             }
2349             # attribute => 'String'
2350             # char => '['
2351             # char1 => ']'
2352             # context => '#stay'
2353             # type => 'RangeDetect'
2354 0 0       0 if ($self->testRangeDetect($text, '[', ']', 0, 0, undef, 0, '#stay', 'String')) {
2355 0         0 return 1
2356             }
2357             # attribute => 'Operator'
2358             # char => ']'
2359             # context => '#pop#pop'
2360             # endRegion => 'String'
2361             # type => 'DetectChar'
2362 0 0       0 if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, '#pop#pop', 'Operator')) {
2363 0         0 return 1
2364             }
2365 0         0 return 0;
2366             };
2367              
2368             sub parsestring_5 {
2369 0     0 0 0 my ($self, $text) = @_;
2370             # type => 'DetectIdentifier'
2371 0 0       0 if ($self->testDetectIdentifier($text, 0, undef, 0, '#stay', undef)) {
2372 0         0 return 1
2373             }
2374             # attribute => 'String Special Character'
2375             # char => '\'
2376             # char1 => '<'
2377             # context => '#stay'
2378             # type => 'Detect2Chars'
2379 0 0       0 if ($self->testDetect2Chars($text, '\\', '<', 0, 0, 0, undef, 0, '#stay', 'String Special Character')) {
2380 0         0 return 1
2381             }
2382             # attribute => 'String Special Character'
2383             # char => '\'
2384             # char1 => '\'
2385             # context => '#stay'
2386             # type => 'Detect2Chars'
2387 0 0       0 if ($self->testDetect2Chars($text, '\\', '\\', 0, 0, 0, undef, 0, '#stay', 'String Special Character')) {
2388 0         0 return 1
2389             }
2390             # attribute => 'String'
2391             # char => '\'
2392             # char1 => '>'
2393             # context => '#stay'
2394             # type => 'Detect2Chars'
2395 0 0       0 if ($self->testDetect2Chars($text, '\\', '>', 0, 0, 0, undef, 0, '#stay', 'String')) {
2396 0         0 return 1
2397             }
2398             # attribute => 'String'
2399             # char => '<'
2400             # char1 => '>'
2401             # context => '#stay'
2402             # type => 'RangeDetect'
2403 0 0       0 if ($self->testRangeDetect($text, '<', '>', 0, 0, undef, 0, '#stay', 'String')) {
2404 0         0 return 1
2405             }
2406             # attribute => 'Operator'
2407             # char => '>'
2408             # context => '#pop#pop'
2409             # endRegion => 'String'
2410             # type => 'DetectChar'
2411 0 0       0 if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop#pop', 'Operator')) {
2412 0         0 return 1
2413             }
2414 0         0 return 0;
2415             };
2416              
2417             sub parsestring_6 {
2418 16     16 0 25 my ($self, $text) = @_;
2419             # type => 'DetectIdentifier'
2420 16 100       59 if ($self->testDetectIdentifier($text, 0, undef, 0, '#stay', undef)) {
2421 2         8 return 1
2422             }
2423             # attribute => 'String Special Character'
2424             # char => '\'
2425             # char1 => '\'
2426             # context => '#stay'
2427             # type => 'Detect2Chars'
2428 14 50       53 if ($self->testDetect2Chars($text, '\\', '\\', 0, 0, 0, undef, 0, '#stay', 'String Special Character')) {
2429 0         0 return 1
2430             }
2431             # String => '\\%1'
2432             # attribute => 'String Special Character'
2433             # context => '#stay'
2434             # dynamic => 'true'
2435             # type => 'RegExpr'
2436 14 50       57 if ($self->testRegExpr($text, '\\\\%1', 0, 1, 0, undef, 0, '#stay', 'String Special Character')) {
2437 0         0 return 1
2438             }
2439             # attribute => 'Operator'
2440             # char => '1'
2441             # context => '#pop#pop'
2442             # dynamic => 'true'
2443             # endRegion => 'String'
2444             # type => 'DetectChar'
2445 14 100       50 if ($self->testDetectChar($text, '1', 0, 1, 0, undef, 0, '#pop#pop', 'Operator')) {
2446 2         8 return 1
2447             }
2448 12         32 return 0;
2449             };
2450              
2451             sub parsesub_arg_definition {
2452 6     6 0 12 my ($self, $text) = @_;
2453             # String => '*$@%'
2454             # attribute => 'Data Type'
2455             # context => '#stay'
2456             # type => 'AnyChar'
2457 6 100       29 if ($self->testAnyChar($text, '*$@%', 0, 0, undef, 0, '#stay', 'Data Type')) {
2458 2         8 return 1
2459             }
2460             # String => '&\[];'
2461             # attribute => 'Normal Text'
2462             # context => '#stay'
2463             # type => 'AnyChar'
2464 4 50       24 if ($self->testAnyChar($text, '&\\[];', 0, 0, undef, 0, '#stay', 'Normal Text')) {
2465 0         0 return 1
2466             }
2467             # attribute => 'Normal Text'
2468             # char => ')'
2469             # context => 'slash_safe_escape'
2470             # type => 'DetectChar'
2471 4 100       15 if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, 'slash_safe_escape', 'Normal Text')) {
2472 2         6 return 1
2473             }
2474 2         8 return 0;
2475             };
2476              
2477             sub parsesub_name_def {
2478 184     184 0 525 my ($self, $text) = @_;
2479             # String => '\w+'
2480             # attribute => 'Function'
2481             # context => '#stay'
2482             # type => 'RegExpr'
2483 184 100       675 if ($self->testRegExpr($text, '\\w+', 0, 0, 0, undef, 0, '#stay', 'Function')) {
2484 92         271 return 1
2485             }
2486             # String => '\$\S'
2487             # attribute => 'Normal Text'
2488             # context => 'find_variable'
2489             # lookAhead => 'true'
2490             # type => 'RegExpr'
2491 92 50       443 if ($self->testRegExpr($text, '\\$\\S', 0, 0, 1, undef, 0, 'find_variable', 'Normal Text')) {
2492 0         0 return 1
2493             }
2494             # String => '\s*\('
2495             # attribute => 'Normal Text'
2496             # context => 'sub_arg_definition'
2497             # type => 'RegExpr'
2498 92 100       468 if ($self->testRegExpr($text, '\\s*\\(', 0, 0, 0, undef, 0, 'sub_arg_definition', 'Normal Text')) {
2499 2         7 return 1
2500             }
2501             # attribute => 'Normal Text'
2502             # char => ':'
2503             # char1 => ':'
2504             # context => '#stay'
2505             # type => 'Detect2Chars'
2506 90 100       534 if ($self->testDetect2Chars($text, ':', ':', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
2507 5         14 return 1
2508             }
2509 85         254 return 0;
2510             };
2511              
2512             sub parsesubst_bracket_pattern {
2513 0     0 0 0 my ($self, $text) = @_;
2514             # String => '\s+#.*$'
2515             # attribute => 'Comment'
2516             # context => '#stay'
2517             # type => 'RegExpr'
2518 0 0       0 if ($self->testRegExpr($text, '\\s+#.*$', 0, 0, 0, undef, 0, '#stay', 'Comment')) {
2519 0         0 return 1
2520             }
2521             # context => 'regex_pattern_internal_ip'
2522             # type => 'IncludeRules'
2523 0 0       0 if ($self->includeRules('regex_pattern_internal_ip', $text)) {
2524 0         0 return 1
2525             }
2526             # attribute => 'Operator'
2527             # char => ']'
2528             # context => 'subst_bracket_replace'
2529             # endRegion => 'Pattern'
2530             # type => 'DetectChar'
2531 0 0       0 if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, 'subst_bracket_replace', 'Operator')) {
2532 0         0 return 1
2533             }
2534 0         0 return 0;
2535             };
2536              
2537             sub parsesubst_bracket_replace {
2538 0     0 0 0 my ($self, $text) = @_;
2539             # context => 'ipstring_internal'
2540             # type => 'IncludeRules'
2541 0 0       0 if ($self->includeRules('ipstring_internal', $text)) {
2542 0         0 return 1
2543             }
2544             # attribute => 'Operator'
2545             # beginRegion => 'Replacement'
2546             # char => '['
2547             # context => '#stay'
2548             # type => 'DetectChar'
2549 0 0       0 if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
2550 0         0 return 1
2551             }
2552             # String => '\][cegimosx]*'
2553             # attribute => 'Operator'
2554             # context => '#pop#pop#pop'
2555             # endRegion => 'Replacement'
2556             # type => 'RegExpr'
2557 0 0       0 if ($self->testRegExpr($text, '\\][cegimosx]*', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Operator')) {
2558 0         0 return 1
2559             }
2560 0         0 return 0;
2561             };
2562              
2563             sub parsesubst_curlybrace_middle {
2564 0     0 0 0 my ($self, $text) = @_;
2565             # String => '#.*$'
2566             # attribute => 'Comment'
2567             # context => '#stay'
2568             # type => 'RegExpr'
2569 0 0       0 if ($self->testRegExpr($text, '#.*$', 0, 0, 0, undef, 0, '#stay', 'Comment')) {
2570 0         0 return 1
2571             }
2572             # attribute => 'Operator'
2573             # beginRegion => 'Replacement'
2574             # char => '{'
2575             # context => 'subst_curlybrace_replace'
2576             # type => 'DetectChar'
2577 0 0       0 if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'subst_curlybrace_replace', 'Operator')) {
2578 0         0 return 1
2579             }
2580 0         0 return 0;
2581             };
2582              
2583             sub parsesubst_curlybrace_pattern {
2584 0     0 0 0 my ($self, $text) = @_;
2585             # String => '\s+#.*$'
2586             # attribute => 'Comment'
2587             # context => '#stay'
2588             # type => 'RegExpr'
2589 0 0       0 if ($self->testRegExpr($text, '\\s+#.*$', 0, 0, 0, undef, 0, '#stay', 'Comment')) {
2590 0         0 return 1
2591             }
2592             # context => 'regex_pattern_internal_ip'
2593             # type => 'IncludeRules'
2594 0 0       0 if ($self->includeRules('regex_pattern_internal_ip', $text)) {
2595 0         0 return 1
2596             }
2597             # attribute => 'Operator'
2598             # char => '}'
2599             # context => 'subst_curlybrace_middle'
2600             # endRegion => 'Pattern'
2601             # type => 'DetectChar'
2602 0 0       0 if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, 'subst_curlybrace_middle', 'Operator')) {
2603 0         0 return 1
2604             }
2605 0         0 return 0;
2606             };
2607              
2608             sub parsesubst_curlybrace_replace {
2609 0     0 0 0 my ($self, $text) = @_;
2610             # context => 'ipstring_internal'
2611             # type => 'IncludeRules'
2612 0 0       0 if ($self->includeRules('ipstring_internal', $text)) {
2613 0         0 return 1
2614             }
2615             # attribute => 'Normal Text'
2616             # beginRegion => 'Block'
2617             # char => '{'
2618             # context => 'subst_curlybrace_replace_recursive'
2619             # type => 'DetectChar'
2620 0 0       0 if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'subst_curlybrace_replace_recursive', 'Normal Text')) {
2621 0         0 return 1
2622             }
2623             # String => '\}[cegimosx]*'
2624             # attribute => 'Operator'
2625             # context => '#pop#pop#pop#pop'
2626             # endRegion => 'Replacement'
2627             # type => 'RegExpr'
2628 0 0       0 if ($self->testRegExpr($text, '\\}[cegimosx]*', 0, 0, 0, undef, 0, '#pop#pop#pop#pop', 'Operator')) {
2629 0         0 return 1
2630             }
2631 0         0 return 0;
2632             };
2633              
2634             sub parsesubst_curlybrace_replace_recursive {
2635 0     0 0 0 my ($self, $text) = @_;
2636             # attribute => 'String (interpolated)'
2637             # beginRegion => 'Block'
2638             # char => '{'
2639             # context => 'subst_curlybrace_replace_recursive'
2640             # type => 'DetectChar'
2641 0 0       0 if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'subst_curlybrace_replace_recursive', 'String (interpolated)')) {
2642 0         0 return 1
2643             }
2644             # attribute => 'Normal Text'
2645             # char => '}'
2646             # context => '#pop'
2647             # endRegion => 'Block'
2648             # type => 'DetectChar'
2649 0 0       0 if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop', 'Normal Text')) {
2650 0         0 return 1
2651             }
2652             # context => 'ipstring_internal'
2653             # type => 'IncludeRules'
2654 0 0       0 if ($self->includeRules('ipstring_internal', $text)) {
2655 0         0 return 1
2656             }
2657 0         0 return 0;
2658             };
2659              
2660             sub parsesubst_paren_pattern {
2661 0     0 0 0 my ($self, $text) = @_;
2662             # String => '\s+#.*$'
2663             # attribute => 'Comment'
2664             # context => '#stay'
2665             # type => 'RegExpr'
2666 0 0       0 if ($self->testRegExpr($text, '\\s+#.*$', 0, 0, 0, undef, 0, '#stay', 'Comment')) {
2667 0         0 return 1
2668             }
2669             # context => 'regex_pattern_internal_ip'
2670             # type => 'IncludeRules'
2671 0 0       0 if ($self->includeRules('regex_pattern_internal_ip', $text)) {
2672 0         0 return 1
2673             }
2674             # attribute => 'Operator'
2675             # char => '}'
2676             # context => 'subst_paren_replace'
2677             # endRegion => 'Pattern'
2678             # type => 'DetectChar'
2679 0 0       0 if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, 'subst_paren_replace', 'Operator')) {
2680 0         0 return 1
2681             }
2682 0         0 return 0;
2683             };
2684              
2685             sub parsesubst_paren_replace {
2686 0     0 0 0 my ($self, $text) = @_;
2687             # context => 'ipstring_internal'
2688             # type => 'IncludeRules'
2689 0 0       0 if ($self->includeRules('ipstring_internal', $text)) {
2690 0         0 return 1
2691             }
2692             # attribute => 'Operator'
2693             # beginRegion => 'Replacement'
2694             # char => '('
2695             # context => '#stay'
2696             # type => 'DetectChar'
2697 0 0       0 if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
2698 0         0 return 1
2699             }
2700             # String => '\)[cegimosx]*'
2701             # attribute => 'Operator'
2702             # context => '#pop#pop#pop'
2703             # endRegion => 'Replacement'
2704             # type => 'RegExpr'
2705 0 0       0 if ($self->testRegExpr($text, '\\)[cegimosx]*', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Operator')) {
2706 0         0 return 1
2707             }
2708 0         0 return 0;
2709             };
2710              
2711             sub parsesubst_slash_pattern {
2712 103     103 0 177 my ($self, $text) = @_;
2713             # String => '\$(?=%1)'
2714             # attribute => 'Pattern Internal Operator'
2715             # context => '#stay'
2716             # dynamic => 'true'
2717             # type => 'RegExpr'
2718 103 100       372 if ($self->testRegExpr($text, '\\$(?=%1)', 0, 1, 0, undef, 0, '#stay', 'Pattern Internal Operator')) {
2719 1         5 return 1
2720             }
2721             # String => '(%1)'
2722             # attribute => 'Operator'
2723             # beginRegion => 'Replacement'
2724             # context => 'subst_slash_replace'
2725             # dynamic => 'true'
2726             # endRegion => 'Pattern'
2727             # type => 'RegExpr'
2728 102 100       511 if ($self->testRegExpr($text, '(%1)', 0, 1, 0, undef, 0, 'subst_slash_replace', 'Operator')) {
2729 26         88 return 1
2730             }
2731             # context => 'regex_pattern_internal_ip'
2732             # type => 'IncludeRules'
2733 76 100       328 if ($self->includeRules('regex_pattern_internal_ip', $text)) {
2734 47         140 return 1
2735             }
2736 29         90 return 0;
2737             };
2738              
2739             sub parsesubst_slash_replace {
2740 44     44 0 85 my ($self, $text) = @_;
2741             # context => 'ipstring_internal'
2742             # type => 'IncludeRules'
2743 44 100       232 if ($self->includeRules('ipstring_internal', $text)) {
2744 12         42 return 1
2745             }
2746             # String => '%1[cegimosx]*'
2747             # attribute => 'Operator'
2748             # context => '#pop#pop#pop'
2749             # dynamic => 'true'
2750             # endRegion => 'Replacement'
2751             # type => 'RegExpr'
2752 32 100       148 if ($self->testRegExpr($text, '%1[cegimosx]*', 0, 1, 0, undef, 0, '#pop#pop#pop', 'Operator')) {
2753 26         90 return 1
2754             }
2755 6         24 return 0;
2756             };
2757              
2758             sub parsesubst_sq_pattern {
2759 0     0 0 0 my ($self, $text) = @_;
2760             # String => '\s+#.*$'
2761             # attribute => 'Comment'
2762             # context => '#stay'
2763             # type => 'RegExpr'
2764 0 0       0 if ($self->testRegExpr($text, '\\s+#.*$', 0, 0, 0, undef, 0, '#stay', 'Comment')) {
2765 0         0 return 1
2766             }
2767             # context => 'regex_pattern_internal'
2768             # type => 'IncludeRules'
2769 0 0       0 if ($self->includeRules('regex_pattern_internal', $text)) {
2770 0         0 return 1
2771             }
2772             # attribute => 'Operator'
2773             # beginRegion => 'Pattern'
2774             # char => '''
2775             # context => 'subst_sq_replace'
2776             # endRegion => 'Pattern'
2777             # type => 'DetectChar'
2778 0 0       0 if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, 'subst_sq_replace', 'Operator')) {
2779 0         0 return 1
2780             }
2781 0         0 return 0;
2782             };
2783              
2784             sub parsesubst_sq_replace {
2785 0     0 0 0 my ($self, $text) = @_;
2786             # String => ''[cegimosx]*'
2787             # attribute => 'Operator'
2788             # context => '#pop#pop#pop'
2789             # endRegion => 'Replacement'
2790             # type => 'RegExpr'
2791 0 0       0 if ($self->testRegExpr($text, '\'[cegimosx]*', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Operator')) {
2792 0         0 return 1
2793             }
2794 0         0 return 0;
2795             };
2796              
2797             sub parsetr {
2798 0     0 0 0 my ($self, $text) = @_;
2799             # String => '\([^)]*\)\s*\(?:[^)]*\)'
2800             # attribute => 'Pattern'
2801             # context => '#pop'
2802             # type => 'RegExpr'
2803 0 0       0 if ($self->testRegExpr($text, '\\([^)]*\\)\\s*\\(?:[^)]*\\)', 0, 0, 0, undef, 0, '#pop', 'Pattern')) {
2804 0         0 return 1
2805             }
2806             # String => '\{[^}]*\}\s*\{[^}]*\}'
2807             # attribute => 'Pattern'
2808             # context => '#pop'
2809             # type => 'RegExpr'
2810 0 0       0 if ($self->testRegExpr($text, '\\{[^}]*\\}\\s*\\{[^}]*\\}', 0, 0, 0, undef, 0, '#pop', 'Pattern')) {
2811 0         0 return 1
2812             }
2813             # String => '\[[^}]*\]\s*\[[^\]]*\]'
2814             # attribute => 'Pattern'
2815             # context => '#pop'
2816             # type => 'RegExpr'
2817 0 0       0 if ($self->testRegExpr($text, '\\[[^}]*\\]\\s*\\[[^\\]]*\\]', 0, 0, 0, undef, 0, '#pop', 'Pattern')) {
2818 0         0 return 1
2819             }
2820             # String => '([^a-zA-Z0-9_\s[\]{}()]).*\1.*\1'
2821             # attribute => 'Pattern'
2822             # context => '#pop'
2823             # minimal => 'true'
2824             # type => 'RegExpr'
2825 0 0       0 if ($self->testRegExpr($text, '([^a-zA-Z0-9_\\s[\\]{}()]).*?\\1.*?\\1', 0, 0, 0, undef, 0, '#pop', 'Pattern')) {
2826 0         0 return 1
2827             }
2828 0         0 return 0;
2829             };
2830              
2831             sub parsevar_detect {
2832 2491     2491 0 13370 my ($self, $text) = @_;
2833             # context => 'var_detect_rules'
2834             # type => 'IncludeRules'
2835 2491 100       11962 if ($self->includeRules('var_detect_rules', $text)) {
2836 1432         4783 return 1
2837             }
2838             # context => 'slash_safe_escape'
2839             # type => 'IncludeRules'
2840 1059 100       4344 if ($self->includeRules('slash_safe_escape', $text)) {
2841 2         7 return 1
2842             }
2843 1057         4599 return 0;
2844             };
2845              
2846             sub parsevar_detect_rules {
2847 2552     2552 0 6514 my ($self, $text) = @_;
2848             # String => '[\w_]+'
2849             # attribute => 'Data Type'
2850             # context => '#stay'
2851             # type => 'RegExpr'
2852 2552 100       9948 if ($self->testRegExpr($text, '[\\w_]+', 0, 0, 0, undef, 0, '#stay', 'Data Type')) {
2853 1201         10468 return 1
2854             }
2855             # attribute => 'Normal Text'
2856             # char => ':'
2857             # char1 => ':'
2858             # context => '#stay'
2859             # type => 'Detect2Chars'
2860 1351 100       7573 if ($self->testDetect2Chars($text, ':', ':', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
2861 1         4 return 1
2862             }
2863             # attribute => 'Operator'
2864             # char => '''
2865             # context => '#stay'
2866             # type => 'DetectChar'
2867 1350 100       5951 if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
2868 7         33 return 1
2869             }
2870             # attribute => 'Normal Text'
2871             # char => '-'
2872             # char1 => '>'
2873             # context => '#stay'
2874             # type => 'Detect2Chars'
2875 1343 100       5405 if ($self->testDetect2Chars($text, '-', '>', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
2876 256         1535 return 1
2877             }
2878             # attribute => 'Normal Text'
2879             # char => '+'
2880             # char1 => '+'
2881             # context => '#stay'
2882             # type => 'Detect2Chars'
2883 1087 50       5198 if ($self->testDetect2Chars($text, '+', '+', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
2884 0         0 return 1
2885             }
2886             # attribute => 'Normal Text'
2887             # char => '-'
2888             # char1 => '-'
2889             # context => '#stay'
2890             # type => 'Detect2Chars'
2891 1087 50       4937 if ($self->testDetect2Chars($text, '-', '-', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
2892 0         0 return 1
2893             }
2894 1087         4105 return 0;
2895             };
2896              
2897             sub parsevar_detect_unsafe {
2898 61     61 0 140 my ($self, $text) = @_;
2899             # context => 'var_detect_rules'
2900             # type => 'IncludeRules'
2901 61 100       272 if ($self->includeRules('var_detect_rules', $text)) {
2902 33         119 return 1
2903             }
2904 28         88 return 0;
2905             };
2906              
2907              
2908             1;
2909              
2910             __END__