# Copyright (c) 2005 - 2006 Hans Jeuken. All rights reserved.
# This program is free software; you can redistribute it and/or
# modify it under the same terms as Perl itself.

# This file was generated from the 'ruby.xml' file of the syntax highlight
# engine of the kate text editor (http://www.kate-editor.org

#kate xml version 1.16
#kate version 2.4
#kate author Stefan Lang (langstefan@gmx.at), Sebastian Vuorinen (sebastian.vuorinen@helsinki.fi)
#generated: Sun Feb  3 22:02:06 2008, localtime

package Syntax::Highlight::Engine::Kate::Ruby;

our $VERSION = '0.16';

use strict;
use warnings;
use base('Syntax::Highlight::Engine::Kate::Template');

sub new {
   my $proto = shift;
   my $class = ref($proto) || $proto;
   my $self = $class->SUPER::new(@_);
   $self->attributes({
      'Access Control' => 'Keyword',
      'Alert' => 'Alert',
      'Attribute Definition' => 'Others',
      'Bin' => 'BaseN',
      'Blockcomment' => 'Comment',
      'Char' => 'Char',
      'Class Variable' => 'Others',
      'Command' => 'String',
      'Comment' => 'Comment',
      'Constant' => 'DataType',
      'Constant Value' => 'DataType',
      'Data' => 'Normal',
      'Dec' => 'DecVal',
      'Default globals' => 'DataType',
      'Definition' => 'Keyword',
      'Delimiter' => 'Char',
      'Error' => 'Error',
      'Expression' => 'Others',
      'Float' => 'Float',
      'GDL input' => 'Others',
      'Global Constant' => 'DataType',
      'Global Variable' => 'DataType',
      'Hex' => 'BaseN',
      'Instance Variable' => 'Others',
      'Kernel methods' => 'Normal',
      'Keyword' => 'Keyword',
      'Member' => 'Normal',
      'Message' => 'Normal',
      'Normal Text' => 'Normal',
      'Octal' => 'BaseN',
      'Operator' => 'Char',
      'Pseudo variable' => 'DecVal',
      'RDoc Value' => 'Others',
      'Raw String' => 'String',
      'Region Marker' => 'Normal',
      'Regular Expression' => 'Others',
      'String' => 'String',
      'Substitution' => 'Others',
      'Symbol' => 'String',
   });
   $self->listAdd('access-control',
      'private',
      'private_class_method',
      'protected',
      'public',
      'public_class_method',
   );
   $self->listAdd('attention',
      'FIXME',
      'NOTE',
      'TODO',
   );
   $self->listAdd('attribute-definitions',
      'attr_accessor',
      'attr_reader',
      'attr_writer',
   );
   $self->listAdd('default-globals',
      '$deferr',
      '$defout',
      '$stderr',
      '$stdin',
      '$stdout',
   );
   $self->listAdd('definitions',
      'alias',
      'class',
      'def',
      'module',
      'undef',
   );
   $self->listAdd('kernel-methods',
      'abort',
      'at_exit',
      'autoload',
      'autoload?',
      'binding',
      'block_given?',
      'callcc',
      'caller',
      'catch',
      'chomp',
      'chomp!',
      'chop',
      'chop!',
      'eval',
      'exec',
      'exit',
      'exit!',
      'fail',
      'fork',
      'format',
      'getc',
      'gets',
      'global_variables',
      'gsub',
      'gsub!',
      'iterator?',
      'lambda',
      'load',
      'local_variables',
      'loop',
      'method_missing',
      'open',
      'p',
      'print',
      'printf',
      'proc',
      'putc',
      'puts',
      'raise',
      'rand',
      'readline',
      'readlines',
      'require',
      'scan',
      'select',
      'set_trace_func',
      'sleep',
      'split',
      'sprintf',
      'srand',
      'sub',
      'sub!',
      'syscall',
      'system',
      'test',
      'throw',
      'trace_var',
      'trap',
      'untrace_var',
      'warn',
   );
   $self->listAdd('keywords',
      'BEGIN',
      'END',
      'and',
      'begin',
      'break',
      'case',
      'defined?',
      'do',
      'else',
      'elsif',
      'end',
      'ensure',
      'for',
      'if',
      'in',
      'include',
      'next',
      'not',
      'or',
      'redo',
      'rescue',
      'retry',
      'return',
      'then',
      'unless',
      'until',
      'when',
      'while',
      'yield',
   );
   $self->listAdd('pseudo-variables',
      '__FILE__',
      '__LINE__',
      'caller',
      'false',
      'nil',
      'self',
      'super',
      'true',
   );
   $self->contextdata({
      'Apostrophed String' => {
         callback => \&parseApostrophedString,
         attribute => 'Raw String',
      },
      'Command String' => {
         callback => \&parseCommandString,
         attribute => 'Command',
      },
      'Comment Line' => {
         callback => \&parseCommentLine,
         attribute => 'Comment',
         lineending => '#pop',
      },
      'DATA' => {
         callback => \&parseDATA,
         attribute => 'Data',
      },
      'Embedded documentation' => {
         callback => \&parseEmbeddeddocumentation,
         attribute => 'Comment',
      },
      'General Comment' => {
         callback => \&parseGeneralComment,
         attribute => 'Comment',
         lineending => '#pop',
      },
      'Line Continue' => {
         callback => \&parseLineContinue,
         attribute => 'Normal Text',
         lineending => '#pop',
      },
      'Member Access' => {
         callback => \&parseMemberAccess,
         attribute => 'Member',
         lineending => '#pop',
      },
      'Normal' => {
         callback => \&parseNormal,
         attribute => 'Normal Text',
      },
      'Quoted String' => {
         callback => \&parseQuotedString,
         attribute => 'String',
      },
      'RDoc Label' => {
         callback => \&parseRDocLabel,
         attribute => 'RDoc Value',
         lineending => '#pop',
      },
      'RegEx 1' => {
         callback => \&parseRegEx1,
         attribute => 'Regular Expression',
      },
      'Short Subst' => {
         callback => \&parseShortSubst,
         attribute => 'Substitution',
         lineending => '#pop',
      },
      'Subst' => {
         callback => \&parseSubst,
         attribute => 'Normal Text',
      },
      'apostrophed_indented_heredoc' => {
         callback => \&parseapostrophed_indented_heredoc,
         attribute => 'Normal Text',
         dynamic => 1,
      },
      'apostrophed_normal_heredoc' => {
         callback => \&parseapostrophed_normal_heredoc,
         attribute => 'Normal Text',
         dynamic => 1,
      },
      'apostrophed_rules' => {
         callback => \&parseapostrophed_rules,
         attribute => 'Raw String',
      },
      'dq_string_rules' => {
         callback => \&parsedq_string_rules,
         attribute => 'String',
      },
      'find_gdl_input' => {
         callback => \&parsefind_gdl_input,
         attribute => 'Normal Text',
         lineending => '#pop',
      },
      'find_heredoc' => {
         callback => \&parsefind_heredoc,
         attribute => 'Normal Text',
         lineending => '#pop',
      },
      'find_indented_heredoc' => {
         callback => \&parsefind_indented_heredoc,
         attribute => 'Normal Text',
         lineending => '#pop',
      },
      'gdl_apostrophed_1' => {
         callback => \&parsegdl_apostrophed_1,
         attribute => 'Raw String',
      },
      'gdl_apostrophed_1_nested' => {
         callback => \&parsegdl_apostrophed_1_nested,
         attribute => 'Raw String',
      },
      'gdl_apostrophed_2' => {
         callback => \&parsegdl_apostrophed_2,
         attribute => 'Raw String',
      },
      'gdl_apostrophed_2_nested' => {
         callback => \&parsegdl_apostrophed_2_nested,
         attribute => 'Raw String',
      },
      'gdl_apostrophed_3' => {
         callback => \&parsegdl_apostrophed_3,
         attribute => 'Raw String',
      },
      'gdl_apostrophed_3_nested' => {
         callback => \&parsegdl_apostrophed_3_nested,
         attribute => 'Raw String',
      },
      'gdl_apostrophed_4' => {
         callback => \&parsegdl_apostrophed_4,
         attribute => 'Raw String',
      },
      'gdl_apostrophed_4_nested' => {
         callback => \&parsegdl_apostrophed_4_nested,
         attribute => 'Raw String',
      },
      'gdl_apostrophed_5' => {
         callback => \&parsegdl_apostrophed_5,
         attribute => 'Raw String',
         dynamic => 1,
      },
      'gdl_dq_string_1' => {
         callback => \&parsegdl_dq_string_1,
         attribute => 'String',
      },
      'gdl_dq_string_1_nested' => {
         callback => \&parsegdl_dq_string_1_nested,
         attribute => 'String',
      },
      'gdl_dq_string_2' => {
         callback => \&parsegdl_dq_string_2,
         attribute => 'String',
      },
      'gdl_dq_string_2_nested' => {
         callback => \&parsegdl_dq_string_2_nested,
         attribute => 'String',
      },
      'gdl_dq_string_3' => {
         callback => \&parsegdl_dq_string_3,
         attribute => 'String',
      },
      'gdl_dq_string_3_nested' => {
         callback => \&parsegdl_dq_string_3_nested,
         attribute => 'String',
      },
      'gdl_dq_string_4' => {
         callback => \&parsegdl_dq_string_4,
         attribute => 'String',
      },
      'gdl_dq_string_4_nested' => {
         callback => \&parsegdl_dq_string_4_nested,
         attribute => 'String',
      },
      'gdl_dq_string_5' => {
         callback => \&parsegdl_dq_string_5,
         attribute => 'String',
         dynamic => 1,
      },
      'gdl_regexpr_1' => {
         callback => \&parsegdl_regexpr_1,
         attribute => 'Regular Expression',
      },
      'gdl_regexpr_1_nested' => {
         callback => \&parsegdl_regexpr_1_nested,
         attribute => 'Regular Expression',
      },
      'gdl_regexpr_2' => {
         callback => \&parsegdl_regexpr_2,
         attribute => 'Regular Expression',
      },
      'gdl_regexpr_2_nested' => {
         callback => \&parsegdl_regexpr_2_nested,
         attribute => 'Regular Expression',
      },
      'gdl_regexpr_3' => {
         callback => \&parsegdl_regexpr_3,
         attribute => 'Regular Expression',
      },
      'gdl_regexpr_3_nested' => {
         callback => \&parsegdl_regexpr_3_nested,
         attribute => 'Regular Expression',
      },
      'gdl_regexpr_4' => {
         callback => \&parsegdl_regexpr_4,
         attribute => 'Regular Expression',
      },
      'gdl_regexpr_4_nested' => {
         callback => \&parsegdl_regexpr_4_nested,
         attribute => 'Regular Expression',
      },
      'gdl_regexpr_5' => {
         callback => \&parsegdl_regexpr_5,
         attribute => 'Regular Expression',
         dynamic => 1,
      },
      'gdl_shell_command_1' => {
         callback => \&parsegdl_shell_command_1,
         attribute => 'Command',
      },
      'gdl_shell_command_1_nested' => {
         callback => \&parsegdl_shell_command_1_nested,
         attribute => 'Command',
      },
      'gdl_shell_command_2' => {
         callback => \&parsegdl_shell_command_2,
         attribute => 'Command',
      },
      'gdl_shell_command_2_nested' => {
         callback => \&parsegdl_shell_command_2_nested,
         attribute => 'Command',
      },
      'gdl_shell_command_3' => {
         callback => \&parsegdl_shell_command_3,
         attribute => 'Command',
      },
      'gdl_shell_command_3_nested' => {
         callback => \&parsegdl_shell_command_3_nested,
         attribute => 'Command',
      },
      'gdl_shell_command_4' => {
         callback => \&parsegdl_shell_command_4,
         attribute => 'Command',
      },
      'gdl_shell_command_4_nested' => {
         callback => \&parsegdl_shell_command_4_nested,
         attribute => 'Command',
      },
      'gdl_shell_command_5' => {
         callback => \&parsegdl_shell_command_5,
         attribute => 'Command',
         dynamic => 1,
      },
      'gdl_token_array_1' => {
         callback => \&parsegdl_token_array_1,
         attribute => 'String',
      },
      'gdl_token_array_1_nested' => {
         callback => \&parsegdl_token_array_1_nested,
         attribute => 'String',
      },
      'gdl_token_array_2' => {
         callback => \&parsegdl_token_array_2,
         attribute => 'String',
      },
      'gdl_token_array_2_nested' => {
         callback => \&parsegdl_token_array_2_nested,
         attribute => 'String',
      },
      'gdl_token_array_3' => {
         callback => \&parsegdl_token_array_3,
         attribute => 'String',
      },
      'gdl_token_array_3_nested' => {
         callback => \&parsegdl_token_array_3_nested,
         attribute => 'String',
      },
      'gdl_token_array_4' => {
         callback => \&parsegdl_token_array_4,
         attribute => 'String',
      },
      'gdl_token_array_4_nested' => {
         callback => \&parsegdl_token_array_4_nested,
         attribute => 'String',
      },
      'gdl_token_array_5' => {
         callback => \&parsegdl_token_array_5,
         attribute => 'String',
         dynamic => 1,
      },
      'heredoc_rules' => {
         callback => \&parseheredoc_rules,
         attribute => 'Normal Text',
      },
      'indented_heredoc' => {
         callback => \&parseindented_heredoc,
         attribute => 'Normal Text',
         dynamic => 1,
      },
      'normal_heredoc' => {
         callback => \&parsenormal_heredoc,
         attribute => 'Normal Text',
         dynamic => 1,
      },
      'regexpr_rules' => {
         callback => \&parseregexpr_rules,
         attribute => 'Regular Expression',
      },
      'shell_command_rules' => {
         callback => \&parseshell_command_rules,
         attribute => 'Command',
      },
      'token_array_rules' => {
         callback => \&parsetoken_array_rules,
         attribute => 'String',
      },
   });
   $self->deliminators('\\s||\\.|\\(|\\)|:|\\+|,|-|<|=|>|\\%|\\&|\\*|\\/|;|\\[|\\]|\\^|\\{|\\||\\}|\\~|\\\\|\\!|\\?');
   $self->basecontext('Normal');
   $self->keywordscase(0);
   $self->initialize;
   bless ($self, $class);
   return $self;
}

sub language {
   return 'Ruby';
}

sub parseApostrophedString {
   my ($self, $text) = @_;
   # String => '\\'
   # attribute => 'String'
   # context => '#stay'
   # type => 'StringDetect'
   if ($self->testStringDetect($text, '\\\\', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # String => '\\\''
   # attribute => 'String'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\\\\\\'', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '''
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, '#pop', 'Raw String')) {
      return 1
   }
   return 0;
};

sub parseCommandString {
   my ($self, $text) = @_;
   # String => '\\'
   # attribute => 'String'
   # context => '#stay'
   # type => 'StringDetect'
   if ($self->testStringDetect($text, '\\\\', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # String => '\\\`'
   # attribute => 'String'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\\\\\`', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # String => '#@{1,2}'
   # attribute => 'Substitution'
   # context => 'Short Subst'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#@{1,2}', 0, 0, 0, undef, 0, 'Short Subst', 'Substitution')) {
      return 1
   }
   # attribute => 'Substitution'
   # char => '#'
   # char1 => '{'
   # context => 'Subst'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '#', '{', 0, 0, 0, undef, 0, 'Subst', 'Substitution')) {
      return 1
   }
   # attribute => 'Char'
   # context => '#pop'
   # type => 'HlCChar'
   if ($self->testHlCChar($text, 0, undef, 0, '#pop', 'Char')) {
      return 1
   }
   # attribute => 'Command'
   # char => '`'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '`', 0, 0, 0, undef, 0, '#pop', 'Command')) {
      return 1
   }
   return 0;
};

sub parseCommentLine {
   my ($self, $text) = @_;
   # String => '\w\:\:\s'
   # attribute => 'Comment'
   # context => 'RDoc Label'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\w\\:\\:\\s', 0, 0, 0, undef, 0, 'RDoc Label', 'Comment')) {
      return 1
   }
   # String => 'attention'
   # attribute => 'Alert'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'attention', 0, undef, 0, '#stay', 'Alert')) {
      return 1
   }
   return 0;
};

sub parseDATA {
   my ($self, $text) = @_;
   return 0;
};

sub parseEmbeddeddocumentation {
   my ($self, $text) = @_;
   # String => '=end'
   # attribute => 'Comment'
   # column => '0'
   # context => '#pop'
   # endRegion => 'comment block'
   # type => 'StringDetect'
   if ($self->testStringDetect($text, '=end', 0, 0, 0, 0, 0, '#pop', 'Comment')) {
      return 1
   }
   return 0;
};

sub parseGeneralComment {
   my ($self, $text) = @_;
   # String => 'attention'
   # attribute => 'Dec'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'attention', 0, undef, 0, '#stay', 'Dec')) {
      return 1
   }
   return 0;
};

sub parseLineContinue {
   my ($self, $text) = @_;
   # String => '(while|until)\b(?!.*\bdo\b)'
   # attribute => 'Keyword'
   # context => '#stay'
   # firstNonSpace => 'true'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '(while|until)\\b(?!.*\\bdo\\b)', 0, 0, 0, undef, 1, '#stay', 'Keyword')) {
      return 1
   }
   # String => '(if|unless)\b'
   # attribute => 'Keyword'
   # context => '#stay'
   # firstNonSpace => 'true'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '(if|unless)\\b', 0, 0, 0, undef, 1, '#stay', 'Keyword')) {
      return 1
   }
   # context => 'Normal'
   # type => 'IncludeRules'
   if ($self->includeRules('Normal', $text)) {
      return 1
   }
   return 0;
};

sub parseMemberAccess {
   my ($self, $text) = @_;
   # String => '\.?[_a-z]\w*(\?|\!)?(?=[^\w\d\.\:])'
   # attribute => 'Message'
   # context => '#pop'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\.?[_a-z]\\w*(\\?|\\!)?(?=[^\\w\\d\\.\\:])', 0, 0, 0, undef, 0, '#pop', 'Message')) {
      return 1
   }
   # String => '\.?[_a-z]\w*(\?|\!)?'
   # attribute => 'Message'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\.?[_a-z]\\w*(\\?|\\!)?', 0, 0, 0, undef, 0, '#stay', 'Message')) {
      return 1
   }
   # String => '[A-Z]+_*(\d|[a-z])\w*(?=[^\w\d\.\:])'
   # attribute => 'Constant'
   # context => '#pop'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '[A-Z]+_*(\\d|[a-z])\\w*(?=[^\\w\\d\\.\\:])', 0, 0, 0, undef, 0, '#pop', 'Constant')) {
      return 1
   }
   # String => '[A-Z]+_*([0-9]|[a-z])\w*'
   # attribute => 'Constant'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '[A-Z]+_*([0-9]|[a-z])\\w*', 0, 0, 0, undef, 0, '#stay', 'Constant')) {
      return 1
   }
   # String => '[_A-Z][_A-Z0-9]*(?=[^\w\d\.\:])'
   # attribute => 'Constant Value'
   # context => '#pop'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '[_A-Z][_A-Z0-9]*(?=[^\\w\\d\\.\\:])', 0, 0, 0, undef, 0, '#pop', 'Constant Value')) {
      return 1
   }
   # String => '[_A-Z][_A-Z0-9]*'
   # attribute => 'Constant Value'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '[_A-Z][_A-Z0-9]*', 0, 0, 0, undef, 0, '#stay', 'Constant Value')) {
      return 1
   }
   # attribute => 'Operator'
   # char => ':'
   # char1 => ':'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, ':', ':', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
      return 1
   }
   # attribute => 'Member'
   # char => '.'
   # context => '#stay'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '.', 0, 0, 0, undef, 0, '#stay', 'Member')) {
      return 1
   }
   # String => '=+-*/%|&[]{}~'
   # attribute => 'Operator'
   # context => '#pop'
   # type => 'AnyChar'
   if ($self->testAnyChar($text, '=+-*/%|&[]{}~', 0, 0, undef, 0, '#pop', 'Operator')) {
      return 1
   }
   # attribute => 'Comment'
   # char => '#'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '#', 0, 0, 0, undef, 0, '#pop', 'Comment')) {
      return 1
   }
   # String => '()\'
   # attribute => 'Normal Text'
   # context => '#pop'
   # type => 'AnyChar'
   if ($self->testAnyChar($text, '()\\', 0, 0, undef, 0, '#pop', 'Normal Text')) {
      return 1
   }
   # String => '\W'
   # attribute => 'Member'
   # context => '#pop'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\W', 0, 0, 0, undef, 0, '#pop', 'Member')) {
      return 1
   }
   return 0;
};

sub parseNormal {
   my ($self, $text) = @_;
   # attribute => 'Normal Text'
   # context => 'Line Continue'
   # type => 'LineContinue'
   if ($self->testLineContinue($text, 0, undef, 0, 'Line Continue', 'Normal Text')) {
      return 1
   }
   # String => '__END__$'
   # attribute => 'Keyword'
   # column => '0'
   # context => 'DATA'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '__END__$', 0, 0, 0, 0, 0, 'DATA', 'Keyword')) {
      return 1
   }
   # String => '#!\/.*'
   # attribute => 'Keyword'
   # column => '0'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#!\\/.*', 0, 0, 0, 0, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '(\=|\(|\[|\{)\s*(if|unless|while|until)\b'
   # attribute => 'Keyword'
   # beginRegion => 'def block'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '(\\=|\\(|\\[|\\{)\\s*(if|unless|while|until)\\b', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '(while|until)\b(?!.*\bdo\b)'
   # attribute => 'Keyword'
   # beginRegion => 'def block'
   # context => '#stay'
   # firstNonSpace => 'true'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '(while|until)\\b(?!.*\\bdo\\b)', 0, 0, 0, undef, 1, '#stay', 'Keyword')) {
      return 1
   }
   # String => '\;\s*(while|until)\b(?!.*\bdo\b)'
   # attribute => 'Keyword'
   # beginRegion => 'def block'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\;\\s*(while|until)\\b(?!.*\\bdo\\b)', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '(if|unless)\b'
   # attribute => 'Keyword'
   # beginRegion => 'def block'
   # context => '#stay'
   # firstNonSpace => 'true'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '(if|unless)\\b', 0, 0, 0, undef, 1, '#stay', 'Keyword')) {
      return 1
   }
   # String => '\;\s*(if|unless)\b'
   # attribute => 'Keyword'
   # beginRegion => 'def block'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\;\\s*(if|unless)\\b', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '\bclass\b'
   # attribute => 'Keyword'
   # beginRegion => 'def block'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bclass\\b', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '\bmodule\b'
   # attribute => 'Keyword'
   # beginRegion => 'def block'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bmodule\\b', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '\bbegin\b'
   # attribute => 'Keyword'
   # beginRegion => 'def block'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bbegin\\b', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '\bfor\b(?!.*\bdo\b)'
   # attribute => 'Keyword'
   # beginRegion => 'def block'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bfor\\b(?!.*\\bdo\\b)', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '\bcase\b'
   # attribute => 'Keyword'
   # beginRegion => 'def block'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bcase\\b', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '\bdo\b'
   # attribute => 'Keyword'
   # beginRegion => 'def block'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bdo\\b', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '\bdef\b'
   # attribute => 'Keyword'
   # beginRegion => 'def block'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bdef\\b', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '\bend\b'
   # attribute => 'Keyword'
   # context => '#stay'
   # endRegion => 'def block'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bend\\b', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '(\b|^\s*)(else|elsif|rescue|ensure)(\s+|$)'
   # attribute => 'Keyword'
   # beginRegion => 'def block'
   # context => '#stay'
   # endRegion => 'def block'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '(\\b|^\\s*)(else|elsif|rescue|ensure)(\\s+|$)', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '...'
   # attribute => 'Operator'
   # context => '#stay'
   # type => 'StringDetect'
   if ($self->testStringDetect($text, '...', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
      return 1
   }
   # attribute => 'Operator'
   # char => '.'
   # char1 => '.'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '.', '.', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
      return 1
   }
   # String => '\.[_a-z][_a-zA-Z0-9]*(\?|\!|\b)'
   # attribute => 'Message'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\.[_a-z][_a-zA-Z0-9]*(\\?|\\!|\\b)', 0, 0, 0, undef, 0, '#stay', 'Message')) {
      return 1
   }
   # String => '\s\?(\\M\-)?(\\C\-)?\\?\S'
   # attribute => 'Dec'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\s\\?(\\\\M\\-)?(\\\\C\\-)?\\\\?\\S', 0, 0, 0, undef, 0, '#stay', 'Dec')) {
      return 1
   }
   # String => 'keywords'
   # attribute => 'Keyword'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'keywords', 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => 'attribute-definitions'
   # attribute => 'Attribute Definition'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'attribute-definitions', 0, undef, 0, '#stay', 'Attribute Definition')) {
      return 1
   }
   # String => 'access-control'
   # attribute => 'Access Control'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'access-control', 0, undef, 0, '#stay', 'Access Control')) {
      return 1
   }
   # String => 'definitions'
   # attribute => 'Definition'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'definitions', 0, undef, 0, '#stay', 'Definition')) {
      return 1
   }
   # String => 'pseudo-variables'
   # attribute => 'Pseudo variable'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'pseudo-variables', 0, undef, 0, '#stay', 'Pseudo variable')) {
      return 1
   }
   # String => 'default-globals'
   # attribute => 'Default globals'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'default-globals', 0, undef, 0, '#stay', 'Default globals')) {
      return 1
   }
   # String => 'kernel-methods'
   # attribute => 'Kernel methods'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'kernel-methods', 0, undef, 0, '#stay', 'Kernel methods')) {
      return 1
   }
   # String => '\$[a-zA-Z_0-9]+'
   # attribute => 'Global Variable'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\$[a-zA-Z_0-9]+', 0, 0, 0, undef, 0, '#stay', 'Global Variable')) {
      return 1
   }
   # String => '\$\-[a-zA-z_]\b'
   # attribute => 'Global Variable'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\$\\-[a-zA-z_]\\b', 0, 0, 0, undef, 0, '#stay', 'Global Variable')) {
      return 1
   }
   # String => '\$[\d_*`\!:?'/\\\-\&]'
   # attribute => 'Default globals'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\$[\\d_*`\\!:?\'/\\\\\\-\\&]', 0, 0, 0, undef, 0, '#stay', 'Default globals')) {
      return 1
   }
   # String => '\b[_A-Z]+[A-Z_0-9]+\b'
   # attribute => 'Global Constant'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b[_A-Z]+[A-Z_0-9]+\\b', 0, 0, 0, undef, 0, '#stay', 'Global Constant')) {
      return 1
   }
   # String => '\b[A-Z]+_*([0-9]|[a-z])[_a-zA-Z0-9]*\b'
   # attribute => 'Constant'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b[A-Z]+_*([0-9]|[a-z])[_a-zA-Z0-9]*\\b', 0, 0, 0, undef, 0, '#stay', 'Constant')) {
      return 1
   }
   # String => '\b\-?0[xX][_0-9a-fA-F]+'
   # attribute => 'Hex'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b\\-?0[xX][_0-9a-fA-F]+', 0, 0, 0, undef, 0, '#stay', 'Hex')) {
      return 1
   }
   # String => '\b\-?0[bB][_01]+'
   # attribute => 'Bin'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b\\-?0[bB][_01]+', 0, 0, 0, undef, 0, '#stay', 'Bin')) {
      return 1
   }
   # String => '\b\-?0[1-7][_0-7]*'
   # attribute => 'Octal'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b\\-?0[1-7][_0-7]*', 0, 0, 0, undef, 0, '#stay', 'Octal')) {
      return 1
   }
   # String => '\b\-?[0-9][0-9_]*\.[0-9][0-9_]*([eE]\-?[1-9][0-9]*(\.[0-9]*)?)?'
   # attribute => 'Float'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b\\-?[0-9][0-9_]*\\.[0-9][0-9_]*([eE]\\-?[1-9][0-9]*(\\.[0-9]*)?)?', 0, 0, 0, undef, 0, '#stay', 'Float')) {
      return 1
   }
   # String => '\b\-?[1-9][0-9_]*\b'
   # attribute => 'Dec'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b\\-?[1-9][0-9_]*\\b', 0, 0, 0, undef, 0, '#stay', 'Dec')) {
      return 1
   }
   # attribute => 'Dec'
   # context => '#stay'
   # type => 'Int'
   if ($self->testInt($text, 0, undef, 0, '#stay', 'Dec')) {
      return 1
   }
   # attribute => 'Char'
   # context => '#stay'
   # type => 'HlCChar'
   if ($self->testHlCChar($text, 0, undef, 0, '#stay', 'Char')) {
      return 1
   }
   # String => '=begin'
   # attribute => 'Blockcomment'
   # beginRegion => 'comment block'
   # column => '0'
   # context => 'Embedded documentation'
   # type => 'StringDetect'
   if ($self->testStringDetect($text, '=begin', 0, 0, 0, 0, 0, 'Embedded documentation', 'Blockcomment')) {
      return 1
   }
   # String => '\s*<<-(?=\w+|["'])'
   # attribute => 'Operator'
   # beginRegion => 'HereDocument'
   # context => 'find_indented_heredoc'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\s*<<-(?=\\w+|["\'])', 0, 0, 0, undef, 0, 'find_indented_heredoc', 'Operator')) {
      return 1
   }
   # String => '\s*<<(?=\w+|["'])'
   # attribute => 'Operator'
   # beginRegion => 'HereDocument'
   # context => 'find_heredoc'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\s*<<(?=\\w+|["\'])', 0, 0, 0, undef, 0, 'find_heredoc', 'Operator')) {
      return 1
   }
   # attribute => 'Operator'
   # char => '.'
   # context => '#stay'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '.', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
      return 1
   }
   # attribute => 'Operator'
   # char => '&'
   # char1 => '&'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '&', '&', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
      return 1
   }
   # attribute => 'Operator'
   # char => '|'
   # char1 => '|'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '|', '|', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
      return 1
   }
   # String => '\s[\?\:\%/]\s'
   # attribute => 'Operator'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\s[\\?\\:\\%/]\\s', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
      return 1
   }
   # String => '[|&<>\^\+*~\-=]+'
   # attribute => 'Operator'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '[|&<>\\^\\+*~\\-=]+', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
      return 1
   }
   # String => '\s!'
   # attribute => 'Operator'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\s!', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
      return 1
   }
   # String => '/=\s'
   # attribute => 'Operator'
   # context => '#stay'
   # insensitive => '0'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '/=\\s', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
      return 1
   }
   # String => '%='
   # attribute => 'Operator'
   # context => '#stay'
   # insensitive => '0'
   # type => 'StringDetect'
   if ($self->testStringDetect($text, '%=', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
      return 1
   }
   # attribute => 'Operator'
   # char => ':'
   # char1 => ':'
   # context => 'Member Access'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, ':', ':', 0, 0, 0, undef, 0, 'Member Access', 'Operator')) {
      return 1
   }
   # String => ':[a-zA-Z_][a-zA-Z0-9_]*'
   # attribute => 'Symbol'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, ':[a-zA-Z_][a-zA-Z0-9_]*', 0, 0, 0, undef, 0, '#stay', 'Symbol')) {
      return 1
   }
   # attribute => 'String'
   # char => '"'
   # context => 'Quoted String'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, 'Quoted String', 'String')) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '''
   # context => 'Apostrophed String'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, 'Apostrophed String', 'Raw String')) {
      return 1
   }
   # attribute => 'Command'
   # char => '`'
   # context => 'Command String'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '`', 0, 0, 0, undef, 0, 'Command String', 'Command')) {
      return 1
   }
   # String => '?#'
   # attribute => 'Normal Text'
   # context => '#stay'
   # type => 'StringDetect'
   if ($self->testStringDetect($text, '?#', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
      return 1
   }
   # String => '#\s*BEGIN.*$'
   # attribute => 'Comment'
   # beginRegion => 'marker'
   # column => '0'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#\\s*BEGIN.*$', 0, 0, 0, 0, 0, '#stay', 'Comment')) {
      return 1
   }
   # String => '#\s*END.*$'
   # attribute => 'Comment'
   # column => '0'
   # context => '#stay'
   # endRegion => 'marker'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#\\s*END.*$', 0, 0, 0, 0, 0, '#stay', 'Comment')) {
      return 1
   }
   # String => '#'
   # attribute => 'Comment'
   # context => 'Comment Line'
   # firstNonSpace => 'true'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#', 0, 0, 0, undef, 1, 'Comment Line', 'Comment')) {
      return 1
   }
   # String => '\s#'
   # attribute => 'Comment'
   # context => 'General Comment'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\s#', 0, 0, 0, undef, 0, 'General Comment', 'Comment')) {
      return 1
   }
   # String => '[\[\]]+'
   # attribute => 'Delimiter'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '[\\[\\]]+', 0, 0, 0, undef, 0, '#stay', 'Delimiter')) {
      return 1
   }
   # attribute => 'Delimiter'
   # beginRegion => 'def block'
   # char => '{'
   # context => '#stay'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, '#stay', 'Delimiter')) {
      return 1
   }
   # attribute => 'Delimiter'
   # char => '}'
   # context => '#stay'
   # endRegion => 'def block'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#stay', 'Delimiter')) {
      return 1
   }
   # String => '@[a-zA-Z_0-9]+'
   # attribute => 'Instance Variable'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '@[a-zA-Z_0-9]+', 0, 0, 0, undef, 0, '#stay', 'Instance Variable')) {
      return 1
   }
   # String => '@@[a-zA-Z_0-9]+'
   # attribute => 'Class Variable'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '@@[a-zA-Z_0-9]+', 0, 0, 0, undef, 0, '#stay', 'Class Variable')) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '/'
   # context => 'RegEx 1'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '/', 0, 0, 0, undef, 0, 'RegEx 1', 'Regular Expression')) {
      return 1
   }
   # String => '\s*[%](?=[Qqxw]?[^\s])'
   # attribute => 'GDL input'
   # beginRegion => 'GdlInput'
   # context => 'find_gdl_input'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\s*[%](?=[Qqxw]?[^\\s])', 0, 0, 0, undef, 0, 'find_gdl_input', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parseQuotedString {
   my ($self, $text) = @_;
   # String => '\\'
   # attribute => 'String'
   # context => '#stay'
   # type => 'StringDetect'
   if ($self->testStringDetect($text, '\\\\', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # String => '\\\"'
   # attribute => 'String'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\\\\\"', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # String => '#@{1,2}'
   # attribute => 'Substitution'
   # context => 'Short Subst'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#@{1,2}', 0, 0, 0, undef, 0, 'Short Subst', 'Substitution')) {
      return 1
   }
   # attribute => 'Substitution'
   # char => '#'
   # char1 => '{'
   # context => 'Subst'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '#', '{', 0, 0, 0, undef, 0, 'Subst', 'Substitution')) {
      return 1
   }
   # attribute => 'String'
   # char => '"'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, '#pop', 'String')) {
      return 1
   }
   return 0;
};

sub parseRDocLabel {
   my ($self, $text) = @_;
   return 0;
};

sub parseRegEx1 {
   my ($self, $text) = @_;
   # String => '\\\/'
   # attribute => 'Regular Expression'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\\\\\/', 0, 0, 0, undef, 0, '#stay', 'Regular Expression')) {
      return 1
   }
   # String => '[^\\]$'
   # attribute => 'Regular Expression'
   # context => '#pop'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '[^\\\\]$', 0, 0, 0, undef, 0, '#pop', 'Regular Expression')) {
      return 1
   }
   # String => '#@{1,2}'
   # attribute => 'Substitution'
   # context => 'Short Subst'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#@{1,2}', 0, 0, 0, undef, 0, 'Short Subst', 'Substitution')) {
      return 1
   }
   # attribute => 'Substitution'
   # char => '#'
   # char1 => '{'
   # context => 'Subst'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '#', '{', 0, 0, 0, undef, 0, 'Subst', 'Substitution')) {
      return 1
   }
   # String => '/[uiomxn]*'
   # attribute => 'Regular Expression'
   # context => '#pop'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '/[uiomxn]*', 0, 0, 0, undef, 0, '#pop', 'Regular Expression')) {
      return 1
   }
   return 0;
};

sub parseShortSubst {
   my ($self, $text) = @_;
   # String => '#@{1,2}'
   # attribute => 'Substitution'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#@{1,2}', 0, 0, 0, undef, 0, '#stay', 'Substitution')) {
      return 1
   }
   # String => '\w(?!\w)'
   # attribute => 'Substitution'
   # context => '#pop'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\w(?!\\w)', 0, 0, 0, undef, 0, '#pop', 'Substitution')) {
      return 1
   }
   return 0;
};

sub parseSubst {
   my ($self, $text) = @_;
   # attribute => 'Substitution'
   # char => '}'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop', 'Substitution')) {
      return 1
   }
   # context => 'Normal'
   # type => 'IncludeRules'
   if ($self->includeRules('Normal', $text)) {
      return 1
   }
   return 0;
};

sub parseapostrophed_indented_heredoc {
   my ($self, $text) = @_;
   # String => '%1$'
   # attribute => 'Keyword'
   # context => '#pop#pop'
   # dynamic => 'true'
   # endRegion => 'HereDocument'
   # firstNonSpace => 'true'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '%1$', 0, 1, 0, undef, 1, '#pop#pop', 'Keyword')) {
      return 1
   }
   return 0;
};

sub parseapostrophed_normal_heredoc {
   my ($self, $text) = @_;
   # String => '%1$'
   # attribute => 'Keyword'
   # column => '0'
   # context => '#pop#pop'
   # dynamic => 'true'
   # endRegion => 'HereDocument'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '%1$', 0, 1, 0, 0, 0, '#pop#pop', 'Keyword')) {
      return 1
   }
   return 0;
};

sub parseapostrophed_rules {
   my ($self, $text) = @_;
   # attribute => 'Raw String'
   # char => '\'
   # char1 => '\'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '\\', 0, 0, 0, undef, 0, '#stay', 'Raw String')) {
      return 1
   }
   return 0;
};

sub parsedq_string_rules {
   my ($self, $text) = @_;
   # attribute => 'String'
   # char => '\'
   # char1 => '\'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '\\', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # String => '#@{1,2}'
   # attribute => 'Substitution'
   # context => 'Short Subst'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#@{1,2}', 0, 0, 0, undef, 0, 'Short Subst', 'Substitution')) {
      return 1
   }
   # attribute => 'Substitution'
   # char => '#'
   # char1 => '{'
   # context => 'Subst'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '#', '{', 0, 0, 0, undef, 0, 'Subst', 'Substitution')) {
      return 1
   }
   return 0;
};

sub parsefind_gdl_input {
   my ($self, $text) = @_;
   # String => 'w\('
   # attribute => 'GDL input'
   # context => 'gdl_token_array_1'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'w\\(', 0, 0, 0, undef, 0, 'gdl_token_array_1', 'GDL input')) {
      return 1
   }
   # String => 'w\{'
   # attribute => 'GDL input'
   # context => 'gdl_token_array_2'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'w\\{', 0, 0, 0, undef, 0, 'gdl_token_array_2', 'GDL input')) {
      return 1
   }
   # String => 'w\['
   # attribute => 'GDL input'
   # context => 'gdl_token_array_3'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'w\\[', 0, 0, 0, undef, 0, 'gdl_token_array_3', 'GDL input')) {
      return 1
   }
   # String => 'w<'
   # attribute => 'GDL input'
   # context => 'gdl_token_array_4'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'w<', 0, 0, 0, undef, 0, 'gdl_token_array_4', 'GDL input')) {
      return 1
   }
   # String => 'w([^\s\w])'
   # attribute => 'GDL input'
   # context => 'gdl_token_array_5'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'w([^\\s\\w])', 0, 0, 0, undef, 0, 'gdl_token_array_5', 'GDL input')) {
      return 1
   }
   # String => 'q\('
   # attribute => 'GDL input'
   # context => 'gdl_apostrophed_1'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'q\\(', 0, 0, 0, undef, 0, 'gdl_apostrophed_1', 'GDL input')) {
      return 1
   }
   # String => 'q\{'
   # attribute => 'GDL input'
   # context => 'gdl_apostrophed_2'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'q\\{', 0, 0, 0, undef, 0, 'gdl_apostrophed_2', 'GDL input')) {
      return 1
   }
   # String => 'q\['
   # attribute => 'GDL input'
   # context => 'gdl_apostrophed_3'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'q\\[', 0, 0, 0, undef, 0, 'gdl_apostrophed_3', 'GDL input')) {
      return 1
   }
   # String => 'q<'
   # attribute => 'GDL input'
   # context => 'gdl_apostrophed_4'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'q<', 0, 0, 0, undef, 0, 'gdl_apostrophed_4', 'GDL input')) {
      return 1
   }
   # String => 'q([^\s\w])'
   # attribute => 'GDL input'
   # context => 'gdl_apostrophed_5'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'q([^\\s\\w])', 0, 0, 0, undef, 0, 'gdl_apostrophed_5', 'GDL input')) {
      return 1
   }
   # String => 'x\('
   # attribute => 'GDL input'
   # context => 'gdl_shell_command_1'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'x\\(', 0, 0, 0, undef, 0, 'gdl_shell_command_1', 'GDL input')) {
      return 1
   }
   # String => 'x\{'
   # attribute => 'GDL input'
   # context => 'gdl_shell_command_2'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'x\\{', 0, 0, 0, undef, 0, 'gdl_shell_command_2', 'GDL input')) {
      return 1
   }
   # String => 'x\['
   # attribute => 'GDL input'
   # context => 'gdl_shell_command_3'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'x\\[', 0, 0, 0, undef, 0, 'gdl_shell_command_3', 'GDL input')) {
      return 1
   }
   # String => 'x<'
   # attribute => 'GDL input'
   # context => 'gdl_shell_command_4'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'x<', 0, 0, 0, undef, 0, 'gdl_shell_command_4', 'GDL input')) {
      return 1
   }
   # String => 'x([^\s\w])'
   # attribute => 'GDL input'
   # context => 'gdl_shell_command_5'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'x([^\\s\\w])', 0, 0, 0, undef, 0, 'gdl_shell_command_5', 'GDL input')) {
      return 1
   }
   # String => 'r\('
   # attribute => 'GDL input'
   # context => 'gdl_regexpr_1'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'r\\(', 0, 0, 0, undef, 0, 'gdl_regexpr_1', 'GDL input')) {
      return 1
   }
   # String => 'r\{'
   # attribute => 'GDL input'
   # context => 'gdl_regexpr_2'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'r\\{', 0, 0, 0, undef, 0, 'gdl_regexpr_2', 'GDL input')) {
      return 1
   }
   # String => 'r\['
   # attribute => 'GDL input'
   # context => 'gdl_regexpr_3'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'r\\[', 0, 0, 0, undef, 0, 'gdl_regexpr_3', 'GDL input')) {
      return 1
   }
   # String => 'r<'
   # attribute => 'GDL input'
   # context => 'gdl_regexpr_4'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'r<', 0, 0, 0, undef, 0, 'gdl_regexpr_4', 'GDL input')) {
      return 1
   }
   # String => 'r([^\s\w])'
   # attribute => 'GDL input'
   # context => 'gdl_regexpr_5'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'r([^\\s\\w])', 0, 0, 0, undef, 0, 'gdl_regexpr_5', 'GDL input')) {
      return 1
   }
   # String => 'Q?\('
   # attribute => 'GDL input'
   # context => 'gdl_dq_string_1'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'Q?\\(', 0, 0, 0, undef, 0, 'gdl_dq_string_1', 'GDL input')) {
      return 1
   }
   # String => 'Q?\{'
   # attribute => 'GDL input'
   # context => 'gdl_dq_string_2'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'Q?\\{', 0, 0, 0, undef, 0, 'gdl_dq_string_2', 'GDL input')) {
      return 1
   }
   # String => 'Q?\['
   # attribute => 'GDL input'
   # context => 'gdl_dq_string_3'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'Q?\\[', 0, 0, 0, undef, 0, 'gdl_dq_string_3', 'GDL input')) {
      return 1
   }
   # String => 'Q?<'
   # attribute => 'GDL input'
   # context => 'gdl_dq_string_4'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'Q?<', 0, 0, 0, undef, 0, 'gdl_dq_string_4', 'GDL input')) {
      return 1
   }
   # String => 'Q?([^\s\w])'
   # attribute => 'GDL input'
   # context => 'gdl_dq_string_5'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, 'Q?([^\\s\\w])', 0, 0, 0, undef, 0, 'gdl_dq_string_5', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsefind_heredoc {
   my ($self, $text) = @_;
   # String => ''(\w+)''
   # attribute => 'Keyword'
   # context => 'apostrophed_normal_heredoc'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\'(\\w+)\'', 0, 0, 0, undef, 0, 'apostrophed_normal_heredoc', 'Keyword')) {
      return 1
   }
   # String => '"?(\w+)"?'
   # attribute => 'Keyword'
   # context => 'normal_heredoc'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '"?(\\w+)"?', 0, 0, 0, undef, 0, 'normal_heredoc', 'Keyword')) {
      return 1
   }
   return 0;
};

sub parsefind_indented_heredoc {
   my ($self, $text) = @_;
   # String => ''(\w+)''
   # attribute => 'Keyword'
   # context => 'apostrophed_indented_heredoc'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\'(\\w+)\'', 0, 0, 0, undef, 0, 'apostrophed_indented_heredoc', 'Keyword')) {
      return 1
   }
   # String => '"?(\w+)"?'
   # attribute => 'Keyword'
   # context => 'indented_heredoc'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '"?(\\w+)"?', 0, 0, 0, undef, 0, 'indented_heredoc', 'Keyword')) {
      return 1
   }
   return 0;
};

sub parsegdl_apostrophed_1 {
   my ($self, $text) = @_;
   # context => 'apostrophed_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('apostrophed_rules', $text)) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '\'
   # char1 => ')'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', ')', 0, 0, 0, undef, 0, '#stay', 'Raw String')) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '('
   # context => 'gdl_apostrophed_1_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'gdl_apostrophed_1_nested', 'Raw String')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => ')'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_apostrophed_1_nested {
   my ($self, $text) = @_;
   # context => 'apostrophed_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('apostrophed_rules', $text)) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '('
   # context => 'gdl_apostrophed_1_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'gdl_apostrophed_1_nested', 'Raw String')) {
      return 1
   }
   # attribute => 'Raw String'
   # char => ')'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop', 'Raw String')) {
      return 1
   }
   return 0;
};

sub parsegdl_apostrophed_2 {
   my ($self, $text) = @_;
   # context => 'apostrophed_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('apostrophed_rules', $text)) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '\'
   # char1 => '}'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '}', 0, 0, 0, undef, 0, '#stay', 'Raw String')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => '}'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '{'
   # context => 'gdl_apostrophed_2_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'gdl_apostrophed_2_nested', 'Raw String')) {
      return 1
   }
   return 0;
};

sub parsegdl_apostrophed_2_nested {
   my ($self, $text) = @_;
   # context => 'apostrophed_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('apostrophed_rules', $text)) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '{'
   # context => 'gdl_apostrophed_2_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'gdl_apostrophed_2_nested', 'Raw String')) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '}'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop', 'Raw String')) {
      return 1
   }
   return 0;
};

sub parsegdl_apostrophed_3 {
   my ($self, $text) = @_;
   # context => 'apostrophed_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('apostrophed_rules', $text)) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '\'
   # char1 => ']'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', ']', 0, 0, 0, undef, 0, '#stay', 'Raw String')) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '['
   # context => 'gdl_apostrophed_3_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'gdl_apostrophed_3_nested', 'Raw String')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => ']'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_apostrophed_3_nested {
   my ($self, $text) = @_;
   # context => 'apostrophed_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('apostrophed_rules', $text)) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '['
   # context => 'gdl_apostrophed_3_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'gdl_apostrophed_3_nested', 'Raw String')) {
      return 1
   }
   # attribute => 'Raw String'
   # char => ']'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, '#pop', 'Raw String')) {
      return 1
   }
   return 0;
};

sub parsegdl_apostrophed_4 {
   my ($self, $text) = @_;
   # context => 'apostrophed_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('apostrophed_rules', $text)) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '\'
   # char1 => '>'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '>', 0, 0, 0, undef, 0, '#stay', 'Raw String')) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '<'
   # context => 'gdl_apostrophed_4_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '<', 0, 0, 0, undef, 0, 'gdl_apostrophed_4_nested', 'Raw String')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => '>'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_apostrophed_4_nested {
   my ($self, $text) = @_;
   # context => 'apostrophed_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('apostrophed_rules', $text)) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '<'
   # context => 'gdl_apostrophed_4_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '<', 0, 0, 0, undef, 0, 'gdl_apostrophed_4_nested', 'Raw String')) {
      return 1
   }
   # attribute => 'Raw String'
   # char => '>'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop', 'Raw String')) {
      return 1
   }
   return 0;
};

sub parsegdl_apostrophed_5 {
   my ($self, $text) = @_;
   # context => 'apostrophed_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('apostrophed_rules', $text)) {
      return 1
   }
   # String => '\\%1'
   # attribute => 'Raw String'
   # context => '#stay'
   # dynamic => 'true'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\\\%1', 0, 1, 0, undef, 0, '#stay', 'Raw String')) {
      return 1
   }
   # String => '\s*%1'
   # attribute => 'GDL input'
   # context => '#pop#pop'
   # dynamic => 'true'
   # endRegion => 'GdlInput'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\s*%1', 0, 1, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_dq_string_1 {
   my ($self, $text) = @_;
   # context => 'dq_string_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('dq_string_rules', $text)) {
      return 1
   }
   # attribute => 'String'
   # char => '\'
   # char1 => ')'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', ')', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => '('
   # context => 'gdl_dq_string_1_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'gdl_dq_string_1_nested', 'String')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => ')'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_dq_string_1_nested {
   my ($self, $text) = @_;
   # context => 'dq_string_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('dq_string_rules', $text)) {
      return 1
   }
   # attribute => 'String'
   # char => '('
   # context => 'gdl_dq_string_1_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'gdl_dq_string_1_nested', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => ')'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop', 'String')) {
      return 1
   }
   return 0;
};

sub parsegdl_dq_string_2 {
   my ($self, $text) = @_;
   # context => 'dq_string_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('dq_string_rules', $text)) {
      return 1
   }
   # attribute => 'String'
   # char => '\'
   # char1 => '}'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '}', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => '}'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   # attribute => 'String'
   # char => '{'
   # context => 'gdl_dq_string_2_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'gdl_dq_string_2_nested', 'String')) {
      return 1
   }
   return 0;
};

sub parsegdl_dq_string_2_nested {
   my ($self, $text) = @_;
   # attribute => 'String'
   # char => '{'
   # context => 'gdl_dq_string_2_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'gdl_dq_string_2_nested', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => '}'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop', 'String')) {
      return 1
   }
   # context => 'dq_string_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('dq_string_rules', $text)) {
      return 1
   }
   return 0;
};

sub parsegdl_dq_string_3 {
   my ($self, $text) = @_;
   # context => 'dq_string_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('dq_string_rules', $text)) {
      return 1
   }
   # attribute => 'String'
   # char => '\'
   # char1 => ']'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', ']', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => '['
   # context => 'gdl_dq_string_3_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'gdl_dq_string_3_nested', 'String')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => ']'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_dq_string_3_nested {
   my ($self, $text) = @_;
   # attribute => 'String'
   # char => '['
   # context => 'gdl_dq_string_3_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'gdl_dq_string_3_nested', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => ']'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, '#pop', 'String')) {
      return 1
   }
   # context => 'dq_string_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('dq_string_rules', $text)) {
      return 1
   }
   return 0;
};

sub parsegdl_dq_string_4 {
   my ($self, $text) = @_;
   # context => 'dq_string_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('dq_string_rules', $text)) {
      return 1
   }
   # attribute => 'String'
   # char => '\'
   # char1 => '>'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '>', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => '<'
   # context => 'gdl_dq_string_4_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '<', 0, 0, 0, undef, 0, 'gdl_dq_string_4_nested', 'String')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => '>'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_dq_string_4_nested {
   my ($self, $text) = @_;
   # attribute => 'String'
   # char => '<'
   # context => 'gdl_dq_string_4_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '<', 0, 0, 0, undef, 0, 'gdl_dq_string_4_nested', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => '>'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop', 'String')) {
      return 1
   }
   # context => 'dq_string_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('dq_string_rules', $text)) {
      return 1
   }
   return 0;
};

sub parsegdl_dq_string_5 {
   my ($self, $text) = @_;
   # context => 'dq_string_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('dq_string_rules', $text)) {
      return 1
   }
   # String => '\\%1'
   # attribute => 'String'
   # context => '#stay'
   # dynamic => 'true'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\\\%1', 0, 1, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # String => '\s*%1'
   # attribute => 'GDL input'
   # context => '#pop#pop'
   # dynamic => 'true'
   # endRegion => 'GdlInput'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\s*%1', 0, 1, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_regexpr_1 {
   my ($self, $text) = @_;
   # context => 'regexpr_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('regexpr_rules', $text)) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '\'
   # char1 => ')'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', ')', 0, 0, 0, undef, 0, '#stay', 'Regular Expression')) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '('
   # context => 'gdl_regexpr_1_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'gdl_regexpr_1_nested', 'Regular Expression')) {
      return 1
   }
   # String => '\)[uiomxn]*'
   # attribute => 'GDL input'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\)[uiomxn]*', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_regexpr_1_nested {
   my ($self, $text) = @_;
   # context => 'regexpr_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('regexpr_rules', $text)) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '('
   # context => 'gdl_regexpr_1_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'gdl_regexpr_1_nested', 'Regular Expression')) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => ')'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop', 'Regular Expression')) {
      return 1
   }
   return 0;
};

sub parsegdl_regexpr_2 {
   my ($self, $text) = @_;
   # context => 'regexpr_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('regexpr_rules', $text)) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '\'
   # char1 => '}'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '}', 0, 0, 0, undef, 0, '#stay', 'Regular Expression')) {
      return 1
   }
   # String => '\}[uiomxn]*'
   # attribute => 'GDL input'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\}[uiomxn]*', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '{'
   # context => 'gdl_regexpr_2_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'gdl_regexpr_2_nested', 'Regular Expression')) {
      return 1
   }
   return 0;
};

sub parsegdl_regexpr_2_nested {
   my ($self, $text) = @_;
   # context => 'regexpr_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('regexpr_rules', $text)) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '{'
   # context => 'gdl_regexpr_2_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'gdl_regexpr_2_nested', 'Regular Expression')) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '}'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop', 'Regular Expression')) {
      return 1
   }
   return 0;
};

sub parsegdl_regexpr_3 {
   my ($self, $text) = @_;
   # context => 'regexpr_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('regexpr_rules', $text)) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '\'
   # char1 => ']'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', ']', 0, 0, 0, undef, 0, '#stay', 'Regular Expression')) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '['
   # context => 'gdl_regexpr_3_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'gdl_regexpr_3_nested', 'Regular Expression')) {
      return 1
   }
   # String => '\][uiomxn]*'
   # attribute => 'GDL input'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\][uiomxn]*', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_regexpr_3_nested {
   my ($self, $text) = @_;
   # context => 'regexpr_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('regexpr_rules', $text)) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '['
   # context => 'gdl_regexpr_3_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'gdl_regexpr_3_nested', 'Regular Expression')) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => ']'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, '#pop', 'Regular Expression')) {
      return 1
   }
   return 0;
};

sub parsegdl_regexpr_4 {
   my ($self, $text) = @_;
   # context => 'regexpr_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('regexpr_rules', $text)) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '\'
   # char1 => '>'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '>', 0, 0, 0, undef, 0, '#stay', 'Regular Expression')) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '<'
   # context => 'gdl_regexpr_4_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '<', 0, 0, 0, undef, 0, 'gdl_regexpr_4_nested', 'Regular Expression')) {
      return 1
   }
   # String => '>[uiomxn]*'
   # attribute => 'GDL input'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '>[uiomxn]*', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_regexpr_4_nested {
   my ($self, $text) = @_;
   # context => 'regexpr_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('regexpr_rules', $text)) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '<'
   # context => 'gdl_regexpr_4_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '<', 0, 0, 0, undef, 0, 'gdl_regexpr_4_nested', 'Regular Expression')) {
      return 1
   }
   # attribute => 'Regular Expression'
   # char => '>'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop', 'Regular Expression')) {
      return 1
   }
   return 0;
};

sub parsegdl_regexpr_5 {
   my ($self, $text) = @_;
   # context => 'regexpr_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('regexpr_rules', $text)) {
      return 1
   }
   # String => '\\%1'
   # attribute => 'Regular Expression'
   # context => '#stay'
   # dynamic => 'true'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\\\%1', 0, 1, 0, undef, 0, '#stay', 'Regular Expression')) {
      return 1
   }
   # String => '\s*%1[uiomxn]*'
   # attribute => 'GDL input'
   # context => '#pop#pop'
   # dynamic => 'true'
   # endRegion => 'GdlInput'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\s*%1[uiomxn]*', 0, 1, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_shell_command_1 {
   my ($self, $text) = @_;
   # context => 'shell_command_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('shell_command_rules', $text)) {
      return 1
   }
   # attribute => 'Command'
   # char => '\'
   # char1 => ')'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', ')', 0, 0, 0, undef, 0, '#stay', 'Command')) {
      return 1
   }
   # attribute => 'Command'
   # char => '('
   # context => 'gdl_shell_command_1_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'gdl_shell_command_1_nested', 'Command')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => ')'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_shell_command_1_nested {
   my ($self, $text) = @_;
   # context => 'shell_command_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('shell_command_rules', $text)) {
      return 1
   }
   # attribute => 'Command'
   # char => '('
   # context => 'gdl_shell_command_1_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'gdl_shell_command_1_nested', 'Command')) {
      return 1
   }
   # attribute => 'Command'
   # char => ')'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop', 'Command')) {
      return 1
   }
   return 0;
};

sub parsegdl_shell_command_2 {
   my ($self, $text) = @_;
   # context => 'shell_command_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('shell_command_rules', $text)) {
      return 1
   }
   # attribute => 'Command'
   # char => '\'
   # char1 => '}'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '}', 0, 0, 0, undef, 0, '#stay', 'Command')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => '}'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   # attribute => 'Command'
   # char => '{'
   # context => 'gdl_shell_command_2_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'gdl_shell_command_2_nested', 'Command')) {
      return 1
   }
   return 0;
};

sub parsegdl_shell_command_2_nested {
   my ($self, $text) = @_;
   # context => 'shell_command_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('shell_command_rules', $text)) {
      return 1
   }
   # attribute => 'Command'
   # char => '{'
   # context => 'gdl_shell_command_2_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'gdl_shell_command_2_nested', 'Command')) {
      return 1
   }
   # attribute => 'Command'
   # char => '}'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop', 'Command')) {
      return 1
   }
   return 0;
};

sub parsegdl_shell_command_3 {
   my ($self, $text) = @_;
   # context => 'shell_command_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('shell_command_rules', $text)) {
      return 1
   }
   # attribute => 'Command'
   # char => '\'
   # char1 => ']'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', ']', 0, 0, 0, undef, 0, '#stay', 'Command')) {
      return 1
   }
   # attribute => 'Command'
   # char => '['
   # context => 'gdl_shell_command_3_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'gdl_shell_command_3_nested', 'Command')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => ']'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_shell_command_3_nested {
   my ($self, $text) = @_;
   # context => 'shell_command_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('shell_command_rules', $text)) {
      return 1
   }
   # attribute => 'Command'
   # char => '['
   # context => 'gdl_shell_command_3_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'gdl_shell_command_3_nested', 'Command')) {
      return 1
   }
   # attribute => 'Command'
   # char => ']'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, '#pop', 'Command')) {
      return 1
   }
   return 0;
};

sub parsegdl_shell_command_4 {
   my ($self, $text) = @_;
   # context => 'shell_command_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('shell_command_rules', $text)) {
      return 1
   }
   # attribute => 'Command'
   # char => '\'
   # char1 => '>'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '>', 0, 0, 0, undef, 0, '#stay', 'Command')) {
      return 1
   }
   # attribute => 'Command'
   # char => '<'
   # context => 'gdl_shell_command_4_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '<', 0, 0, 0, undef, 0, 'gdl_shell_command_4_nested', 'Command')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => '>'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_shell_command_4_nested {
   my ($self, $text) = @_;
   # context => 'shell_command_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('shell_command_rules', $text)) {
      return 1
   }
   # attribute => 'Command'
   # char => '<'
   # context => 'gdl_shell_command_4_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '<', 0, 0, 0, undef, 0, 'gdl_shell_command_4_nested', 'Command')) {
      return 1
   }
   # attribute => 'Command'
   # char => '>'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop', 'Command')) {
      return 1
   }
   return 0;
};

sub parsegdl_shell_command_5 {
   my ($self, $text) = @_;
   # context => 'shell_command_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('shell_command_rules', $text)) {
      return 1
   }
   # String => '\\%1'
   # attribute => 'Command'
   # context => '#stay'
   # dynamic => 'true'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\\\%1', 0, 1, 0, undef, 0, '#stay', 'Command')) {
      return 1
   }
   # String => '\s*%1'
   # attribute => 'GDL input'
   # context => '#pop#pop'
   # dynamic => 'true'
   # endRegion => 'GdlInput'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\s*%1', 0, 1, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_token_array_1 {
   my ($self, $text) = @_;
   # context => 'token_array_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('token_array_rules', $text)) {
      return 1
   }
   # attribute => 'String'
   # char => '\'
   # char1 => ')'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', ')', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => '('
   # context => 'gdl_token_array_1_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'gdl_token_array_1_nested', 'String')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => ')'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_token_array_1_nested {
   my ($self, $text) = @_;
   # context => 'token_array_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('token_array_rules', $text)) {
      return 1
   }
   # attribute => 'String'
   # char => '('
   # context => 'gdl_token_array_1_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'gdl_token_array_1_nested', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => ')'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop', 'String')) {
      return 1
   }
   return 0;
};

sub parsegdl_token_array_2 {
   my ($self, $text) = @_;
   # context => 'token_array_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('token_array_rules', $text)) {
      return 1
   }
   # attribute => 'String'
   # char => '\'
   # char1 => '}'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '}', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => '}'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   # attribute => 'String'
   # char => '{'
   # context => 'gdl_token_array_2_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'gdl_token_array_2_nested', 'String')) {
      return 1
   }
   return 0;
};

sub parsegdl_token_array_2_nested {
   my ($self, $text) = @_;
   # context => 'token_array_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('token_array_rules', $text)) {
      return 1
   }
   # attribute => 'String'
   # char => '{'
   # context => 'gdl_token_array_2_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'gdl_token_array_2_nested', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => '}'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop', 'String')) {
      return 1
   }
   return 0;
};

sub parsegdl_token_array_3 {
   my ($self, $text) = @_;
   # context => 'token_array_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('token_array_rules', $text)) {
      return 1
   }
   # attribute => 'String'
   # char => '\'
   # char1 => ']'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', ']', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => '['
   # context => 'gdl_token_array_3_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'gdl_token_array_3_nested', 'String')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => ']'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_token_array_3_nested {
   my ($self, $text) = @_;
   # context => 'token_array_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('token_array_rules', $text)) {
      return 1
   }
   # attribute => 'String'
   # char => '['
   # context => 'gdl_token_array_3_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'gdl_token_array_3_nested', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => ']'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, '#pop', 'String')) {
      return 1
   }
   return 0;
};

sub parsegdl_token_array_4 {
   my ($self, $text) = @_;
   # context => 'token_array_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('token_array_rules', $text)) {
      return 1
   }
   # attribute => 'String'
   # char => '\'
   # char1 => '>'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '>', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => '<'
   # context => 'gdl_token_array_4_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '<', 0, 0, 0, undef, 0, 'gdl_token_array_4_nested', 'String')) {
      return 1
   }
   # attribute => 'GDL input'
   # char => '>'
   # context => '#pop#pop'
   # endRegion => 'GdlInput'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parsegdl_token_array_4_nested {
   my ($self, $text) = @_;
   # context => 'token_array_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('token_array_rules', $text)) {
      return 1
   }
   # attribute => 'String'
   # char => '<'
   # context => 'gdl_token_array_4_nested'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '<', 0, 0, 0, undef, 0, 'gdl_token_array_4_nested', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => '>'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop', 'String')) {
      return 1
   }
   return 0;
};

sub parsegdl_token_array_5 {
   my ($self, $text) = @_;
   # context => 'token_array_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('token_array_rules', $text)) {
      return 1
   }
   # String => '\\%1'
   # attribute => 'String'
   # context => '#stay'
   # dynamic => 'true'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\\\%1', 0, 1, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   # String => '\s*%1'
   # attribute => 'GDL input'
   # context => '#pop#pop'
   # dynamic => 'true'
   # endRegion => 'GdlInput'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\s*%1', 0, 1, 0, undef, 0, '#pop#pop', 'GDL input')) {
      return 1
   }
   return 0;
};

sub parseheredoc_rules {
   my ($self, $text) = @_;
   # String => '#@{1,2}'
   # attribute => 'Substitution'
   # context => 'Short Subst'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#@{1,2}', 0, 0, 0, undef, 0, 'Short Subst', 'Substitution')) {
      return 1
   }
   # attribute => 'Substitution'
   # char => '#'
   # char1 => '{'
   # context => 'Subst'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '#', '{', 0, 0, 0, undef, 0, 'Subst', 'Substitution')) {
      return 1
   }
   return 0;
};

sub parseindented_heredoc {
   my ($self, $text) = @_;
   # String => '%1$'
   # attribute => 'Keyword'
   # context => '#pop#pop'
   # dynamic => 'true'
   # endRegion => 'HereDocument'
   # firstNonSpace => 'true'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '%1$', 0, 1, 0, undef, 1, '#pop#pop', 'Keyword')) {
      return 1
   }
   # context => 'heredoc_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('heredoc_rules', $text)) {
      return 1
   }
   return 0;
};

sub parsenormal_heredoc {
   my ($self, $text) = @_;
   # String => '%1$'
   # attribute => 'Keyword'
   # column => '0'
   # context => '#pop#pop'
   # dynamic => 'true'
   # endRegion => 'HereDocument'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '%1$', 0, 1, 0, 0, 0, '#pop#pop', 'Keyword')) {
      return 1
   }
   # context => 'heredoc_rules'
   # type => 'IncludeRules'
   if ($self->includeRules('heredoc_rules', $text)) {
      return 1
   }
   return 0;
};

sub parseregexpr_rules {
   my ($self, $text) = @_;
   # attribute => 'Regular Expression'
   # char => '\'
   # char1 => '\'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '\\', 0, 0, 0, undef, 0, '#stay', 'Regular Expression')) {
      return 1
   }
   # String => '#@{1,2}'
   # attribute => 'Substitution'
   # context => 'Short Subst'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#@{1,2}', 0, 0, 0, undef, 0, 'Short Subst', 'Substitution')) {
      return 1
   }
   # attribute => 'Substitution'
   # char => '#'
   # char1 => '{'
   # context => 'Subst'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '#', '{', 0, 0, 0, undef, 0, 'Subst', 'Substitution')) {
      return 1
   }
   return 0;
};

sub parseshell_command_rules {
   my ($self, $text) = @_;
   # attribute => 'Command'
   # char => '\'
   # char1 => '\'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '\\', 0, 0, 0, undef, 0, '#stay', 'Command')) {
      return 1
   }
   # String => '#@{1,2}'
   # attribute => 'Substitution'
   # context => 'Short Subst'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#@{1,2}', 0, 0, 0, undef, 0, 'Short Subst', 'Substitution')) {
      return 1
   }
   # attribute => 'Substitution'
   # char => '#'
   # char1 => '{'
   # context => 'Subst'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '#', '{', 0, 0, 0, undef, 0, 'Subst', 'Substitution')) {
      return 1
   }
   return 0;
};

sub parsetoken_array_rules {
   my ($self, $text) = @_;
   # String => '\\'
   # attribute => 'String'
   # context => '#stay'
   # type => 'StringDetect'
   if ($self->testStringDetect($text, '\\\\', 0, 0, 0, undef, 0, '#stay', 'String')) {
      return 1
   }
   return 0;
};


1;

__END__

=head1 NAME

Syntax::Highlight::Engine::Kate::Ruby - a Plugin for Ruby syntax highlighting

=head1 SYNOPSIS

 require Syntax::Highlight::Engine::Kate::Ruby;
 my $sh = new Syntax::Highlight::Engine::Kate::Ruby([
 ]);

=head1 DESCRIPTION

Syntax::Highlight::Engine::Kate::Ruby is a  plugin module that provides syntax highlighting
for Ruby to the Syntax::Haghlight::Engine::Kate highlighting engine.

This code is generated from the syntax definition files used
by the Kate project.
It works quite fine, but can use refinement and optimization.

It inherits Syntax::Higlight::Engine::Kate::Template. See also there.

=head1 AUTHOR

Hans Jeuken (haje <at> toneel <dot> demon <dot> nl)

=head1 BUGS

Unknown. If you find any, please contact the author