# 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 'fortran.xml' file of the syntax highlight
# engine of the kate text editor (http://www.kate-editor.org

#kate xml version 1.11
#kate version 2.4
#kate author Franchin Matteo (fnch@libero.it)
#generated: Sun Feb  3 22:02:05 2008, localtime

package Syntax::Highlight::Engine::Kate::Fortran;

our $VERSION = '0.14';

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({
      'Comment' => 'Comment',
      'Data Type' => 'DataType',
      'Decimal' => 'DecVal',
      'Elemental Procedure' => 'BString',
      'Float' => 'Float',
      'IO Function' => 'Function',
      'Inquiry Function' => 'Function',
      'Keyword' => 'Keyword',
      'Logical' => 'Reserved',
      'Non elemental subroutine' => 'Keyword',
      'Normal Text' => 'Normal',
      'Operator' => 'Operator',
      'Preprocessor' => 'Others',
      'String' => 'String',
      'Symbol' => 'Normal',
      'Transformational Function' => 'Variable',
   });
   $self->listAdd('elemental_procs',
      'abs',
      'achar',
      'acos',
      'adjustl',
      'adjustr',
      'aimag',
      'aint',
      'alog',
      'alog10',
      'amax0',
      'amax1',
      'amin0',
      'amin1',
      'amod',
      'anint',
      'aprime',
      'asin',
      'atan',
      'atan2',
      'btest',
      'cabs',
      'ccos',
      'ceiling',
      'cexp',
      'char',
      'clog',
      'cmplx',
      'conjg',
      'cos',
      'cosh',
      'csin',
      'csqrt',
      'dabs',
      'dacos',
      'dasin',
      'datan',
      'datan2',
      'dble',
      'dcmplx',
      'dconjg',
      'dcos',
      'dcosh',
      'ddim',
      'ddmim',
      'dexp',
      'dfloat',
      'dim',
      'dimag',
      'dint',
      'dlog',
      'dlog10',
      'dmax1',
      'dmin1',
      'dmod',
      'dnint',
      'dprod',
      'dreal',
      'dsign',
      'dsin',
      'dsinh',
      'dsqrt',
      'dtan',
      'dtanh',
      'exp',
      'exponent',
      'float',
      'floor',
      'fraction',
      'iabs',
      'iachar',
      'iand',
      'ibclr',
      'ibits',
      'ibset',
      'ichar',
      'idim',
      'idint',
      'idnint',
      'ieor',
      'ifix',
      'index',
      'int',
      'ior',
      'ishft',
      'ishftc',
      'isign',
      'len_trim',
      'lge',
      'lgt',
      'lle',
      'llt',
      'log',
      'log10',
      'logical',
      'max',
      'max0',
      'max1',
      'merge',
      'min',
      'min0',
      'min1',
      'mod',
      'modulo',
      'mvbits',
      'nearest',
      'nint',
      'not',
      'rand',
      'real',
      'rrspacing',
      'scale',
      'scan',
      'set_exponent',
      'sign',
      'sin',
      'sinh',
      'sngl',
      'spacing',
      'sqrt',
      'tan',
      'tanh',
      'verify',
   );
   $self->listAdd('inquire_keywords',
      'access',
      'action',
      'blank',
      'delim',
      'direct',
      'err',
      'exist',
      'file',
      'form',
      'formatted',
      'iostat',
      'name',
      'named',
      'nextrec',
      'number',
      'opened',
      'pad',
      'position',
      'read',
      'readwrite',
      'recl',
      'sequential',
      'unformatted',
      'unit',
      'write',
   );
   $self->listAdd('inquiry_fn',
      'allocated',
      'associated',
      'bit_size',
      'digits',
      'epsilon',
      'huge',
      'kind',
      'lbound',
      'len',
      'maxexponent',
      'minexponent',
      'precision',
      'present',
      'radix',
      'range',
      'shape',
      'size',
      'tiny',
      'ubound',
   );
   $self->listAdd('io_functions',
      'access',
      'backspace',
      'close',
      'format',
      'inquire',
      'open',
      'print',
      'read',
      'rewind',
      'write',
   );
   $self->listAdd('io_keywords',
      'advance',
      'end',
      'eor',
      'err',
      'fmt',
      'iostat',
      'size',
      'status',
      'unit',
   );
   $self->listAdd('keywords',
      'allocate',
      'assignment',
      'break',
      'call',
      'case',
      'common',
      'contains',
      'continue',
      'cycle',
      'deallocate',
      'default',
      'do',
      'elemental',
      'else',
      'elseif',
      'elsewhere',
      'entry',
      'equivalence',
      'exit',
      'external',
      'for',
      'forall',
      'go',
      'goto',
      'if',
      'implicit',
      'include',
      'interface',
      'intrinsic',
      'namelist',
      'none',
      'nullify',
      'only',
      'operator',
      'pause',
      'procedure',
      'pure',
      'record',
      'recursive',
      'result',
      'return',
      'select',
      'selectcase',
      'stop',
      'then',
      'to',
      'use',
      'where',
      'while',
   );
   $self->listAdd('non_elem_subr',
      'date_and_time',
      'random_number',
      'random_seed',
      'system_clock',
   );
   $self->listAdd('open_keywords',
      'access',
      'action',
      'blank',
      'delim',
      'err',
      'file',
      'form',
      'iostat',
      'pad',
      'position',
      'recl',
      'status',
      'unit',
   );
   $self->listAdd('transform_fn',
      'all',
      'any',
      'count',
      'cshift',
      'dot_product',
      'eoshift',
      'matmul',
      'maxloc',
      'maxval',
      'minloc',
      'minval',
      'pack',
      'product',
      'repeat',
      'reshape',
      'selected_int_kind',
      'selected_real_kind',
      'spread',
      'sum',
      'transfer',
      'transpose',
      'trim',
      'unpack',
   );
   $self->listAdd('types',
      'allocatable',
      'double',
      'optional',
      'parameter',
      'pointer',
      'precision',
      'private',
      'public',
      'save',
      'sequence',
      'target',
   );
   $self->contextdata({
      'default' => {
         callback => \&parsedefault,
         attribute => 'Normal Text',
      },
      'end_of_string' => {
         callback => \&parseend_of_string,
         attribute => 'String',
         fallthrough => '#pop#pop',
      },
      'find_begin_stmnts' => {
         callback => \&parsefind_begin_stmnts,
         attribute => 'Normal Text',
      },
      'find_comments' => {
         callback => \&parsefind_comments,
         attribute => 'Normal Text',
      },
      'find_decls' => {
         callback => \&parsefind_decls,
         attribute => 'Normal Text',
      },
      'find_end_stmnts' => {
         callback => \&parsefind_end_stmnts,
         attribute => 'Normal Text',
      },
      'find_intrinsics' => {
         callback => \&parsefind_intrinsics,
         attribute => 'Normal Text',
      },
      'find_io_paren' => {
         callback => \&parsefind_io_paren,
         attribute => 'Normal Text',
      },
      'find_io_stmnts' => {
         callback => \&parsefind_io_stmnts,
         attribute => 'Normal Text',
      },
      'find_numbers' => {
         callback => \&parsefind_numbers,
         attribute => 'Normal Text',
      },
      'find_op_and_log' => {
         callback => \&parsefind_op_and_log,
         attribute => 'Normal Text',
      },
      'find_paren' => {
         callback => \&parsefind_paren,
         attribute => 'Data Type',
         lineending => '#pop',
      },
      'find_preprocessor' => {
         callback => \&parsefind_preprocessor,
         attribute => 'Normal Text',
      },
      'find_strings' => {
         callback => \&parsefind_strings,
         attribute => 'String',
      },
      'find_symbols' => {
         callback => \&parsefind_symbols,
         attribute => 'Normal Text',
      },
      'format_stmnt' => {
         callback => \&parseformat_stmnt,
         attribute => 'Normal Text',
      },
      'inside_func_paren' => {
         callback => \&parseinside_func_paren,
         attribute => 'Normal Text',
      },
      'string_1' => {
         callback => \&parsestring_1,
         attribute => 'String',
         fallthrough => '#pop',
      },
      'string_2' => {
         callback => \&parsestring_2,
         attribute => 'String',
         fallthrough => '#pop',
      },
   });
   $self->deliminators('\\s||\\.|\\(|\\)|:|\\!|\\+|,|-|<|=|>|\\%|\\&|\\*|\\/|;|\\?|\\[|\\]|\\^|\\{|\\||\\}|\\~|\\\\');
   $self->basecontext('default');
   $self->keywordscase(0);
   $self->initialize;
   bless ($self, $class);
   return $self;
}

sub language {
   return 'Fortran';
}

sub parsedefault {
   my ($self, $text) = @_;
   # context => 'find_strings'
   # type => 'IncludeRules'
   if ($self->includeRules('find_strings', $text)) {
      return 1
   }
   # context => 'find_decls'
   # type => 'IncludeRules'
   if ($self->includeRules('find_decls', $text)) {
      return 1
   }
   # context => 'find_intrinsics'
   # type => 'IncludeRules'
   if ($self->includeRules('find_intrinsics', $text)) {
      return 1
   }
   # context => 'find_io_stmnts'
   # type => 'IncludeRules'
   if ($self->includeRules('find_io_stmnts', $text)) {
      return 1
   }
   # context => 'find_op_and_log'
   # type => 'IncludeRules'
   if ($self->includeRules('find_op_and_log', $text)) {
      return 1
   }
   # context => 'find_numbers'
   # type => 'IncludeRules'
   if ($self->includeRules('find_numbers', $text)) {
      return 1
   }
   # context => 'find_preprocessor'
   # type => 'IncludeRules'
   if ($self->includeRules('find_preprocessor', $text)) {
      return 1
   }
   # context => 'find_comments'
   # type => 'IncludeRules'
   if ($self->includeRules('find_comments', $text)) {
      return 1
   }
   # context => 'find_symbols'
   # type => 'IncludeRules'
   if ($self->includeRules('find_symbols', $text)) {
      return 1
   }
   # context => 'find_end_stmnts'
   # type => 'IncludeRules'
   if ($self->includeRules('find_end_stmnts', $text)) {
      return 1
   }
   # context => 'find_begin_stmnts'
   # type => 'IncludeRules'
   if ($self->includeRules('find_begin_stmnts', $text)) {
      return 1
   }
   return 0;
};

sub parseend_of_string {
   my ($self, $text) = @_;
   # type => 'DetectSpaces'
   if ($self->testDetectSpaces($text, 0, undef, 0, '#stay', undef)) {
      return 1
   }
   # String => '&\s*$'
   # attribute => 'Keyword'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '&\\s*$', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # attribute => 'Keyword'
   # char => '&'
   # context => '#pop'
   # firstNonSpace => 'true'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '&', 0, 0, 0, undef, 1, '#pop', 'Keyword')) {
      return 1
   }
   # String => '(!.*)?$'
   # attribute => 'Comment'
   # context => '#stay'
   # firstNonSpace => 'true'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '(!.*)?$', 0, 0, 0, undef, 1, '#stay', 'Comment')) {
      return 1
   }
   return 0;
};

sub parsefind_begin_stmnts {
   my ($self, $text) = @_;
   # String => '\bmodule\s+procedure\b'
   # attribute => 'Keyword'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bmodule\\s+procedure\\b', 1, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '\b(program|subroutine|function|module|block\s*data)\b'
   # attribute => 'Keyword'
   # beginRegion => 'Unit'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b(program|subroutine|function|module|block\\s*data)\\b', 1, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   return 0;
};

sub parsefind_comments {
   my ($self, $text) = @_;
   # String => '[cC\*].*$'
   # attribute => 'Comment'
   # column => '0'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '[cC\\*].*$', 0, 0, 0, 0, 0, '#stay', 'Comment')) {
      return 1
   }
   # String => '!.*$'
   # attribute => 'Comment'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '!.*$', 0, 0, 0, undef, 0, '#stay', 'Comment')) {
      return 1
   }
   return 0;
};

sub parsefind_decls {
   my ($self, $text) = @_;
   # String => '\binteger[\*]\d{1,2}'
   # attribute => 'Data Type'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\binteger[\\*]\\d{1,2}', 1, 0, 0, undef, 0, '#stay', 'Data Type')) {
      return 1
   }
   # String => '\breal[\*]\d{1,2}'
   # attribute => 'Data Type'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\breal[\\*]\\d{1,2}', 1, 0, 0, undef, 0, '#stay', 'Data Type')) {
      return 1
   }
   # String => '\bcomplex[\*]\d{1,2}'
   # attribute => 'Data Type'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bcomplex[\\*]\\d{1,2}', 1, 0, 0, undef, 0, '#stay', 'Data Type')) {
      return 1
   }
   # String => '\bend\s*type\b'
   # attribute => 'Data Type'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bend\\s*type\\b', 1, 0, 0, undef, 0, '#stay', 'Data Type')) {
      return 1
   }
   # String => 'types'
   # attribute => 'Data Type'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'types', 0, undef, 0, '#stay', 'Data Type')) {
      return 1
   }
   # String => '^\s*data\b'
   # attribute => 'Data Type'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '^\\s*data\\b', 1, 0, 0, undef, 0, '#stay', 'Data Type')) {
      return 1
   }
   # String => '^\s*real\s*[(]'
   # attribute => 'Data Type'
   # context => 'find_paren'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '^\\s*real\\s*[(]', 1, 0, 0, undef, 0, 'find_paren', 'Data Type')) {
      return 1
   }
   # String => '^\s*real(?![\w\*])'
   # attribute => 'Data Type'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '^\\s*real(?![\\w\\*])', 1, 0, 0, undef, 0, '#stay', 'Data Type')) {
      return 1
   }
   # String => '\bcharacter[*][0-9]+\b'
   # attribute => 'Data Type'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bcharacter[*][0-9]+\\b', 1, 0, 0, undef, 0, '#stay', 'Data Type')) {
      return 1
   }
   # String => '\b(type|integer|complex|character|logical|intent|dimension)\b\s*[(]'
   # attribute => 'Data Type'
   # context => 'find_paren'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b(type|integer|complex|character|logical|intent|dimension)\\b\\s*[(]', 1, 0, 0, undef, 0, 'find_paren', 'Data Type')) {
      return 1
   }
   # String => '\b(type|integer|complex|character|logical|intent|dimension)\b'
   # attribute => 'Data Type'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b(type|integer|complex|character|logical|intent|dimension)\\b', 1, 0, 0, undef, 0, '#stay', 'Data Type')) {
      return 1
   }
   # attribute => 'Data Type'
   # char => ':'
   # char1 => ':'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, ':', ':', 0, 0, 0, undef, 0, '#stay', 'Data Type')) {
      return 1
   }
   return 0;
};

sub parsefind_end_stmnts {
   my ($self, $text) = @_;
   # String => '\bend\s*(program|subroutine|function|module|block\s*data)\b'
   # attribute => 'Keyword'
   # context => '#stay'
   # endRegion => 'Unit'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bend\\s*(program|subroutine|function|module|block\\s*data)\\b', 1, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '\bend\s*(do|if|select|where|forall|interface)\b'
   # attribute => 'Keyword'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bend\\s*(do|if|select|where|forall|interface)\\b', 1, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '\bend\b'
   # attribute => 'Keyword'
   # context => '#stay'
   # endRegion => 'Unit'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bend\\b', 1, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   return 0;
};

sub parsefind_intrinsics {
   my ($self, $text) = @_;
   # String => 'keywords'
   # attribute => 'Keyword'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'keywords', 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => 'elemental_procs'
   # attribute => 'Elemental Procedure'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'elemental_procs', 0, undef, 0, '#stay', 'Elemental Procedure')) {
      return 1
   }
   # String => 'inquiry_fn'
   # attribute => 'Inquiry Function'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'inquiry_fn', 0, undef, 0, '#stay', 'Inquiry Function')) {
      return 1
   }
   # String => 'transform_fn'
   # attribute => 'Transformational Function'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'transform_fn', 0, undef, 0, '#stay', 'Transformational Function')) {
      return 1
   }
   # String => 'non_elem_subr'
   # attribute => 'Non elemental subroutine'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'non_elem_subr', 0, undef, 0, '#stay', 'Non elemental subroutine')) {
      return 1
   }
   return 0;
};

sub parsefind_io_paren {
   my ($self, $text) = @_;
   # attribute => 'IO Function'
   # char => '*'
   # context => '#stay'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '*', 0, 0, 0, undef, 0, '#stay', 'IO Function')) {
      return 1
   }
   # attribute => 'Normal Text'
   # char => '('
   # context => 'inside_func_paren'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'inside_func_paren', 'Normal Text')) {
      return 1
   }
   # attribute => 'IO Function'
   # char => ')'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop', 'IO Function')) {
      return 1
   }
   # String => 'io_keywords'
   # attribute => 'IO Function'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'io_keywords', 0, undef, 0, '#stay', 'IO Function')) {
      return 1
   }
   # String => 'inquire_keywords'
   # attribute => 'IO Function'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'inquire_keywords', 0, undef, 0, '#stay', 'IO Function')) {
      return 1
   }
   # String => 'open_keywords'
   # attribute => 'IO Function'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'open_keywords', 0, undef, 0, '#stay', 'IO Function')) {
      return 1
   }
   # context => 'find_strings'
   # type => 'IncludeRules'
   if ($self->includeRules('find_strings', $text)) {
      return 1
   }
   # context => 'find_intrinsics'
   # type => 'IncludeRules'
   if ($self->includeRules('find_intrinsics', $text)) {
      return 1
   }
   # context => 'find_numbers'
   # type => 'IncludeRules'
   if ($self->includeRules('find_numbers', $text)) {
      return 1
   }
   # context => 'find_symbols'
   # type => 'IncludeRules'
   if ($self->includeRules('find_symbols', $text)) {
      return 1
   }
   return 0;
};

sub parsefind_io_stmnts {
   my ($self, $text) = @_;
   # String => '\b(read|write|backspace|rewind|end\s*file|close)\s*[(]'
   # attribute => 'IO Function'
   # context => 'find_io_paren'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b(read|write|backspace|rewind|end\\s*file|close)\\s*[(]', 1, 0, 0, undef, 0, 'find_io_paren', 'IO Function')) {
      return 1
   }
   # String => '\bopen\s*[(]'
   # attribute => 'IO Function'
   # context => 'find_io_paren'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bopen\\s*[(]', 1, 0, 0, undef, 0, 'find_io_paren', 'IO Function')) {
      return 1
   }
   # String => '\binquire\s*[(]'
   # attribute => 'IO Function'
   # context => 'find_io_paren'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\binquire\\s*[(]', 1, 0, 0, undef, 0, 'find_io_paren', 'IO Function')) {
      return 1
   }
   # String => '\bformat\s*[(]'
   # attribute => 'IO Function'
   # context => 'format_stmnt'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bformat\\s*[(]', 1, 0, 0, undef, 0, 'format_stmnt', 'IO Function')) {
      return 1
   }
   # String => '\bend\s*file\b'
   # attribute => 'IO Function'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\bend\\s*file\\b', 1, 0, 0, undef, 0, '#stay', 'IO Function')) {
      return 1
   }
   # String => 'io_functions'
   # attribute => 'IO Function'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'io_functions', 0, undef, 0, '#stay', 'IO Function')) {
      return 1
   }
   return 0;
};

sub parsefind_numbers {
   my ($self, $text) = @_;
   # String => '[0-9]*\.[0-9]+([de][+-]?[0-9]+)?([_]([0-9]+|[a-z][\w_]*))?'
   # attribute => 'Float'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '[0-9]*\\.[0-9]+([de][+-]?[0-9]+)?([_]([0-9]+|[a-z][\\w_]*))?', 1, 0, 0, undef, 0, '#stay', 'Float')) {
      return 1
   }
   # String => '\b[0-9]+\.[0-9]*([de][+-]?[0-9]+)?([_]([0-9]+|[a-z][\w_]*))?(?![a-z])'
   # attribute => 'Float'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b[0-9]+\\.[0-9]*([de][+-]?[0-9]+)?([_]([0-9]+|[a-z][\\w_]*))?(?![a-z])', 1, 0, 0, undef, 0, '#stay', 'Float')) {
      return 1
   }
   # String => '\b[0-9]+[de][+-]?[0-9]+([_]([0-9]+|[a-z][\w_]*))?'
   # attribute => 'Float'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b[0-9]+[de][+-]?[0-9]+([_]([0-9]+|[a-z][\\w_]*))?', 1, 0, 0, undef, 0, '#stay', 'Float')) {
      return 1
   }
   # String => '\b[0-9]+([_]([0-9]+|[a-zA-Z][\w_]*))?'
   # attribute => 'Decimal'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b[0-9]+([_]([0-9]+|[a-zA-Z][\\w_]*))?', 0, 0, 0, undef, 0, '#stay', 'Decimal')) {
      return 1
   }
   # String => '\b[bozx](['][0-9a-f]+[']|["][0-9a-f]+["])'
   # attribute => 'Decimal'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\b[bozx]([\'][0-9a-f]+[\']|["][0-9a-f]+["])', 1, 0, 0, undef, 0, '#stay', 'Decimal')) {
      return 1
   }
   return 0;
};

sub parsefind_op_and_log {
   my ($self, $text) = @_;
   # String => '\.(true|false)\.'
   # attribute => 'Logical'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\.(true|false)\\.', 1, 0, 0, undef, 0, '#stay', 'Logical')) {
      return 1
   }
   # String => '\.[A-Za-z]+\.'
   # attribute => 'Operator'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\.[A-Za-z]+\\.', 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
   }
   return 0;
};

sub parsefind_paren {
   my ($self, $text) = @_;
   # attribute => 'Data Type'
   # char => '('
   # context => 'find_paren'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'find_paren', 'Data Type')) {
      return 1
   }
   # attribute => 'Data Type'
   # char => ')'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop', 'Data Type')) {
      return 1
   }
   return 0;
};

sub parsefind_preprocessor {
   my ($self, $text) = @_;
   # String => '(#|cDEC\$|CDEC\$).*$'
   # attribute => 'Preprocessor'
   # column => '0'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '(#|cDEC\\$|CDEC\\$).*$', 0, 0, 0, 0, 0, '#stay', 'Preprocessor')) {
      return 1
   }
   return 0;
};

sub parsefind_strings {
   my ($self, $text) = @_;
   # attribute => 'String'
   # char => '''
   # context => 'string_1'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, 'string_1', 'String')) {
      return 1
   }
   # attribute => 'String'
   # char => '"'
   # context => 'string_2'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, 'string_2', 'String')) {
      return 1
   }
   return 0;
};

sub parsefind_symbols {
   my ($self, $text) = @_;
   # attribute => 'Keyword'
   # char => '*'
   # char1 => '*'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '*', '*', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # attribute => 'Keyword'
   # char => '('
   # char1 => '/'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '(', '/', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # attribute => 'Keyword'
   # char => '/'
   # char1 => ')'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '/', ')', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '&+-*/=?[]^{|}~'
   # attribute => 'Keyword'
   # context => '#stay'
   # type => 'AnyChar'
   if ($self->testAnyChar($text, '&+-*/=?[]^{|}~', 0, 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => '(),'
   # attribute => 'Symbol'
   # context => '#stay'
   # type => 'AnyChar'
   if ($self->testAnyChar($text, '(),', 0, 0, undef, 0, '#stay', 'Symbol')) {
      return 1
   }
   return 0;
};

sub parseformat_stmnt {
   my ($self, $text) = @_;
   # attribute => 'IO Function'
   # char => '('
   # context => 'format_stmnt'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'format_stmnt', 'IO Function')) {
      return 1
   }
   # attribute => 'IO Function'
   # char => ')'
   # context => '#pop'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, ')', 0, 0, 0, undef, 0, '#pop', 'IO Function')) {
      return 1
   }
   # String => '[0-9]*/'
   # attribute => 'IO Function'
   # context => '#stay'
   # insensitive => 'TRUE'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '[0-9]*/', 1, 0, 0, undef, 0, '#stay', 'IO Function')) {
      return 1
   }
   # String => ':'
   # attribute => 'IO Function'
   # context => '#stay'
   # type => 'AnyChar'
   if ($self->testAnyChar($text, ':', 0, 0, undef, 0, '#stay', 'IO Function')) {
      return 1
   }
   # context => 'find_strings'
   # type => 'IncludeRules'
   if ($self->includeRules('find_strings', $text)) {
      return 1
   }
   # context => 'find_symbols'
   # type => 'IncludeRules'
   if ($self->includeRules('find_symbols', $text)) {
      return 1
   }
   return 0;
};

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

sub parsestring_1 {
   my ($self, $text) = @_;
   # String => '[^']*''
   # attribute => 'String'
   # context => '#pop'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '[^\']*\'', 0, 0, 0, undef, 0, '#pop', 'String')) {
      return 1
   }
   # String => '&\s*$'
   # attribute => 'Keyword'
   # context => 'end_of_string'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '&\\s*$', 0, 0, 0, undef, 0, 'end_of_string', 'Keyword')) {
      return 1
   }
   # String => '.*(?=&\s*$)'
   # attribute => 'String'
   # context => 'end_of_string'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '.*(?=&\\s*$)', 0, 0, 0, undef, 0, 'end_of_string', 'String')) {
      return 1
   }
   return 0;
};

sub parsestring_2 {
   my ($self, $text) = @_;
   # String => '[^"]*"'
   # attribute => 'String'
   # context => '#pop'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '[^"]*"', 0, 0, 0, undef, 0, '#pop', 'String')) {
      return 1
   }
   # String => '&\s*$'
   # attribute => 'Keyword'
   # context => 'end_of_string'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '&\\s*$', 0, 0, 0, undef, 0, 'end_of_string', 'Keyword')) {
      return 1
   }
   # String => '.*(?=&\s*$)'
   # attribute => 'String'
   # context => 'end_of_string'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '.*(?=&\\s*$)', 0, 0, 0, undef, 0, 'end_of_string', 'String')) {
      return 1
   }
   return 0;
};


1;

__END__

=head1 NAME

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

=head1 SYNOPSIS

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

=head1 DESCRIPTION

Syntax::Highlight::Engine::Kate::Fortran is a  plugin module that provides syntax highlighting
for Fortran 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