jEdit example source code file (perl.xml)

This example jEdit source code file (perl.xml) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - jEdit tags/keywords

begin, end, keyword1, keyword3, keyword3, literal1, operator, operator, seq, seq, span, true, type, type

The jEdit perl.xml source code

<?xml version="1.0"?>

<!DOCTYPE MODE SYSTEM "xmode.dtd">

<MODE>
	<PROPS>
		<PROPERTY NAME="lineComment" VALUE="#" />
		<PROPERTY NAME="indentOpenBrackets" VALUE="{" />
		<PROPERTY NAME="indentCloseBrackets" VALUE="}" />
		<PROPERTY NAME="unalignedOpenBrackets" VALUE="(" />
		<PROPERTY NAME="unalignedCloseBrackets" VALUE=")" />
		<PROPERTY NAME="indentNextLine" VALUE="[^#]*\.\s*$" />
	</PROPS>

	<!-- no ESCAPE char because we need the backslash for references -->
	<RULES HIGHLIGHT_DIGITS="TRUE" IGNORE_CASE="FALSE">
		<!-- Comments -->
		<EOL_SPAN TYPE="COMMENT1">#

		<!-- TYPE is LABEL so that =head1 and =cut are highlighted as so -->
		<SPAN TYPE="LABEL" DELEGATE="POD" AT_LINE_START="TRUE">
			<BEGIN>=head1
			<END>=cut
		</SPAN>
		<SPAN AT_LINE_START="TRUE" TYPE="LABEL" DELEGATE="POD">
			<BEGIN>=head2
			<END>=cut
		</SPAN>
        <SPAN TYPE="LABEL" DELEGATE="POD" AT_LINE_START="TRUE">
			<BEGIN>=head3
			<END>=cut
		</SPAN>
		<SPAN  AT_LINE_START="TRUE" TYPE="LABEL" DELEGATE="POD">
			<BEGIN>=head4
			<END>=cut
		</SPAN>
		<SPAN TYPE="LABEL"  AT_LINE_START="TRUE" DELEGATE="POD">
			<BEGIN>=item
			<END>=cut
		</SPAN>
		<SPAN  AT_LINE_START="TRUE" TYPE="LABEL" DELEGATE="POD">
			<BEGIN>=over
			<END>=cut
		</SPAN>
		<SPAN TYPE="LABEL" DELEGATE="POD" AT_LINE_START="TRUE">
			<BEGIN>=back
			<END>=cut
		</SPAN>
		<SPAN AT_LINE_START="TRUE" TYPE="LABEL" DELEGATE="POD">
			<BEGIN>=pod
			<END>=cut
		</SPAN>
		<SPAN TYPE="LABEL" DELEGATE="POD"  AT_LINE_START="TRUE">
			<BEGIN>=for
			<END>=cut
		</SPAN>
		<SPAN TYPE="LABEL" DELEGATE="POD" AT_LINE_START="TRUE">
			<BEGIN>=begin
			<END>=cut
		</SPAN>
		<SPAN AT_LINE_START="TRUE" TYPE="LABEL" DELEGATE="POD">
			<BEGIN>=end
			<END>=cut
		</SPAN>

		<!-- Some other things that confuse the mode file. -->
		<SEQ TYPE="OPERATOR">*"
		<SEQ TYPE="OPERATOR">*'
		<SEQ TYPE="OPERATOR">&"
		<SEQ TYPE="OPERATOR">&'

		<SPAN TYPE="KEYWORD2" NO_LINE_BREAK="TRUE" DELEGATE="VARIABLE">
			<BEGIN>${
			<END>}
		</SPAN>

		<!-- Scalar variables -->
		<SEQ_REGEXP HASH_CHAR="$" TYPE="KEYWORD2">\$#?((\p{Alpha}\w*|_\w+)?::)*(\p{Alpha}\w*|_\w+|\d+)

		<!-- Array variables -->
		<SEQ_REGEXP HASH_CHAR="@" TYPE="KEYWORD2">@((\p{Alpha}\w*|_\w+)?::)*(\p{Alpha}\w*|_\w+|\d+)

		<!-- Associative Array (= Hash) variables -->
		<SEQ_REGEXP HASH_CHAR="%" TYPE="KEYWORD2">%((\p{Alpha}\w*|_\w+)?::)*(\p{Alpha}\w*|_\w+|\d+)

		<!-- Dereferences -->
		<SEQ_REGEXP HASH_CHAR="$$" TYPE="KEYWORD4">\$\$+((\p{Alpha}\w*|_\w+)?::)*(\p{Alpha}\w*|_\w+|\d+)
		<SEQ_REGEXP HASH_CHAR="@$" TYPE="KEYWORD4">@\$((\p{Alpha}\w*|_\w+)?::)*(\p{Alpha}\w*|_\w+|\d+)
		<SEQ_REGEXP HASH_CHAR="%$" TYPE="KEYWORD4">%\$((\p{Alpha}\w*|_\w+)?::)*(\p{Alpha}\w*|_\w+|\d+)
		<SEQ_REGEXP HASH_CHAR="*" TYPE="KEYWORD4">\*((\p{Alpha}\w*|_\w+)?::)*(\p{Alpha}\w*|_\w+|\d+)

		<!-- Perl predefined variables -->
		<SEQ_REGEXP HASH_CHAR="$^" TYPE="KEYWORD2">\$\^\p{Alpha}
		<SEQ_REGEXP HASH_CHAR="$" TYPE="KEYWORD2">\$\p{Punct}

		<!-- references to vars and code, starting with a backslash -->
		<SEQ_REGEXP HASH_CHAR="\" TYPE="KEYWORD4">\\[@%\$&]((\p{Alpha}\w*|_\w+)?::)*(\p{Alpha}\w*|_\w+|\d+)

		<!-- complex code dereference -->
		<SPAN TYPE="KEYWORD4" NO_LINE_BREAK="TRUE" DELEGATE="MAIN">
			<BEGIN>&{
			<END>}
		</SPAN>

		<!-- Function calls from variables -->
		<SEQ_REGEXP HASH_CHAR="&$" TYPE="FUNCTION">&\$((\p{Alpha}\w*|_\w+)?::)*(\p{Alpha}\w*|_\w+|\d+)

		<!-- Highlight calls to subs that contain ' in the name. -->
		<SEQ_REGEXP HASH_CHAR="&" TYPE="FUNCTION"
		>&\p{Alpha}[\p{Alnum}_]*'\p{Alpha}[\p{Alnum}_]*</SEQ_REGEXP>

		<!-- Literals -->
		<SPAN TYPE="LITERAL1" DELEGATE="LITERAL">
			<BEGIN>"
			<END>"
		</SPAN>

		<!-- apostrophe literals -->
		<SPAN TYPE="LITERAL1" DELEGATE="APOSTR">
			<BEGIN>'
			<END>'
		</SPAN>
		<SEQ_REGEXP TYPE="LITERAL1">\b\w+\b(?=\s*=>)

		<!-- options: -text -->
		<SEQ_REGEXP HASH_CHAR="-" TYPE="LITERAL1">-[\p{Lower}]\w+

		<!-- file stat expressions -->
		<SEQ_REGEXP HASH_CHAR="-" TYPE="KEYWORD3">-[\p{Lower}]

		<!-- non-quoted literals in hashes -->
		<SPAN_REGEXP TYPE="OPERATOR" HASH_CHAR="{" NO_LINE_BREAK="TRUE" DELEGATE="LITERAL">
			<BEGIN>\{(?=\s*[\p{Alpha}_\-][\p{Alnum}_]*\s*\})
			<END>}
		</SPAN_REGEXP>

		<!-- Code blocks. This is a hack to correctly highlight some
			 complex expressions that can have arbitrary perl code
			 inside brackets (like array deferences below). Declaring
			 this *before* the other rules is needed to maintain
			 correct bracket matching.
		-->
		<SPAN TYPE="OPERATOR" NO_LINE_BREAK="FALSE" DELEGATE="MAIN">
			<BEGIN>{
			<END>}
		</SPAN>

		<!-- Array dereference -->
		<SPAN TYPE="KEYWORD4" NO_LINE_BREAK="TRUE" DELEGATE="MAIN">
			<BEGIN>@{
			<END>}
		</SPAN>

		<!-- Hash dereference -->
		<SPAN TYPE="KEYWORD4" NO_LINE_BREAK="TRUE" DELEGATE="MAIN">
			<BEGIN>%{
			<END>}
		</SPAN>

		<!-- labels, catches also package prefixes at line start :( -->
		<MARK_PREVIOUS TYPE="LABEL" AT_LINE_START="TRUE" MATCH_TYPE="OPERATOR">:

		<!-- __DATA__ and similar -->
		<SEQ_REGEXP HASH_CHAR="__" TYPE="KEYWORD4">__\w+__

		<!-- Exec -->
		<SPAN TYPE="KEYWORD3" DELEGATE="EXEC">
			<BEGIN>`
			<END>`
		</SPAN>

		<!-- file globs / IO operators -->
		<SEQ_REGEXP HASH_CHAR="<" TYPE="KEYWORD4"><[\p{Punct}\p{Alnum}_]*>

		<!-- Heredoc -->
		<SPAN_REGEXP HASH_CHAR="<<" TYPE="LITERAL2" DELEGATE="LITERAL">
		<BEGIN>
		<END AT_LINE_START="TRUE">$2
		</SPAN_REGEXP>
		<SPAN_REGEXP HASH_CHAR="<<" TYPE="LITERAL2" DELEGATE="LITERAL">
		<BEGIN>
		<END AT_LINE_START="TRUE">$1
		</SPAN_REGEXP>

		<!-- jEdit 4.1 adds regular expression syntax rules so we can
		     highlight this sort of crap. -->

		<!-- /Regexp/, avoid confusion with a sequence of two divisions! -->
		<SEQ_REGEXP TYPE="MARKUP" HASH_CHAR="/"
			AT_WORD_START="TRUE">/.*?[^\\]/([cgimosx]+\b|(?=[^cgimosx])|$)(?!\s*[\d\$\@\(\{\-A-Z"'])</SEQ_REGEXP>

		<!-- q//, qq//, qx// -->
		<SPAN_REGEXP HASH_CHAR="q"
					 TYPE="LITERAL1"
					 ESCAPE="\"
					 MATCH_TYPE="OPERATOR"
					 AT_WORD_START="TRUE"
					 NO_LINE_BREAK="FALSE">
			<BEGIN>q[qxw]?([#/\|!])
			<END>~1
		</SPAN_REGEXP>
		<SPAN_REGEXP HASH_CHAR="q"
					 MATCH_TYPE="OPERATOR"
					 DELEGATE="QUOTED_BRACKET"
					 AT_WORD_START="TRUE"
					 NO_LINE_BREAK="FALSE">
			<BEGIN>q[qxw]?(\[)
			<END>~1
		</SPAN_REGEXP>
		<SPAN_REGEXP HASH_CHAR="q"
					 MATCH_TYPE="OPERATOR"
					 DELEGATE="QUOTED_BRACE"
					 AT_WORD_START="TRUE"
					 NO_LINE_BREAK="FALSE">
			<BEGIN>q[qxw]?(\{)
			<END>~1
		</SPAN_REGEXP>
		<SPAN_REGEXP HASH_CHAR="q"
					 MATCH_TYPE="OPERATOR"
					 DELEGATE="QUOTED_PAREN"
					 AT_WORD_START="TRUE"
					 NO_LINE_BREAK="FALSE">
			<BEGIN>q[qxw]?(\()
			<END>~1
		</SPAN_REGEXP>

		<!-- qr// should match other regex highlight colors -->
		<SPAN_REGEXP HASH_CHAR="q"
					 ESCAPE="\"
					 TYPE="LITERAL1"
					 MATCH_TYPE="OPERATOR"
					 AT_WORD_START="TRUE"
					 NO_LINE_BREAK="FALSE">
			<BEGIN>qr([#/\|!])
			<END>~1
		</SPAN_REGEXP>
		<SPAN_REGEXP HASH_CHAR="q"
					 DELEGATE="QUOTED_BRACKET"
					 MATCH_TYPE="OPERATOR"
					 AT_WORD_START="TRUE"
					 NO_LINE_BREAK="FALSE">
			<BEGIN>qr(\[)
			<END>~1
		</SPAN_REGEXP>
		<SPAN_REGEXP HASH_CHAR="q"
					 DELEGATE="QUOTED_BRACE"
					 MATCH_TYPE="OPERATOR"
					 AT_WORD_START="TRUE"
					 NO_LINE_BREAK="FALSE">
			<BEGIN>qr(\{)
			<END>~1
		</SPAN_REGEXP>
		<SPAN_REGEXP HASH_CHAR="q"
					 DELEGATE="QUOTED_PAREN"
					 ESCAPE="\"
					 MATCH_TYPE="OPERATOR"
					 AT_WORD_START="TRUE"
					 NO_LINE_BREAK="FALSE">
			<BEGIN>qr(\()
 			<END>~1
 		</SPAN_REGEXP>

		<!-- tr/// transliteration -->
		<SEQ_REGEXP TYPE="MARKUP" HASH_CHAR="tr"
            AT_WORD_START="TRUE">tr\s*\{.*?[^\\]\}\s*\{(?:.*?[^\\])*?\}[cds]*</SEQ_REGEXP>

		<SEQ_REGEXP TYPE="MARKUP" HASH_CHAR="tr"
            AT_WORD_START="TRUE">tr([^\p{Alnum}\p{Space}\}])(?:.*?)\1(?:.*?)\1[cds]*</SEQ_REGEXP>

		<!-- y/// translation -->
		<SEQ_REGEXP TYPE="MARKUP" HASH_CHAR="y"
            AT_WORD_START="TRUE">y\s*\{.*?[^\\]\}\s*\{(?:.*?[^\\])*?\}[cds]*</SEQ_REGEXP>

		<SEQ_REGEXP TYPE="MARKUP" HASH_CHAR="y"
            AT_WORD_START="TRUE">y([^\p{Alnum}\p{Space}\}_])(?:.*?)\1(?:.*?)\1[cds]*</SEQ_REGEXP>

		<!-- m// regular expression matching -->
		<SEQ_REGEXP TYPE="MARKUP" HASH_CHAR="m"
			AT_WORD_START="TRUE">m\s*\{.*?[^\\]\}[cgimosx]*</SEQ_REGEXP>

		<SEQ_REGEXP TYPE="MARKUP" HASH_CHAR="m"
			AT_WORD_START="TRUE">m([^\p{Alnum}\p{Space}\}])(?:.*?[^\\])\1[cgimosx]*</SEQ_REGEXP>

		<!-- s/// regular expression substitution -->
		<SEQ_REGEXP TYPE="MARKUP" HASH_CHAR="s"
            AT_WORD_START="TRUE">s\s*\{.*?\}\s*\{.*?\}[egimosx]*</SEQ_REGEXP>

		<SEQ_REGEXP TYPE="MARKUP" HASH_CHAR="s"
            AT_WORD_START="TRUE">s([^\p{Alnum}\p{Space}\}])(?:.*?)\1(?:.*?)\1[egimosx]*</SEQ_REGEXP>

		<!-- complex operators -->
		<SEQ TYPE="OPERATOR">||
		<SEQ TYPE="OPERATOR">//
		<SEQ TYPE="OPERATOR">&&
		<SEQ TYPE="OPERATOR">!=
		<SEQ TYPE="OPERATOR"><=>
		<SEQ TYPE="OPERATOR">->
		<SEQ TYPE="OPERATOR">=>
		<SEQ TYPE="OPERATOR">==
		<SEQ TYPE="OPERATOR">=~
		<SEQ TYPE="OPERATOR">!~
		<SEQ TYPE="OPERATOR">~~

		<SEQ TYPE="OPERATOR">+=
		<SEQ TYPE="OPERATOR">-=
		<SEQ TYPE="OPERATOR">/=
		<SEQ TYPE="OPERATOR">*=
		<SEQ TYPE="OPERATOR">.=
		<SEQ TYPE="OPERATOR">%=

		<SEQ TYPE="OPERATOR">&=
		<SEQ TYPE="OPERATOR">|=
		<SEQ TYPE="OPERATOR">**=
		<SEQ TYPE="OPERATOR"><<=
		<SEQ TYPE="OPERATOR">>>=
		<SEQ TYPE="OPERATOR">&&=
		<SEQ TYPE="OPERATOR">||=
		<SEQ TYPE="OPERATOR">^=
		<SEQ TYPE="OPERATOR">x=
		<SEQ TYPE="OPERATOR">>=
		<SEQ TYPE="OPERATOR"><=
		<SEQ TYPE="OPERATOR">>
		<SEQ TYPE="OPERATOR"><

		<!-- simple operators -->
		<SEQ TYPE="OPERATOR">|
		<SEQ TYPE="OPERATOR">&
		<SEQ TYPE="OPERATOR">!
		<SEQ TYPE="OPERATOR">=
		<SEQ TYPE="OPERATOR">!
		<SEQ TYPE="OPERATOR">+
		<SEQ TYPE="OPERATOR">-
		<SEQ TYPE="OPERATOR">/
		<SEQ TYPE="OPERATOR">**
		<SEQ TYPE="OPERATOR">*
		<SEQ TYPE="OPERATOR">^
		<SEQ TYPE="OPERATOR">~
		<SEQ TYPE="OPERATOR">{
		<SEQ TYPE="OPERATOR">}
		<SEQ TYPE="OPERATOR">?
		<SEQ TYPE="OPERATOR">:

		<!-- Keywords -->
		<KEYWORDS>
			<KEYWORD1>new
			<KEYWORD1>if
			<KEYWORD1>until
			<KEYWORD1>while
			<KEYWORD1>elsif
			<KEYWORD1>else
			<KEYWORD1>unless
			<KEYWORD1>for
			<KEYWORD1>foreach
			<KEYWORD1>BEGIN
			<KEYWORD1>END

			<OPERATOR>cmp
			<OPERATOR>eq
			<OPERATOR>ne
			<OPERATOR>le
			<OPERATOR>ge
			<OPERATOR>not
			<OPERATOR>and
			<OPERATOR>or
			<OPERATOR>xor

			<!-- At least attempt to highlight 'x', although this misses some -->
			<OPERATOR>x

			<!--
				The following function list was derived from the perlfunc man
				page, Perl version 5.00503

				Certain keywords have been commented out where they appear more
				than once, and the y///, qx//, etc. functions have been removed,
				since they would are colorized not as keywords, but with separate
				rules.
			-->

			<!-- Functions for SCALARs or strings -->
			<KEYWORD3>chomp
			<KEYWORD3>chop
			<KEYWORD3>chr
			<KEYWORD3>crypt
			<KEYWORD3>hex
			<KEYWORD3>index
			<KEYWORD3>lc
			<KEYWORD3>lcfirst
			<KEYWORD3>length
			<KEYWORD3>oct
			<KEYWORD3>ord
			<KEYWORD3>pack
			<KEYWORD3>reverse
			<KEYWORD3>rindex
			<KEYWORD3>sprintf
			<KEYWORD3>substr
			<KEYWORD3>uc
			<KEYWORD3>ucfirst

			<!-- Regular expressions and pattern matching -->
			<KEYWORD3>pos
			<KEYWORD3>quotemeta
			<KEYWORD3>split
			<KEYWORD3>study

			<!-- Numeric functions -->
			<KEYWORD3>abs
			<KEYWORD3>atan2
			<KEYWORD3>cos
			<KEYWORD3>exp
			<!---->
			<KEYWORD3>int
			<KEYWORD3>log
			<!---->
			<KEYWORD3>rand
			<KEYWORD3>sin
			<KEYWORD3>sqrt
			<KEYWORD3>srand

			<!-- Functions for real @ARRAYs -->
			<KEYWORD3>pop
			<KEYWORD3>push
			<KEYWORD3>shift
			<KEYWORD3>splice
			<KEYWORD3>unshift

			<!-- Functions for list data -->
			<KEYWORD3>grep
			<KEYWORD3>join
			<KEYWORD3>map
			<!---->
			<KEYWORD3>sort
			<KEYWORD3>unpack

			<!-- Functions for real %HASHes -->
			<KEYWORD3>delete
			<KEYWORD3>each
			<KEYWORD3>exists
			<KEYWORD3>keys
			<KEYWORD3>values

			<!-- Input and output functions -->
			<KEYWORD3>binmode
			<KEYWORD3>close
			<KEYWORD3>closedir
			<KEYWORD3>dbmclose
			<KEYWORD3>dbmopen
			<!---->
			<KEYWORD3>eof
			<KEYWORD3>fileno
			<KEYWORD3>flock
			<KEYWORD3>format
			<KEYWORD3>getc
			<KEYWORD3>print
			<KEYWORD3>printf
			<KEYWORD3>read
			<KEYWORD3>readdir
			<KEYWORD3>rewinddir
			<KEYWORD3>say
			<KEYWORD3>seek
			<KEYWORD3>seekdir
			<KEYWORD3>select
			<KEYWORD3>syscall
			<KEYWORD3>sysread
			<KEYWORD3>sysseek
			<KEYWORD3>syswrite
			<KEYWORD3>tell
			<KEYWORD3>telldir
			<KEYWORD3>truncate
			<KEYWORD3>warn
			<KEYWORD3>write

			<!-- Functions for fixed length data or records -->
			<!---->
			<!---->
			<!---->
			<!---->
			<!---->
			<!---->
			<KEYWORD3>vec

			<!-- Functions for filehandles, files, or directories -->
			<KEYWORD3>chdir
			<KEYWORD3>chmod
			<KEYWORD3>chown
			<KEYWORD3>chroot
			<KEYWORD3>fcntl
			<KEYWORD3>glob
			<KEYWORD3>ioctl
			<KEYWORD3>link
			<KEYWORD3>lstat
			<KEYWORD3>mkdir
			<KEYWORD3>open
			<KEYWORD3>opendir
			<KEYWORD3>readlink
			<KEYWORD3>rename
			<KEYWORD3>rmdir
			<KEYWORD3>stat
			<KEYWORD3>symlink
			<KEYWORD3>umask
			<KEYWORD3>unlink
			<KEYWORD3>utime

			<!-- Keywords related to the control flow of your perl program -->
			<KEYWORD1>caller
			<KEYWORD1>continue
			<KEYWORD1>die
			<KEYWORD1>do
			<KEYWORD1>dump
			<KEYWORD1>eval
			<KEYWORD1>exit
			<KEYWORD1>goto
			<KEYWORD1>last
			<KEYWORD1>next
			<KEYWORD1>redo
			<KEYWORD1>return
			<KEYWORD1>wantarray

			<!-- Keywords related to switch -->
			<KEYWORD1>break
			<KEYWORD1>default
			<KEYWORD1>given
			<KEYWORD1>when

			<!-- Keywords related to scoping -->
			<!---->
			<!---->
			<KEYWORD1>local
			<KEYWORD1>my
			<KEYWORD1>our
			<KEYWORD1>package
			<KEYWORD1>state
			<KEYWORD1>use

			<!-- Miscellaneous functions -->
			<KEYWORD3>defined
			<!---->
			<!---->
			<KEYWORD3>formline
			<!---->
			<!---->
			<KEYWORD3>reset
			<KEYWORD3>scalar
			<KEYWORD3>undef
			<!---->

			<!-- Functions for processes and process groups -->
			<KEYWORD3>alarm
			<KEYWORD3>exec
			<KEYWORD3>fork
			<KEYWORD3>getpgrp
			<KEYWORD3>getppid
			<KEYWORD3>getpriority
			<KEYWORD3>kill
			<KEYWORD3>pipe
			<KEYWORD3>setpgrp
			<KEYWORD3>setpriority
			<KEYWORD3>sleep
			<KEYWORD3>system
			<KEYWORD3>times
			<KEYWORD3>wait
			<KEYWORD3>waitpid

			<!-- Keywords related to perl modules -->
			<!---->
			<KEYWORD1>import
			<KEYWORD1>no
			<!---->
			<KEYWORD1>require
			<!---->

			<!-- Keywords related to classes and object-orientedness -->
			<KEYWORD3>bless
			<!---->
			<!---->
			<!---->
			<KEYWORD3>ref
			<KEYWORD3>tie
			<KEYWORD3>tied
			<KEYWORD3>untie
			<!---->

			<!-- Low-level socket functions -->
			<KEYWORD3>accept
			<KEYWORD3>bind
			<KEYWORD3>connect
			<KEYWORD3>getpeername
			<KEYWORD3>getsockname
			<KEYWORD3>getsockopt
			<KEYWORD3>listen
			<KEYWORD3>recv
			<KEYWORD3>send
			<KEYWORD3>setsockopt
			<KEYWORD3>shutdown
			<KEYWORD3>socket
			<KEYWORD3>socketpair

			<!-- System V interprocess communication functions -->
			<KEYWORD3>msgctl
			<KEYWORD3>msgget
			<KEYWORD3>msgrcv
			<KEYWORD3>msgsnd
			<KEYWORD3>semctl
			<KEYWORD3>semget

			<KEYWORD3>semop
			<KEYWORD3>shmctl
			<KEYWORD3>shmget
			<KEYWORD3>shmread
			<KEYWORD3>shmwrite

			<!-- Fetching user and group info -->
			<KEYWORD3>endgrent
			<KEYWORD3>endhostent
			<KEYWORD3>endnetent
			<KEYWORD3>endpwent
			<KEYWORD3>getgrent
			<KEYWORD3>getgrgid
			<KEYWORD3>getgrnam
			<KEYWORD3>getlogin
			<KEYWORD3>getpwent
			<KEYWORD3>getpwnam
			<KEYWORD3>getpwuid
			<KEYWORD3>setgrent
			<KEYWORD3>setpwent

			<!-- Fetching network info -->
			<KEYWORD3>endprotoent
			<KEYWORD3>endservent
			<KEYWORD3>gethostbyaddr
			<KEYWORD3>gethostbyname
			<KEYWORD3>gethostent
			<KEYWORD3>getnetbyaddr
			<KEYWORD3>getnetbyname
			<KEYWORD3>getnetent
			<KEYWORD3>getprotobyname
			<KEYWORD3>getprotobynumber
			<KEYWORD3>getprotoent
			<KEYWORD3>getservbyname
			<KEYWORD3>getservbyport
			<KEYWORD3>getservent
			<KEYWORD3>sethostent
			<KEYWORD3>setnetent
			<KEYWORD3>setprotoent
			<KEYWORD3>setservent

			<!-- Time-related functions -->
			<KEYWORD3>gmtime
			<KEYWORD3>localtime
			<KEYWORD3>time
			<!---->

			<FUNCTION>sub
		</KEYWORDS>
	</RULES>

	<RULES SET="POD" DEFAULT="COMMENT2">
		<MARK_FOLLOWING TYPE="LABEL" AT_LINE_START="TRUE">=
	</RULES>

	<RULES SET="LITERAL" DEFAULT="LITERAL1" ESCAPE="\">
		<!-- Variables inside a Literal -->
		<SPAN TYPE="KEYWORD2" NO_LINE_BREAK="TRUE" DELEGATE="VARIABLE">
			<BEGIN>${
			<END>}
		</SPAN>

		<!-- object method inside a Literal -->
		<SPAN TYPE="KEYWORD2" NO_LINE_BREAK="TRUE" DELEGATE="VARIABLE">
			<BEGIN>->{
			<END>}
		</SPAN>

		<SEQ_REGEXP HASH_CHAR="$" TYPE="KEYWORD2">\$#?((\p{Alpha}\w*|_\w+)?::)*(\p{Alpha}\w*|_\w+|\d+)

		<SPAN TYPE="KEYWORD2" NO_LINE_BREAK="TRUE" DELEGATE="VARIABLE">
			<BEGIN>@{
			<END>}
		</SPAN>

		<MARK_FOLLOWING TYPE="KEYWORD2">@

		<SPAN TYPE="KEYWORD2" NO_LINE_BREAK="TRUE" DELEGATE="VARIABLE">
			<BEGIN>%{
			<END>}
		</SPAN>

		<MARK_FOLLOWING TYPE="KEYWORD2">%

		<SEQ TYPE="LITERAL1">|
		<SEQ TYPE="LITERAL1">&
		<SEQ TYPE="LITERAL1">!
		<SEQ TYPE="LITERAL1">>
		<SEQ TYPE="LITERAL1"><
		<SEQ TYPE="LITERAL1">)
		<SEQ TYPE="LITERAL1">(
		<SEQ TYPE="LITERAL1">=
		<SEQ TYPE="LITERAL1">!
		<SEQ TYPE="LITERAL1">+
		<SEQ TYPE="LITERAL1">-
		<SEQ TYPE="LITERAL1">/
		<SEQ TYPE="LITERAL1">*
		<SEQ TYPE="LITERAL1">^
		<SEQ TYPE="LITERAL1">~
		<SEQ TYPE="LITERAL1">}
		<SEQ TYPE="LITERAL1">{
		<SEQ TYPE="LITERAL1">.
		<SEQ TYPE="LITERAL1">,
		<SEQ TYPE="LITERAL1">;
		<SEQ TYPE="LITERAL1">]
		<SEQ TYPE="LITERAL1">[
		<SEQ TYPE="LITERAL1">?
		<SEQ TYPE="LITERAL1">:
	</RULES>

	<!-- Literals framed by apostrophs -->
	<RULES SET="APOSTR" DEFAULT="LITERAL1" ESCAPE="\">

		<!-- just a hack for sprintf -->
		<SEQ_REGEXP HASH_CHAR="%" TYPE="LITERAL4">%\d*\.?\d*[dfis]

	</RULES>

	<RULES SET="EXEC" DEFAULT="KEYWORD3" ESCAPE="\">
		<!-- Comments -->
		<EOL_SPAN TYPE="COMMENT1">#

		<!-- Variables -->
		<SPAN TYPE="KEYWORD2" NO_LINE_BREAK="TRUE">
			<BEGIN>${
			<END>}
		</SPAN>

		<MARK_FOLLOWING TYPE="KEYWORD2">$#
		<MARK_FOLLOWING TYPE="KEYWORD2">$

		<SPAN TYPE="KEYWORD2" NO_LINE_BREAK="TRUE">
			<BEGIN>@{
			<END>}
		</SPAN>

		<MARK_FOLLOWING TYPE="KEYWORD2">@

		<SPAN TYPE="KEYWORD2" NO_LINE_BREAK="TRUE">
			<BEGIN>%{
			<END>}
		</SPAN>

		<MARK_FOLLOWING TYPE="KEYWORD2">%
	</RULES>

	<RULES SET="VARIABLE" DEFAULT="KEYWORD2" ESCAPE="\">
 		<SPAN TYPE="KEYWORD2" NO_LINE_BREAK="TRUE" DELEGATE="VARIABLE">
			<BEGIN>{
			<END>}
		</SPAN>

		<SEQ TYPE="OPERATOR">->
	</RULES>

	<RULES SET="REGEXP" DEFAULT="MARKUP" ESCAPE="\">
		<!-- ??? -->
		<SEQ TYPE="MARKUP">)(
	</RULES>

	<RULES SET="SUB_NAME" DEFAULT="FUNCTION">
		<EOL_SPAN TYPE="COMMENT1">#
		<SPAN TYPE="OPERATOR" DELEGATE="SUB_PROTO">
			<BEGIN>(
			<END>)
		</SPAN>
	</RULES>

	<RULES SET="SUB_PROTO" DEFAULT="LITERAL1">
		<SEQ TYPE="LITERAL2">$
		<SEQ TYPE="LITERAL2">@
		<SEQ TYPE="LITERAL2">%
		<SEQ TYPE="LITERAL2">&
		<SEQ TYPE="LITERAL2">*
		<SEQ TYPE="LITERAL3">\
	</RULES>

	<!-- Used for quote-like operators; just makes sure the brackets are balanced. -->
	<RULES SET="QUOTED_BRACKET" DEFAULT="LITERAL1" ESCAPE="\">
		<SPAN NO_LINE_BREAK="FALSE"
					 TYPE="LITERAL1"
					 MATCH_TYPE="OPERATOR"
					 DELEGATE="QUOTED_BRACKET"
					 HASH_CHARS="[">
			<BEGIN>[
			<END>]
		</SPAN>
	</RULES>
	<RULES SET="QUOTED_BRACE" DEFAULT="LITERAL1" ESCAPE="\">
		<SPAN NO_LINE_BREAK="FALSE"
					 TYPE="LITERAL1"
					 MATCH_TYPE="OPERATOR"
					 DELEGATE="QUOTED_BRACE"
					 HASH_CHARS="{">
			<BEGIN>{
			<END>}
		</SPAN>
	</RULES>
	<RULES SET="QUOTED_PAREN" DEFAULT="LITERAL1" ESCAPE="\">
		<SPAN NO_LINE_BREAK="FALSE"
					 TYPE="LITERAL1"
					 MATCH_TYPE="OPERATOR"
					 DELEGATE="QUOTED_PAREN"
					 HASH_CHARS="(">
			<BEGIN>(
			<END>)
		</SPAN>
	</RULES>

</MODE>