local-lib5/lib/perl5/Syntax/Highlight/Engine/Kate/Inform.pm

   1 # Copyright (c) 2005 - 2006 Hans Jeuken. All rights reserved.
   2 # This program is free software; you can redistribute it and/or
   3 # modify it under the same terms as Perl itself.
   4
   5 # This file was generated from the 'inform.xml' file of the syntax highlight
   6 # engine of the kate text editor (http://www.kate-editor.org
   7
   8 #kate xml version 1.23
   9 #kate version 2.3
  10 #kate author Giancarlo Niccolai (giancarlo@niccolai.ws)
  11 #generated: Sun Feb  3 22:02:05 2008, localtime
  12
  13 package Syntax::Highlight::Engine::Kate::Inform;
  14
  15 our $VERSION = '0.06';
  16
  17 use strict;
  18 use warnings;
  19 use base('Syntax::Highlight::Engine::Kate::Template');
  20
  21 sub new {
  22    my $proto = shift;
  23    my $class = ref($proto) || $proto;
  24    my $self = $class->SUPER::new(@_);
  25    $self->attributes({
  26       'Actions' => 'DataType',
  27       'Comment' => 'Comment',
  28       'Function' => 'Function',
  29       'Keyword' => 'Keyword',
  30       'Normal Text' => 'Normal',
  31       'Number' => 'DecVal',
  32       'OpCode' => 'Reserved',
  33       'Operator' => 'Operator',
  34       'Pragma' => 'Others',
  35       'PredefFunction' => 'Function',
  36       'String' => 'String',
  37       'Values' => 'BaseN',
  38       'Word' => 'IString',
  39    });
  40    $self->listAdd('ClassDeclOps',
  41       'has',
  42       'private',
  43       'with',
  44    );
  45    $self->listAdd('actions',
  46       'Answer',
  47       'Ask',
  48       'AskFor',
  49       'Attack',
  50       'Blow',
  51       'Burn',
  52       'Buy',
  53       'Climb',
  54       'Climb',
  55       'Close',
  56       'Consult',
  57       'Cut',
  58       'Dig',
  59       'Disrobe',
  60       'Drink',
  61       'Drop',
  62       'Eat',
  63       'Empty',
  64       'Empty',
  65       'EmptyT',
  66       'Enter',
  67       'Examine',
  68       'Exit',
  69       'Fill',
  70       'FullScore',
  71       'GetOff',
  72       'GetOff',
  73       'Give',
  74       'Go',
  75       'GoIn',
  76       'GoIn',
  77       'Insert',
  78       'Inv',
  79       'Inv',
  80       'InvTall',
  81       'InvWide',
  82       'Jump',
  83       'JumpOn',
  84       'Kiss',
  85       'LMode1',
  86       'LMode2',
  87       'LMode3',
  88       'LetGo',
  89       'Listen',
  90       'Lock',
  91       'Look',
  92       'Mild',
  93       'No',
  94       'NotifyOff',
  95       'NotifyOn',
  96       'Objects',
  97       'Open',
  98       'Places',
  99       'Pray',
 100       'Pronouns',
 101       'Pull',
 102       'Push',
 103       'PushDir',
 104       'PutOn',
 105       'Quit',
 106       'Receive',
 107       'Restart',
 108       'Restore',
 109       'Rub',
 110       'Save',
 111       'Score',
 112       'ScriptOff',
 113       'ScriptOn',
 114       'Search',
 115       'Set',
 116       'SetTo',
 117       'Show',
 118       'Sing',
 119       'Sing',
 120       'Sing',
 121       'Sleep',
 122       'Smell',
 123       'Sorry',
 124       'Squeeze',
 125       'Strong',
 126       'Swim',
 127       'Swing',
 128       'SwitchOff',
 129       'SwitchOn',
 130       'Take',
 131       'Taste',
 132       'Tell',
 133       'Think',
 134       'ThrowAt',
 135       'ThrownAt',
 136       'Tie',
 137       'Touch',
 138       'Transfer',
 139       'Turn',
 140       'Unlock',
 141       'VagueGo',
 142       'Verify',
 143       'Version',
 144       'Wave',
 145       'WaveHands',
 146       'Wear',
 147       'Yes',
 148    );
 149    $self->listAdd('functions',
 150       'Achieved',
 151       'AddToScope',
 152       'CDefArt',
 153       'ChangeDefault',
 154       'DefArt',
 155       'DoMenu',
 156       'EnglishNumber',
 157       'HasLightSource',
 158       'InDefArt',
 159       'Locale',
 160       'LoopOverScope',
 161       'NextWord',
 162       'NextWordStopped',
 163       'NounDomain',
 164       'ObjectIsUntouchable',
 165       'OffersLight',
 166       'PlaceInScope',
 167       'PlayerTo',
 168       'PrintShortName',
 169       'ScopeWithin',
 170       'SetTime',
 171       'StartDaemon',
 172       'StartTimer',
 173       'StopDaemon',
 174       'StopTimer',
 175       'TestScope',
 176       'TryNumber',
 177       'UnsignedCompare',
 178       'WordAddress',
 179       'WordLenght',
 180       'WriteListFrom',
 181       'YesOrNo',
 182       'ZRegion',
 183       'allowpushdir',
 184       'child',
 185       'children',
 186       'metaclass',
 187       'parent',
 188    );
 189    $self->listAdd('inline_pragmas',
 190       '#else',
 191       '#endif',
 192       '#ifdef',
 193       '#ifndef',
 194    );
 195    $self->listAdd('keywords',
 196       'box',
 197       'break',
 198       'continue',
 199       'do',
 200       'else',
 201       'font',
 202       'for',
 203       'give',
 204       'if',
 205       'inversion',
 206       'jump',
 207       'move',
 208       'new_line',
 209       'objectloop',
 210       'on',
 211       'print',
 212       'print_ret',
 213       'quit',
 214       'read',
 215       'remove',
 216       'restore',
 217       'return',
 218       'rfalse',
 219       'rtrue',
 220       'save',
 221       'spaces',
 222       'spring',
 223       'style',
 224       'switch',
 225       'to',
 226       'until',
 227    );
 228    $self->listAdd('operators',
 229       'has',
 230       'hasn\\\'t',
 231       'in',
 232       'notin',
 233       'ofclass',
 234       'or',
 235       'provides',
 236    );
 237    $self->listAdd('pragmas',
 238       'Abbreviate',
 239       'Array',
 240       'Attribute',
 241       'Constant',
 242       'Default',
 243       'End',
 244       'Endif',
 245       'Extend',
 246       'Global',
 247       'Ifdef',
 248       'Iffalse',
 249       'Iffalse',
 250       'Ifndef',
 251       'Ifnot',
 252       'Ifnot',
 253       'Iftrue',
 254       'Iftrue',
 255       'Import',
 256       'Include',
 257       'Link',
 258       'Lowstring',
 259       'Message',
 260       'Property',
 261       'Release',
 262       'Replace',
 263       'Serial',
 264       'Statusline',
 265       'Switches',
 266       'System_file',
 267       'Verb',
 268       'score',
 269    );
 270    $self->listAdd('special_vals',
 271       'Routine',
 272       'String',
 273       'action',
 274       'actor',
 275       'actors_location',
 276       'bold',
 277       'buffer',
 278       'consult_from',
 279       'consult_words',
 280       'false',
 281       'fixed',
 282       'location',
 283       'nothing',
 284       'noun',
 285       'off',
 286       'on',
 287       'player',
 288       'roman',
 289       'score',
 290       'second',
 291       'self',
 292       'sender',
 293       'the_time',
 294       'true',
 295       'underline',
 296       'wn',
 297    );
 298    $self->contextdata({
 299       'ClassDecl' => {
 300          callback => \&parseClassDecl,
 301          attribute => 'Normal Text',
 302          lineending => 'ClassDecl_1',
 303       },
 304       'ClassDecl_1' => {
 305          callback => \&parseClassDecl_1,
 306          attribute => 'Normal Text',
 307       },
 308       'Normal' => {
 309          callback => \&parseNormal,
 310          attribute => 'Normal Text',
 311       },
 312       'PropDefVal rules' => {
 313          callback => \&parsePropDefValrules,
 314          attribute => 'Normal Text',
 315       },
 316       'TopLevel' => {
 317          callback => \&parseTopLevel,
 318          attribute => 'Normal Text',
 319       },
 320       'comment' => {
 321          callback => \&parsecomment,
 322          attribute => 'Comment',
 323          lineending => '#pop',
 324       },
 325       'funcdef' => {
 326          callback => \&parsefuncdef,
 327          attribute => 'Normal Text',
 328       },
 329       'has_decl' => {
 330          callback => \&parsehas_decl,
 331          attribute => 'Normal Text',
 332       },
 333       'prop_def' => {
 334          callback => \&parseprop_def,
 335          attribute => 'Normal Text',
 336       },
 337       'prop_func_def' => {
 338          callback => \&parseprop_func_def,
 339          attribute => 'Normal Text',
 340       },
 341       'string' => {
 342          callback => \&parsestring,
 343          attribute => 'String',
 344       },
 345       'word' => {
 346          callback => \&parseword,
 347          attribute => 'Word',
 348          lineending => '#pop',
 349       },
 350    });
 351    $self->deliminators('\\s||\\.|\\(|\\)|:|\\!|\\+|,|-|<|=|>|\\%|\\&|\\*|\\/|;|\\?|\\[|\\]|\\^|\\{|\\||\\}|\\~|\\\\');
 352    $self->basecontext('TopLevel');
 353    $self->keywordscase(0);
 354    $self->initialize;
 355    bless ($self, $class);
 356    return $self;
 357 }
 358
 359 sub language {
 360    return 'Inform';
 361 }
 362
 363 sub parseClassDecl {
 364    my ($self, $text) = @_;
 365    # context => 'PropDefVal rules'
 366    # type => 'IncludeRules'
 367    if ($self->includeRules('PropDefVal rules', $text)) {
 368       return 1
 369    }
 370    return 0;
 371 };
 372
 373 sub parseClassDecl_1 {
 374    my ($self, $text) = @_;
 375    # String => '^[\t ]*has '
 376    # attribute => 'Keyword'
 377    # context => 'has_decl'
 378    # insensitive => 'TRUE'
 379    # type => 'RegExpr'
 380    if ($self->testRegExpr($text, '^[\\t ]*has ', 1, 0, 0, undef, 0, 'has_decl', 'Keyword')) {
 381       return 1
 382    }
 383    # String => 'ClassDeclOps'
 384    # attribute => 'Keyword'
 385    # context => '#stay'
 386    # type => 'keyword'
 387    if ($self->testKeyword($text, 'ClassDeclOps', 0, undef, 0, '#stay', 'Keyword')) {
 388       return 1
 389    }
 390    # String => '[a-zA-Z_]+\w*'
 391    # attribute => 'Function'
 392    # context => 'prop_def'
 393    # type => 'RegExpr'
 394    if ($self->testRegExpr($text, '[a-zA-Z_]+\\w*', 0, 0, 0, undef, 0, 'prop_def', 'Function')) {
 395       return 1
 396    }
 397    # attribute => 'Pragma'
 398    # char => ';'
 399    # context => '#pop'
 400    # endRegion => 'reg_class'
 401    # type => 'DetectChar'
 402    if ($self->testDetectChar($text, ';', 0, 0, 0, undef, 0, '#pop', 'Pragma')) {
 403       return 1
 404    }
 405    return 0;
 406 };
 407
 408 sub parseNormal {
 409    my ($self, $text) = @_;
 410    # attribute => 'Comment'
 411    # char => '!'
 412    # context => 'comment'
 413    # type => 'DetectChar'
 414    if ($self->testDetectChar($text, '!', 0, 0, 0, undef, 0, 'comment', 'Comment')) {
 415       return 1
 416    }
 417    # attribute => 'String'
 418    # char => '"'
 419    # context => 'string'
 420    # type => 'DetectChar'
 421    if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, 'string', 'String')) {
 422       return 1
 423    }
 424    # attribute => 'Word'
 425    # char => '''
 426    # context => 'word'
 427    # type => 'DetectChar'
 428    if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, 'word', 'Word')) {
 429       return 1
 430    }
 431    # String => 'inline_pragmas'
 432    # attribute => 'Pragma'
 433    # context => '#stay'
 434    # type => 'keyword'
 435    if ($self->testKeyword($text, 'inline_pragmas', 0, undef, 0, '#stay', 'Pragma')) {
 436       return 1
 437    }
 438    # String => '--?>'
 439    # attribute => 'Operator'
 440    # context => '#stay'
 441    # type => 'RegExpr'
 442    if ($self->testRegExpr($text, '--?>', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
 443       return 1
 444    }
 445    # String => 'keywords'
 446    # attribute => 'Keyword'
 447    # context => '#stay'
 448    # type => 'keyword'
 449    if ($self->testKeyword($text, 'keywords', 0, undef, 0, '#stay', 'Keyword')) {
 450       return 1
 451    }
 452    # String => 'actions'
 453    # attribute => 'Actions'
 454    # context => '#stay'
 455    # type => 'keyword'
 456    if ($self->testKeyword($text, 'actions', 0, undef, 0, '#stay', 'Actions')) {
 457       return 1
 458    }
 459    # String => 'functions'
 460    # attribute => 'PredefFunction'
 461    # context => '#stay'
 462    # type => 'keyword'
 463    if ($self->testKeyword($text, 'functions', 0, undef, 0, '#stay', 'PredefFunction')) {
 464       return 1
 465    }
 466    # String => 'special_vals'
 467    # attribute => 'Values'
 468    # context => '#stay'
 469    # type => 'keyword'
 470    if ($self->testKeyword($text, 'special_vals', 0, undef, 0, '#stay', 'Values')) {
 471       return 1
 472    }
 473    # String => 'operators'
 474    # attribute => 'Operator'
 475    # context => '#stay'
 476    # type => 'keyword'
 477    if ($self->testKeyword($text, 'operators', 0, undef, 0, '#stay', 'Operator')) {
 478       return 1
 479    }
 480    # String => '##[a-zA-Z_]+\w*'
 481    # attribute => 'Actions'
 482    # context => '#stay'
 483    # type => 'RegExpr'
 484    if ($self->testRegExpr($text, '##[a-zA-Z_]+\\w*', 0, 0, 0, undef, 0, '#stay', 'Actions')) {
 485       return 1
 486    }
 487    # String => '@[a-zA-Z_]+\w*'
 488    # attribute => 'OpCode'
 489    # context => '#stay'
 490    # type => 'RegExpr'
 491    if ($self->testRegExpr($text, '@[a-zA-Z_]+\\w*', 0, 0, 0, undef, 0, '#stay', 'OpCode')) {
 492       return 1
 493    }
 494    # String => '\$[0-9a-fA-F]{1,4}'
 495    # attribute => 'Number'
 496    # context => '#stay'
 497    # type => 'RegExpr'
 498    if ($self->testRegExpr($text, '\\$[0-9a-fA-F]{1,4}', 0, 0, 0, undef, 0, '#stay', 'Number')) {
 499       return 1
 500    }
 501    # String => '[a-zA-Z_]+\w*'
 502    # attribute => 'Normal Text'
 503    # context => '#stay'
 504    # type => 'RegExpr'
 505    if ($self->testRegExpr($text, '[a-zA-Z_]+\\w*', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
 506       return 1
 507    }
 508    # String => '\d+'
 509    # attribute => 'Number'
 510    # context => '#stay'
 511    # type => 'RegExpr'
 512    if ($self->testRegExpr($text, '\\d+', 0, 0, 0, undef, 0, '#stay', 'Number')) {
 513       return 1
 514    }
 515    # attribute => 'Keyword'
 516    # beginRegion => 'reg_compound'
 517    # char => '{'
 518    # context => '#stay'
 519    # type => 'DetectChar'
 520    if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
 521       return 1
 522    }
 523    # attribute => 'Keyword'
 524    # char => '}'
 525    # context => '#stay'
 526    # endRegion => 'reg_compound'
 527    # type => 'DetectChar'
 528    if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#stay', 'Keyword')) {
 529       return 1
 530    }
 531    # String => '%&()+-<=>{|}~'
 532    # attribute => 'Operator'
 533    # context => '#stay'
 534    # type => 'AnyChar'
 535    if ($self->testAnyChar($text, '%&()+-<=>{|}~', 0, 0, undef, 0, '#stay', 'Operator')) {
 536       return 1
 537    }
 538    return 0;
 539 };
 540
 541 sub parsePropDefValrules {
 542    my ($self, $text) = @_;
 543    # attribute => 'Comment'
 544    # char => '!'
 545    # context => 'comment'
 546    # type => 'DetectChar'
 547    if ($self->testDetectChar($text, '!', 0, 0, 0, undef, 0, 'comment', 'Comment')) {
 548       return 1
 549    }
 550    # attribute => 'String'
 551    # char => '"'
 552    # context => 'string'
 553    # type => 'DetectChar'
 554    if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, 'string', 'String')) {
 555       return 1
 556    }
 557    # attribute => 'Word'
 558    # char => '''
 559    # context => 'word'
 560    # type => 'DetectChar'
 561    if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, 'word', 'Word')) {
 562       return 1
 563    }
 564    # attribute => 'Function'
 565    # beginRegion => 'reg_prop_def_func'
 566    # char => '['
 567    # context => 'prop_func_def'
 568    # type => 'DetectChar'
 569    if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'prop_func_def', 'Function')) {
 570       return 1
 571    }
 572    # attribute => 'Operator'
 573    # char => ','
 574    # context => '#pop'
 575    # type => 'DetectChar'
 576    if ($self->testDetectChar($text, ',', 0, 0, 0, undef, 0, '#pop', 'Operator')) {
 577       return 1
 578    }
 579    # String => '\$[0-9a-fA-F]{1,4}'
 580    # attribute => 'Number'
 581    # context => '#stay'
 582    # type => 'RegExpr'
 583    if ($self->testRegExpr($text, '\\$[0-9a-fA-F]{1,4}', 0, 0, 0, undef, 0, '#stay', 'Number')) {
 584       return 1
 585    }
 586    # String => '\d+'
 587    # attribute => 'Number'
 588    # context => '#stay'
 589    # type => 'RegExpr'
 590    if ($self->testRegExpr($text, '\\d+', 0, 0, 0, undef, 0, '#stay', 'Number')) {
 591       return 1
 592    }
 593    return 0;
 594 };
 595
 596 sub parseTopLevel {
 597    my ($self, $text) = @_;
 598    # attribute => 'Comment'
 599    # char => '!'
 600    # context => 'comment'
 601    # type => 'DetectChar'
 602    if ($self->testDetectChar($text, '!', 0, 0, 0, undef, 0, 'comment', 'Comment')) {
 603       return 1
 604    }
 605    # attribute => 'String'
 606    # char => '"'
 607    # context => 'string'
 608    # type => 'DetectChar'
 609    if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, 'string', 'String')) {
 610       return 1
 611    }
 612    # String => '[[]\s*[a-zA-Z_]+\w*'
 613    # attribute => 'Function'
 614    # beginRegion => 'reg_function'
 615    # context => 'funcdef'
 616    # type => 'RegExpr'
 617    if ($self->testRegExpr($text, '[[]\\s*[a-zA-Z_]+\\w*', 0, 0, 0, undef, 0, 'funcdef', 'Function')) {
 618       return 1
 619    }
 620    # String => ' *object | *class '
 621    # attribute => 'Pragma'
 622    # beginRegion => 'reg_class'
 623    # column => '0'
 624    # context => 'ClassDecl'
 625    # insensitive => 'TRUE'
 626    # type => 'RegExpr'
 627    if ($self->testRegExpr($text, ' *object | *class ', 1, 0, 0, 0, 0, 'ClassDecl', 'Pragma')) {
 628       return 1
 629    }
 630    # String => 'pragmas'
 631    # attribute => 'Pragma'
 632    # context => '#stay'
 633    # type => 'keyword'
 634    if ($self->testKeyword($text, 'pragmas', 0, undef, 0, '#stay', 'Pragma')) {
 635       return 1
 636    }
 637    # String => 'inline_pragmas'
 638    # attribute => 'Pragma'
 639    # context => '#stay'
 640    # type => 'keyword'
 641    if ($self->testKeyword($text, 'inline_pragmas', 0, undef, 0, '#stay', 'Pragma')) {
 642       return 1
 643    }
 644    # String => '--?>'
 645    # attribute => 'Operator'
 646    # context => '#stay'
 647    # type => 'RegExpr'
 648    if ($self->testRegExpr($text, '--?>', 0, 0, 0, undef, 0, '#stay', 'Operator')) {
 649       return 1
 650    }
 651    # String => '[a-zA-Z_]+\d*'
 652    # attribute => 'Normal Text'
 653    # context => '#stay'
 654    # type => 'RegExpr'
 655    if ($self->testRegExpr($text, '[a-zA-Z_]+\\d*', 0, 0, 0, undef, 0, '#stay', 'Normal Text')) {
 656       return 1
 657    }
 658    # String => '\$[0-9a-fA-F]{1,4}'
 659    # attribute => 'Number'
 660    # context => '#stay'
 661    # type => 'RegExpr'
 662    if ($self->testRegExpr($text, '\\$[0-9a-fA-F]{1,4}', 0, 0, 0, undef, 0, '#stay', 'Number')) {
 663       return 1
 664    }
 665    # String => '\d+'
 666    # attribute => 'Number'
 667    # context => '#stay'
 668    # type => 'RegExpr'
 669    if ($self->testRegExpr($text, '\\d+', 0, 0, 0, undef, 0, '#stay', 'Number')) {
 670       return 1
 671    }
 672    return 0;
 673 };
 674
 675 sub parsecomment {
 676    my ($self, $text) = @_;
 677    return 0;
 678 };
 679
 680 sub parsefuncdef {
 681    my ($self, $text) = @_;
 682    # context => 'Normal'
 683    # type => 'IncludeRules'
 684    if ($self->includeRules('Normal', $text)) {
 685       return 1
 686    }
 687    # attribute => 'Function'
 688    # char => ']'
 689    # char1 => ';'
 690    # context => '#pop'
 691    # endRegion => 'reg_function'
 692    # type => 'Detect2Chars'
 693    if ($self->testDetect2Chars($text, ']', ';', 0, 0, 0, undef, 0, '#pop', 'Function')) {
 694       return 1
 695    }
 696    return 0;
 697 };
 698
 699 sub parsehas_decl {
 700    my ($self, $text) = @_;
 701    # attribute => 'Pragma'
 702    # char => ';'
 703    # context => '#pop#pop#pop'
 704    # endRegion => 'reg_class'
 705    # type => 'DetectChar'
 706    if ($self->testDetectChar($text, ';', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Pragma')) {
 707       return 1
 708    }
 709    # context => 'PropDefVal rules'
 710    # type => 'IncludeRules'
 711    if ($self->includeRules('PropDefVal rules', $text)) {
 712       return 1
 713    }
 714    return 0;
 715 };
 716
 717 sub parseprop_def {
 718    my ($self, $text) = @_;
 719    # attribute => 'Function'
 720    # char => ','
 721    # context => '#pop'
 722    # endRegion => 'reg_prop'
 723    # type => 'DetectChar'
 724    if ($self->testDetectChar($text, ',', 0, 0, 0, undef, 0, '#pop', 'Function')) {
 725       return 1
 726    }
 727    # attribute => 'Pragma'
 728    # char => ';'
 729    # context => '#pop#pop#pop'
 730    # endRegion => 'reg_class'
 731    # type => 'DetectChar'
 732    if ($self->testDetectChar($text, ';', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Pragma')) {
 733       return 1
 734    }
 735    # attribute => 'Function'
 736    # beginRegion => 'reg_prop_func'
 737    # char => '['
 738    # context => 'prop_func_def'
 739    # type => 'DetectChar'
 740    if ($self->testDetectChar($text, '[', 0, 0, 0, undef, 0, 'prop_func_def', 'Function')) {
 741       return 1
 742    }
 743    # context => 'PropDefVal rules'
 744    # type => 'IncludeRules'
 745    if ($self->includeRules('PropDefVal rules', $text)) {
 746       return 1
 747    }
 748    return 0;
 749 };
 750
 751 sub parseprop_func_def {
 752    my ($self, $text) = @_;
 753    # attribute => 'Function'
 754    # char => ']'
 755    # context => '#pop'
 756    # endRegion => 'reg_prop_func'
 757    # type => 'DetectChar'
 758    if ($self->testDetectChar($text, ']', 0, 0, 0, undef, 0, '#pop', 'Function')) {
 759       return 1
 760    }
 761    # context => 'Normal'
 762    # type => 'IncludeRules'
 763    if ($self->includeRules('Normal', $text)) {
 764       return 1
 765    }
 766    return 0;
 767 };
 768
 769 sub parsestring {
 770    my ($self, $text) = @_;
 771    # attribute => 'String'
 772    # char => '"'
 773    # context => '#pop'
 774    # type => 'DetectChar'
 775    if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, '#pop', 'String')) {
 776       return 1
 777    }
 778    return 0;
 779 };
 780
 781 sub parseword {
 782    my ($self, $text) = @_;
 783    # attribute => 'Word'
 784    # char => '''
 785    # context => '#pop'
 786    # type => 'DetectChar'
 787    if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, '#pop', 'Word')) {
 788       return 1
 789    }
 790    return 0;
 791 };
 792
 793
 794 1;
 795
 796 __END__
 797
 798 =head1 NAME
 799
 800 Syntax::Highlight::Engine::Kate::Inform - a Plugin for Inform syntax highlighting
 801
 802 =head1 SYNOPSIS
 803
 804  require Syntax::Highlight::Engine::Kate::Inform;
 805  my $sh = new Syntax::Highlight::Engine::Kate::Inform([
 806  ]);
 807
 808 =head1 DESCRIPTION
 809
 810 Syntax::Highlight::Engine::Kate::Inform is a  plugin module that provides syntax highlighting
 811 for Inform to the Syntax::Haghlight::Engine::Kate highlighting engine.
 812
 813 This code is generated from the syntax definition files used
 814 by the Kate project.
 815 It works quite fine, but can use refinement and optimization.
 816
 817 It inherits Syntax::Higlight::Engine::Kate::Template. See also there.
 818
 819 =cut
 820
 821 =head1 AUTHOR
 822
 823 Hans Jeuken (haje <at> toneel <dot> demon <dot> nl)
 824
 825 =cut
 826
 827 =head1 BUGS
 828
 829 Unknown. If you find any, please contact the author
 830
 831 =cut
 832