Syntax::Highlight::Engine::Kate::Xslt - a Plugin for xslt syntax highlighting
Index
Code Index:
NAME
Syntax::Highlight::Engine::Kate::Xslt - a Plugin for xslt syntax highlighting
SYNOPSIS
require Syntax::Highlight::Engine::Kate::Xslt;
my $sh = new Syntax::Highlight::Engine::Kate::Xslt([
]);
DESCRIPTION
Syntax::Highlight::Engine::Kate::Xslt is a plugin module that provides syntax highlighting
for xslt 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.
AUTHOR
Hans Jeuken (haje <at> toneel <dot> demon <dot> nl)
BUGS
Unknown. If you find any, please contact the author
# 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 'xslt.xml' file of the syntax highlight
# engine of the kate text editor (http://www.kate-editor.org
#kate xml version 1.03
#kate version 2.1
#kate author Peter Lammich (views@gmx.de)
#generated: Sun Feb 3 22:02:06 2008, localtime
package Syntax::Highlight::Engine::Kate::Xslt;
our $VERSION = '0.06';
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({
'Alert' => 'Alert',
'Attribute' => 'Others',
'Attribute Value' => 'BaseN',
'Comment' => 'Comment',
'Entity Reference' => 'Char',
'Invalid' => 'Error',
'Normal Text' => 'Normal',
'Tag' => 'Keyword',
'Variable' => 'Variable',
'XPath' => 'Others',
'XPath 2.0/ XSLT 2.0 Function' => 'Operator',
'XPath Attribute' => 'Float',
'XPath Axis' => 'DecVal',
'XPath String' => 'BaseN',
'XPath/ XSLT Function' => 'Function',
'XSLT 2.0 Tag' => 'Reserved',
'XSLT Tag' => 'Reserved',
});
$self->listAdd('functions',
'boolean',
'ceiling',
'concat',
'contains',
'count',
'current',
'document',
'element-available',
'false',
'floor',
'format-number',
'function-available',
'generate-id',
'id',
'key',
'lang',
'last',
'local-name',
'name',
'namespace-uri',
'normalize-space',
'not',
'number',
'position',
'round',
'starts-with',
'string',
'string-length',
'substring',
'substring-after',
'substring-before',
'sum',
'system-property',
'text',
'translate',
'true',
'unparsed-entity-uri',
);
$self->listAdd('functions_2.0',
'QName',
'abs',
'adjust-date-to-timezone',
'adjust-dateTime-to-timezone',
'adjust-time-to-timezone',
'avg',
'base-uri',
'codepoints-to-string',
'collection',
'compare',
'current-date',
'current-dateTime',
'current-group',
'current-grouping-key',
'current-time',
'data',
'dateTime',
'day-from-date',
'day-from-dateTime',
'days-from-duration',
'deep-equal',
'default-collation',
'distinct-values',
'doc',
'document-uri',
'empty',
'ends-with',
'error',
'escape-uri',
'exactly-one',
'exists',
'expanded-QName',
'format-date',
'format-dateTime',
'format-time',
'hours-from-dateTime',
'hours-from-duration',
'hours-from-time',
'idref',
'implicit-timezone',
'in-scope-prefixes',
'index-of',
'input',
'insert-before',
'local-name-from-QName',
'lower-case',
'matches',
'max',
'min',
'minutes-from-dateTime',
'minutes-from-duration',
'minutes-from-time',
'month-from-date',
'month-from-dateTime',
'months-from-duration',
'namespace-uri-for-prefix',
'namespace-uri-from-QName',
'node-kind',
'node-name',
'normalize-unicode',
'one-or-more',
'regex-group',
'remove',
'replace',
'resolve-QName',
'resolve-uri',
'reverse',
'root',
'round-half-to-even',
'seconds-from-dateTime',
'seconds-from-duration',
'seconds-from-time',
'sequence-node-identical',
'static-base-uri',
'string-join',
'string-to-codepoints',
'subsequence',
'subtract-dateTimes-yielding-dayTimeDuration',
'subtract-dateTimes-yielding-yearMonthDuration',
'subtract-dates-yielding-dayTimeDuration',
'subtract-dates-yielding-yearMonthDuration',
'timezone-from-date',
'timezone-from-dateTime',
'timezone-from-time',
'tokenize',
'trace',
'unordered',
'unparsed-entity-public-id',
'unparsed-text',
'upper-case',
'year-from-date',
'year-from-dateTime',
'years-from-duration',
'zero-or-one',
);
$self->listAdd('keytags',
'xsl:apply-imports',
'xsl:apply-templates',
'xsl:attribute',
'xsl:attribute-set',
'xsl:call-template',
'xsl:choose',
'xsl:comment',
'xsl:copy',
'xsl:copy-of',
'xsl:decimal-format',
'xsl:element',
'xsl:fallback',
'xsl:for-each',
'xsl:if',
'xsl:import',
'xsl:include',
'xsl:key',
'xsl:message',
'xsl:namespace-alias',
'xsl:number',
'xsl:otherwise',
'xsl:output',
'xsl:param',
'xsl:preserve-space',
'xsl:processing-instruction',
'xsl:sort',
'xsl:strip-space',
'xsl:stylesheet',
'xsl:template',
'xsl:text',
'xsl:transform',
'xsl:value-of',
'xsl:variable',
'xsl:when',
'xsl:with-param',
);
$self->listAdd('keytags_2.0',
'xsl:analyze-string',
'xsl:character-map',
'xsl:document',
'xsl:for-each-group',
'xsl:function',
'xsl:import-schema',
'xsl:matching-substring',
'xsl:namespace',
'xsl:next-match',
'xsl:non-matching-substring',
'xsl:output-character',
'xsl:perform-sort',
'xsl:result-document',
'xsl:sequence',
);
$self->contextdata({
'attrValue' => {
callback => \&parseattrValue,
attribute => 'Invalid',
},
'attributes' => {
callback => \&parseattributes,
attribute => 'Attribute',
},
'comment' => {
callback => \&parsecomment,
attribute => 'Comment',
},
'detectEntRef' => {
callback => \&parsedetectEntRef,
attribute => 'Normal Text',
},
'normalText' => {
callback => \&parsenormalText,
attribute => 'Normal Text',
},
'sqstring' => {
callback => \&parsesqstring,
attribute => 'Attribute Value',
},
'sqxpath' => {
callback => \&parsesqxpath,
attribute => 'XPath',
},
'sqxpathstring' => {
callback => \&parsesqxpathstring,
attribute => 'XPath String',
},
'string' => {
callback => \&parsestring,
attribute => 'Attribute Value',
},
'tagname' => {
callback => \&parsetagname,
attribute => 'Tag',
},
'xattrValue' => {
callback => \&parsexattrValue,
attribute => 'Invalid',
},
'xattributes' => {
callback => \&parsexattributes,
attribute => 'Attribute',
},
'xpath' => {
callback => \&parsexpath,
attribute => 'XPath',
},
'xpathstring' => {
callback => \&parsexpathstring,
attribute => 'XPath String',
},
});
$self->deliminators('\\s||\\.|\\(|\\)|\\!|\\+|,|<|=|>|\\%|\\&|\\*|\\/|;|\\?|\\[|\\]|\\^|\\{|\\||\\}|\\~|\\\\|-|:');
$self->basecontext('normalText');
$self->keywordscase(0);
$self->initialize;
bless ($self, $class);
return $self;
}
sub language {
return 'xslt';
}
sub parseattrValue {
my ($self, $text) = @_;
# attribute => 'Invalid'
# char => '/'
# char1 => '>'
# context => '#pop#pop#pop'
# type => 'Detect2Chars'
if ($self->testDetect2Chars($text, '/', '>', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Invalid')) {
return 1
}
# attribute => 'Invalid'
# char => '>'
# context => '#pop#pop#pop'
# type => 'DetectChar'
if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Invalid')) {
return 1
}
# attribute => 'Attribute Value'
# char => '"'
# context => 'string'
# type => 'DetectChar'
if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, 'string', 'Attribute Value')) {
return 1
}
# attribute => 'Attribute Value'
# char => '''
# context => 'sqstring'
# type => 'DetectChar'
if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, 'sqstring', 'Attribute Value')) {
return 1
}
return 0;
};
sub parseattributes {
my ($self, $text) = @_;
# attribute => 'Tag'
# char => '/'
# char1 => '>'
# context => '#pop#pop'
# type => 'Detect2Chars'
if ($self->testDetect2Chars($text, '/', '>', 0, 0, 0, undef, 0, '#pop#pop', 'Tag')) {
return 1
}
# attribute => 'Tag'
# char => '>'
# context => '#pop#pop'
# type => 'DetectChar'
if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop#pop', 'Tag')) {
return 1
}
# String => '\s*=\s*'
# attribute => 'Normal Text'
# context => 'attrValue'
# type => 'RegExpr'
if ($self->testRegExpr($text, '\\s*=\\s*', 0, 0, 0, undef, 0, 'attrValue', 'Normal Text')) {
return 1
}
return 0;
};
sub parsecomment {
my ($self, $text) = @_;
# String => '-->'
# attribute => 'Comment'
# context => '#pop'
# endRegion => 'comment'
# type => 'StringDetect'
if ($self->testStringDetect($text, '-->', 0, 0, 0, undef, 0, '#pop', 'Comment')) {
return 1
}
# String => '-(-(?!->))+'
# attribute => 'Invalid'
# context => '#stay'
# type => 'RegExpr'
if ($self->testRegExpr($text, '-(-(?!->))+', 0, 0, 0, undef, 0, '#stay', 'Invalid')) {
return 1
}
# String => '(FIXME|TODO|HACK)'
# attribute => 'Alert'
# context => '#stay'
# type => 'RegExpr'
if ($self->testRegExpr($text, '(FIXME|TODO|HACK)', 0, 0, 0, undef, 0, '#stay', 'Alert')) {
return 1
}
return 0;
};
sub parsedetectEntRef {
my ($self, $text) = @_;
# String => '&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\w.:_-]*);'
# attribute => 'Entity Reference'
# context => '#stay'
# type => 'RegExpr'
if ($self->testRegExpr($text, '&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);', 0, 0, 0, undef, 0, '#stay', 'Entity Reference')) {
return 1
}
return 0;
};
sub parsenormalText {
my ($self, $text) = @_;
# String => '<!--'
# attribute => 'Comment'
# beginRegion => 'comment'
# context => 'comment'
# type => 'StringDetect'
if ($self->testStringDetect($text, '<!--', 0, 0, 0, undef, 0, 'comment', 'Comment')) {
return 1
}
# attribute => 'Tag'
# char => '<'
# context => 'tagname'
# type => 'DetectChar'
if ($self->testDetectChar($text, '<', 0, 0, 0, undef, 0, 'tagname', 'Tag')) {
return 1
}
# String => '&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\w.:_-]*);'
# attribute => 'Entity Reference'
# context => '#stay'
# type => 'RegExpr'
if ($self->testRegExpr($text, '&(#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z_:][\\w.:_-]*);', 0, 0, 0, undef, 0, '#stay', 'Entity Reference')) {
return 1
}
return 0;
};
sub parsesqstring {
my ($self, $text) = @_;
# attribute => 'XPath'
# char => '{'
# context => 'sqxpath'
# type => 'DetectChar'
if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'sqxpath', 'XPath')) {
return 1
}
# attribute => 'Attribute Value'
# char => '''
# context => '#pop#pop'
# type => 'DetectChar'
if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, '#pop#pop', 'Attribute Value')) {
return 1
}
# context => 'detectEntRef'
# type => 'IncludeRules'
if ($self->includeRules('detectEntRef', $text)) {
return 1
}
return 0;
};
sub parsesqxpath {
my ($self, $text) = @_;
# String => 'functions'
# attribute => 'XPath/ XSLT Function'
# context => '#stay'
# type => 'keyword'
if ($self->testKeyword($text, 'functions', 0, undef, 0, '#stay', 'XPath/ XSLT Function')) {
return 1
}
# String => 'functions_2.0'
# attribute => 'XPath 2.0/ XSLT 2.0 Function'
# context => '#stay'
# type => 'keyword'
if ($self->testKeyword($text, 'functions_2.0', 0, undef, 0, '#stay', 'XPath 2.0/ XSLT 2.0 Function')) {
return 1
}
# String => '(ancestor|ancestor-or-self|attribute|child|descendant|descendant-or-self|following|following-sibling|namespace|parent|preceding|preceding-sibling|self)::'
# attribute => 'XPath Axis'
# context => '#stay'
# type => 'RegExpr'
if ($self->testRegExpr($text, '(ancestor|ancestor-or-self|attribute|child|descendant|descendant-or-self|following|following-sibling|namespace|parent|preceding|preceding-sibling|self)::', 0, 0, 0, undef, 0, '#stay', 'XPath Axis')) {
return 1
}
# attribute => 'XPath'
# char => '}'
# context => '#pop'
# type => 'DetectChar'
if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop', 'XPath')) {
return 1
}
# attribute => 'XPath String'
# char => '"'
# context => 'xpathstring'
# type => 'DetectChar'
if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, 'xpathstring', 'XPath String')) {
return 1
}
# attribute => 'XPath'
# char => '''
# context => '#pop#pop'
# type => 'DetectChar'
if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, '#pop#pop', 'XPath')) {
return 1
}
# String => '@[A-Za-z_:][\w.:_-]*'
# attribute => 'XPath Attribute'
# context => '#stay'
# type => 'RegExpr'
if ($self->testRegExpr($text, '@[A-Za-z_:][\\w.:_-]*', 0, 0, 0, undef, 0, '#stay', 'XPath Attribute')) {
return 1
}
# String => '\$[A-Za-z_:][\w.:_-]*'
# attribute => 'Variable'
# context => '#stay'
# type => 'RegExpr'
if ($self->testRegExpr($text, '\\$[A-Za-z_:][\\w.:_-]*', 0, 0, 0, undef, 0, '#stay', 'Variable')) {
return 1
}
# String => '[A-Za-z_:][\w.:_-]*'
# attribute => 'XPath'
# context => '#stay'
# type => 'RegExpr'
if ($self->testRegExpr($text, '[A-Za-z_:][\\w.:_-]*', 0, 0, 0, undef, 0, '#stay', 'XPath')) {
return 1
}
# attribute => 'Invalid'
# char => '$'
# context => '#stay'
# type => 'DetectChar'
if ($self->testDetectChar($text, '$', 0, 0, 0, undef, 0, '#stay', 'Invalid')) {
return 1
}
# context => 'detectEntRef'
# type => 'IncludeRules'
if ($self->includeRules('detectEntRef', $text)) {
return 1
}
return 0;
};
sub parsesqxpathstring {
my ($self, $text) = @_;
# attribute => 'XPath String'
# char => '''
# context => '#pop'
# type => 'DetectChar'
if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, '#pop', 'XPath String')) {
return 1
}
# context => 'detectEntRef'
# type => 'IncludeRules'
if ($self->includeRules('detectEntRef', $text)) {
return 1
}
return 0;
};
sub parsestring {
my ($self, $text) = @_;
# attribute => 'XPath'
# char => '{'
# context => 'xpath'
# type => 'DetectChar'
if ($self->testDetectChar($text, '{', 0, 0, 0, undef, 0, 'xpath', 'XPath')) {
return 1
}
# attribute => 'Attribute Value'
# char => '"'
# context => '#pop#pop'
# type => 'DetectChar'
if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, '#pop#pop', 'Attribute Value')) {
return 1
}
# context => 'detectEntRef'
# type => 'IncludeRules'
if ($self->includeRules('detectEntRef', $text)) {
return 1
}
return 0;
};
sub parsetagname {
my ($self, $text) = @_;
# String => 'keytags'
# attribute => 'XSLT Tag'
# context => 'xattributes'
# type => 'keyword'
if ($self->testKeyword($text, 'keytags', 0, undef, 0, 'xattributes', 'XSLT Tag')) {
return 1
}
# String => 'keytags_2.0'
# attribute => 'XSLT 2.0 Tag'
# context => 'xattributes'
# type => 'keyword'
if ($self->testKeyword($text, 'keytags_2.0', 0, undef, 0, 'xattributes', 'XSLT 2.0 Tag')) {
return 1
}
# String => '\s*'
# attribute => 'Attribute'
# context => 'attributes'
# type => 'RegExpr'
if ($self->testRegExpr($text, '\\s*', 0, 0, 0, undef, 0, 'attributes', 'Attribute')) {
return 1
}
# attribute => 'Tag'
# char => '>'
# context => '#pop'
# type => 'DetectChar'
if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop', 'Tag')) {
return 1
}
return 0;
};
sub parsexattrValue {
my ($self, $text) = @_;
# attribute => 'Invalid'
# char => '/'
# char1 => '>'
# context => '#pop#pop#pop'
# type => 'Detect2Chars'
if ($self->testDetect2Chars($text, '/', '>', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Invalid')) {
return 1
}
# attribute => 'Invalid'
# char => '>'
# context => '#pop#pop#pop'
# type => 'DetectChar'
if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop#pop#pop', 'Invalid')) {
return 1
}
# attribute => 'XPath'
# char => '"'
# context => 'xpath'
# type => 'DetectChar'
if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, 'xpath', 'XPath')) {
return 1
}
# attribute => 'XPath'
# char => '''
# context => 'sqxpath'
# type => 'DetectChar'
if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, 'sqxpath', 'XPath')) {
return 1
}
return 0;
};
sub parsexattributes {
my ($self, $text) = @_;
# attribute => 'Tag'
# char => '/'
# char1 => '>'
# context => '#pop#pop'
# type => 'Detect2Chars'
if ($self->testDetect2Chars($text, '/', '>', 0, 0, 0, undef, 0, '#pop#pop', 'Tag')) {
return 1
}
# attribute => 'Tag'
# char => '>'
# context => '#pop#pop'
# type => 'DetectChar'
if ($self->testDetectChar($text, '>', 0, 0, 0, undef, 0, '#pop#pop', 'Tag')) {
return 1
}
# String => 'select\s*=\s*'
# attribute => 'Attribute'
# context => 'xattrValue'
# type => 'RegExpr'
if ($self->testRegExpr($text, 'select\\s*=\\s*', 0, 0, 0, undef, 0, 'xattrValue', 'Attribute')) {
return 1
}
# String => 'test\s*=\s*'
# attribute => 'Attribute'
# context => 'xattrValue'
# type => 'RegExpr'
if ($self->testRegExpr($text, 'test\\s*=\\s*', 0, 0, 0, undef, 0, 'xattrValue', 'Attribute')) {
return 1
}
# String => 'match\s*=\s*'
# attribute => 'Attribute'
# context => 'xattrValue'
# type => 'RegExpr'
if ($self->testRegExpr($text, 'match\\s*=\\s*', 0, 0, 0, undef, 0, 'xattrValue', 'Attribute')) {
return 1
}
# String => '\s*=\s*'
# attribute => 'Attribute'
# context => 'attrValue'
# type => 'RegExpr'
if ($self->testRegExpr($text, '\\s*=\\s*', 0, 0, 0, undef, 0, 'attrValue', 'Attribute')) {
return 1
}
return 0;
};
sub parsexpath {
my ($self, $text) = @_;
# String => 'functions'
# attribute => 'XPath/ XSLT Function'
# context => '#stay'
# type => 'keyword'
if ($self->testKeyword($text, 'functions', 0, undef, 0, '#stay', 'XPath/ XSLT Function')) {
return 1
}
# String => 'functions_2.0'
# attribute => 'XPath 2.0/ XSLT 2.0 Function'
# context => '#stay'
# type => 'keyword'
if ($self->testKeyword($text, 'functions_2.0', 0, undef, 0, '#stay', 'XPath 2.0/ XSLT 2.0 Function')) {
return 1
}
# String => '(ancestor|ancestor-or-self|attribute|child|descendant|descendant-or-self|following|following-sibling|namespace|parent|preceding|preceding-sibling|self)::'
# attribute => 'XPath Axis'
# context => '#stay'
# type => 'RegExpr'
if ($self->testRegExpr($text, '(ancestor|ancestor-or-self|attribute|child|descendant|descendant-or-self|following|following-sibling|namespace|parent|preceding|preceding-sibling|self)::', 0, 0, 0, undef, 0, '#stay', 'XPath Axis')) {
return 1
}
# attribute => 'XPath'
# char => '}'
# context => '#pop'
# type => 'DetectChar'
if ($self->testDetectChar($text, '}', 0, 0, 0, undef, 0, '#pop', 'XPath')) {
return 1
}
# attribute => 'XPath String'
# char => '''
# context => 'sqxpathstring'
# type => 'DetectChar'
if ($self->testDetectChar($text, '\'', 0, 0, 0, undef, 0, 'sqxpathstring', 'XPath String')) {
return 1
}
# attribute => 'XPath'
# char => '"'
# context => '#pop#pop'
# type => 'DetectChar'
if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, '#pop#pop', 'XPath')) {
return 1
}
# String => '@[A-Za-z_:][\w.:_-]*'
# attribute => 'XPath Attribute'
# context => '#stay'
# type => 'RegExpr'
if ($self->testRegExpr($text, '@[A-Za-z_:][\\w.:_-]*', 0, 0, 0, undef, 0, '#stay', 'XPath Attribute')) {
return 1
}
# String => '\$[A-Za-z_:][\w.:_-]*'
# attribute => 'Variable'
# context => '#stay'
# type => 'RegExpr'
if ($self->testRegExpr($text, '\\$[A-Za-z_:][\\w.:_-]*', 0, 0, 0, undef, 0, '#stay', 'Variable')) {
return 1
}
# String => '[A-Za-z_:][\w.:_-]*'
# attribute => 'XPath'
# context => '#stay'
# type => 'RegExpr'
if ($self->testRegExpr($text, '[A-Za-z_:][\\w.:_-]*', 0, 0, 0, undef, 0, '#stay', 'XPath')) {
return 1
}
# attribute => 'Invalid'
# char => '$'
# context => '#stay'
# type => 'DetectChar'
if ($self->testDetectChar($text, '$', 0, 0, 0, undef, 0, '#stay', 'Invalid')) {
return 1
}
# context => 'detectEntRef'
# type => 'IncludeRules'
if ($self->includeRules('detectEntRef', $text)) {
return 1
}
return 0;
};
sub parsexpathstring {
my ($self, $text) = @_;
# attribute => 'XPath String'
# char => '"'
# context => '#pop'
# type => 'DetectChar'
if ($self->testDetectChar($text, '"', 0, 0, 0, undef, 0, '#pop', 'XPath String')) {
return 1
}
# context => 'detectEntRef'
# type => 'IncludeRules'
if ($self->includeRules('detectEntRef', $text)) {
return 1
}
return 0;
};
1;
__END__