File Coverage

blib/lib/Syntax/Highlight/Engine/Kate/Scheme.pm

Criterion	Covered	Total	%
statement	126	141	89.3
branch	78	92	84.7
condition	1	3	33.3
subroutine	16	17	94.1
pod	0	14	0.0
total	221	267	82.7

# 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 'scheme.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 Dominik Haumann ([e-mail])
#generated: Sun Feb  3 22:02:06 2008, localtime

package Syntax::Highlight::Engine::Kate::Scheme;

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({
      'BaseN' => 'BaseN',
      'Brackets1' => 'Others',
      'Brackets2' => 'Others',
      'Brackets3' => 'Others',
      'Brackets4' => 'Others',
      'Brackets5' => 'Others',
      'Brackets6' => 'Others',
      'Char' => 'Char',
      'Comment' => 'Comment',
      'Data' => 'DataType',
      'Decimal' => 'DecVal',
      'Definition' => 'Reserved',
      'Float' => 'Float',
      'Function' => 'Function',
      'Keyword' => 'Keyword',
      'Normal' => 'Normal',
      'Operator' => 'Operator',
      'Region Marker' => 'RegionMarker',
      'String' => 'String',
   });
   $self->listAdd('characters',
      '#\\\\ack',
      '#\\\\backspace',
      '#\\\\bel',
      '#\\\\bs',
      '#\\\\bs',
      '#\\\\can',
      '#\\\\cr',
      '#\\\\cr',
      '#\\\\dc1',
      '#\\\\dc2',
      '#\\\\dc3',
      '#\\\\dc4',
      '#\\\\dle',
      '#\\\\em',
      '#\\\\enq',
      '#\\\\eot',
      '#\\\\esc',
      '#\\\\etb',
      '#\\\\etx',
      '#\\\\fs',
      '#\\\\gs',
      '#\\\\ht',
      '#\\\\ht',
      '#\\\\nak',
      '#\\\\newline',
      '#\\\\nl',
      '#\\\\nl',
      '#\\\\np',
      '#\\\\np',
      '#\\\\nul',
      '#\\\\nul',
      '#\\\\null',
      '#\\\\page',
      '#\\\\return',
      '#\\\\rs',
      '#\\\\si',
      '#\\\\so',
      '#\\\\soh',
      '#\\\\sp',
      '#\\\\space',
      '#\\\\stx',
      '#\\\\sub',
      '#\\\\syn',
      '#\\\\tab',
      '#\\\\us',
      '#\\\\vt',
   );
   $self->listAdd('defines',
      'define',
      'define*',
      'define*-public',
      'define-accessor',
      'define-class',
      'define-generic',
      'define-macro',
      'define-method',
      'define-module',
      'define-private',
      'define-public',
      'define-reader-ctor',
      'define-syntax',
      'define-syntax-macro',
      'defined?',
      'defmacro',
      'defmacro*',
      'defmacro*-public',
   );
   $self->listAdd('keywords',
      'abs',
      'acos',
      'and',
      'angle',
      'append',
      'applymap',
      'asin',
      'assoc',
      'assq',
      'assv',
      'atan',
      'begin',
      'boolean?',
      'break',
      'caaaar',
      'caaadr',
      'caaar',
      'caadar',
      'caaddr',
      'caadr',
      'caar',
      'cadaar',
      'cadadr',
      'cadar',
      'caddar',
      'cadddr',
      'caddr',
      'cadr',
      'call-with-current-continuation',
      'call-with-input-file',
      'call-with-output-file',
      'call-with-values',
      'call/cc',
      'car',
      'case',
      'catch',
      'cdaaar',
      'cdaadr',
      'cdaar',
      'cdadar',
      'cdaddr',
      'cdadr',
      'cdar',
      'cddaar',
      'cddadr',
      'cddar',
      'cdddar',
      'cddddr',
      'cdddr',
      'cddr',
      'cdr',
      'ceiling',
      'char->integer',
      'char-alphabetic?',
      'char-ci<=?',
      'char-ci=?',
      'char-ci>=?',
      'char-ci>?',
      'char-downcase',
      'char-lower-case?',
      'char-numeric?',
      'char-ready?',
      'char-upcase',
      'char-upper-case?',
      'char-whitespace?',
      'char<=?',
      'char
      'char=?',
      'char>=?',
      'char>?',
      'char?',
      'close-input-port',
      'close-output-port',
      'complex?',
      'cond',
      'cons',
      'continue',
      'cos',
      'current-input-port',
      'current-output-port',
      'denominator',
      'display',
      'do',
      'dynamic-wind',
      'else',
      'eof-object?',
      'eq?',
      'equal?',
      'eqv?',
      'eval',
      'even?',
      'exact->inexact',
      'exact?',
      'exp',
      'expt',
      'floor',
      'for-each',
      'force',
      'gcd',
      'har-ci
      'if',
      'imag-part',
      'inexact->exact',
      'inexact?',
      'input-port?',
      'integer->char',
      'integer?',
      'interaction-environment',
      'lambda',
      'lcm',
      'length',
      'let',
      'let*',
      'let-syntax',
      'letrec',
      'letrec-syntax',
      'list',
      'list->string',
      'list-ref',
      'list-tail',
      'list?',
      'load',
      'log',
      'magnitude',
      'make-polar',
      'make-rectangular',
      'make-string',
      'make-vector',
      'max',
      'member',
      'memq',
      'memv',
      'min',
      'modulo',
      'negative?',
      'newline',
      'not',
      'null-environment',
      'null?',
      'number->string',
      'number?',
      'numerator',
      'odd?',
      'open-input-file',
      'open-output-file',
      'or',
      'output-port?',
      'pair?',
      'peek-char',
      'port?',
      'positive?',
      'procedure?',
      'quotient',
      'rational?',
      'rationalize',
      'read',
      'read-char',
      'real-part',
      'real?',
      'remainder',
      'reverse',
      'round',
      'scheme-report-environment',
      'set-car!',
      'set-cdr!',
      'sin',
      'sqrt',
      'string',
      'string->list',
      'string->number',
      'string->symbol',
      'string-append',
      'string-ci<=?',
      'string-ci
      'string-ci=?',
      'string-ci>=?',
      'string-ci>?',
      'string-copy',
      'string-fill!',
      'string-length',
      'string-ref',
      'string-set!',
      'string<=?',
      'string
      'string=?',
      'string>=?',
      'string>?',
      'string?',
      'substring',
      'symbol->string',
      'symbol?',
      'syntax-rules',
      'tan',
      'transcript-off',
      'transcript-on',
      'truncate',
      'values',
      'vector',
      'vector->listlist->vector',
      'vector-fill!',
      'vector-length',
      'vector-ref',
      'vector-set!',
      'vector?',
      'while',
      'with-input-from-file',
      'with-output-to-file',
      'write',
      'write-char',
      'zero?',
   );
   $self->listAdd('operators',
      '*)',
      '*,*',
      '+',
      '-',
      '/',
      '<',
      '<=',
      '=',
      '=>',
      '>',
      '>=',
   );
   $self->contextdata({
      'Default' => {
         callback => \&parseDefault,
         attribute => 'Normal',
      },
      'Level0' => {
         callback => \&parseLevel0,
         attribute => 'Normal',
      },
      'Level1' => {
         callback => \&parseLevel1,
         attribute => 'Normal',
      },
      'Level2' => {
         callback => \&parseLevel2,
         attribute => 'Normal',
      },
      'Level3' => {
         callback => \&parseLevel3,
         attribute => 'Normal',
      },
      'Level4' => {
         callback => \&parseLevel4,
         attribute => 'Normal',
      },
      'Level5' => {
         callback => \&parseLevel5,
         attribute => 'Normal',
      },
      'Level6' => {
         callback => \&parseLevel6,
         attribute => 'Normal',
      },
      'MultiLineComment' => {
         callback => \&parseMultiLineComment,
         attribute => 'Comment',
      },
      'SpecialNumber' => {
         callback => \&parseSpecialNumber,
         attribute => 'Normal',
         lineending => '#pop',
      },
      'String' => {
         callback => \&parseString,
         attribute => 'String',
      },
      'function_decl' => {
         callback => \&parsefunction_decl,
         attribute => 'Function',
      },
   });
   $self->deliminators('\\s||\\.|\\(|\\)|,|\\%|\\&|;|\\[|\\]|\\^|\\{|\\||\\}|\\~|-|\\+|\\*|\\?|\\!|<|>|=|\\/|:|#|\\\\');
   $self->basecontext('Level0');
   $self->keywordscase(0);
   $self->initialize;
   bless ($self, $class);
   return $self;
}

sub language {
   return 'Scheme';
}

sub parseDefault {
   my ($self, $text) = @_;
   # String => ';+\s*BEGIN.*$'
   # attribute => 'Region Marker'
   # beginRegion => 'region'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, ';+\\s*BEGIN.*$', 0, 0, 0, undef, 0, '#stay', 'Region Marker')) {
      return 1
   }
   # String => ';+\s*END.*$'
   # attribute => 'Region Marker'
   # context => '#stay'
   # endRegion => 'region'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, ';+\\s*END.*$', 0, 0, 0, undef, 0, '#stay', 'Region Marker')) {
      return 1
   }
   # String => ';.*$'
   # attribute => 'Comment'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, ';.*$', 0, 0, 0, undef, 0, '#stay', 'Comment')) {
      return 1
   }
   # attribute => 'Comment'
   # beginRegion => 'region'
   # char => '#'
   # char1 => '!'
   # context => 'MultiLineComment'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '#', '!', 0, 0, 0, undef, 0, 'MultiLineComment', 'Comment')) {
      return 1
   }
   # String => 'keywords'
   # attribute => 'Keyword'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'keywords', 0, undef, 0, '#stay', 'Keyword')) {
      return 1
   }
   # String => 'operators'
   # attribute => 'Operator'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'operators', 0, undef, 0, '#stay', 'Operator')) {
      return 1
   }
   # String => 'defines'
   # attribute => 'Definition'
   # context => 'function_decl'
   # type => 'keyword'
   if ($self->testKeyword($text, 'defines', 0, undef, 0, 'function_decl', 'Definition')) {
      return 1
   }
   # String => 'characters'
   # attribute => 'Char'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'characters', 0, undef, 0, '#stay', 'Char')) {
      return 1
   }
   # String => '#\\.'
   # attribute => 'Char'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#\\\\.', 0, 0, 0, undef, 0, '#stay', 'Char')) {
      return 1
   }
   # attribute => 'String'
   # char => '"'
   # context => 'String'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, 'String', 'String')) {
      return 1
   }
   # String => '#[bodxei]'
   # attribute => 'Char'
   # context => 'SpecialNumber'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#[bodxei]', 0, 0, 0, undef, 0, 'SpecialNumber', 'Char')) {
      return 1
   }
   # String => '#[tf]'
   # attribute => 'Decimal'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#[tf]', 0, 0, 0, undef, 0, '#stay', 'Decimal')) {
      return 1
   }
   # attribute => 'Float'
   # context => '#stay'
   # type => 'Float'
   if ($self->testFloat($text, 0, undef, 0, '#stay', 'Float')) {
      return 1
   }
   # attribute => 'Decimal'
   # context => '#stay'
   # type => 'Int'
   if ($self->testInt($text, 0, undef, 0, '#stay', 'Decimal')) {
      return 1
   }
   # attribute => 'Brackets1'
   # char => '('
   # context => 'Level1'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'Level1', 'Brackets1')) {
      return 1
   }
   return 0;
};

sub parseLevel0 {
   my ($self, $text) = @_;
   # attribute => 'Brackets1'
   # char => '('
   # context => 'Level1'
   # type => 'DetectChar'
   if ($self->testDetectChar($text, '(', 0, 0, 0, undef, 0, 'Level1', 'Brackets1')) {
      return 1
   }
   # context => 'Default'
   # type => 'IncludeRules'
   if ($self->includeRules('Default', $text)) {
      return 1
   }
   return 0;
};

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

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

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

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

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

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

sub parseMultiLineComment {
   my ($self, $text) = @_;
   # String => '!#\s*$'
   # attribute => 'Comment'
   # column => '0'
   # context => '#pop'
   # endRegion => 'region'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '!#\\s*$', 0, 0, 0, 0, 0, '#pop', 'Comment')) {
      return 1
   }
   return 0;
};

sub parseSpecialNumber {
   my ($self, $text) = @_;
   # attribute => 'Float'
   # context => '#pop'
   # type => 'Float'
   if ($self->testFloat($text, 0, undef, 0, '#pop', 'Float')) {
      return 1
   }
   # attribute => 'Decimal'
   # context => '#pop'
   # type => 'Int'
   if ($self->testInt($text, 0, undef, 0, '#pop', 'Decimal')) {
      return 1
   }
   # attribute => 'BaseN'
   # context => '#pop'
   # type => 'HlCOct'
   if ($self->testHlCOct($text, 0, undef, 0, '#pop', 'BaseN')) {
      return 1
   }
   # attribute => 'Float'
   # context => '#pop'
   # type => 'HlCHex'
   if ($self->testHlCHex($text, 0, undef, 0, '#pop', 'Float')) {
      return 1
   }
   return 0;
};

sub parseString {
   my ($self, $text) = @_;
   # String => 'characters'
   # attribute => 'Char'
   # context => '#stay'
   # type => 'keyword'
   if ($self->testKeyword($text, 'characters', 0, undef, 0, '#stay', 'Char')) {
      return 1
   }
   # String => '#\\.'
   # attribute => 'Char'
   # context => '#stay'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '#\\\\.', 0, 0, 0, undef, 0, '#stay', 'Char')) {
      return 1
   }
   # attribute => 'Char'
   # char => '\'
   # char1 => '"'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '"', 0, 0, 0, undef, 0, '#stay', 'Char')) {
      return 1
   }
   # attribute => 'Char'
   # char => '\'
   # char1 => '\'
   # context => '#stay'
   # type => 'Detect2Chars'
   if ($self->testDetect2Chars($text, '\\', '\\', 0, 0, 0, undef, 0, '#stay', 'Char')) {
      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 parsefunction_decl {
   my ($self, $text) = @_;
   # String => '\s*[A-Za-z0-9-+\<\>//\*]*\s*'
   # attribute => 'Function'
   # context => '#pop'
   # type => 'RegExpr'
   if ($self->testRegExpr($text, '\\s*[A-Za-z0-9-+\\<\\>//\\*]*\\s*', 0, 0, 0, undef, 0, '#pop', 'Function')) {
      return 1
   }
   return 0;
};


1;

__END__