Search This Blog

2007-01-21

Perl documentation generator for Windows XP

::GENERATE HUGE PERL DOCUMENTATION

cmd /c perldoc perl >>perldoc.txt
echo generating documentation for perl

cmd /c perldoc perlintro >>perldoc.txt
echo generating documentation for perlintro

cmd /c perldoc perltoc >>perldoc.txt
echo generating documentation for perltoc

cmd /c perldoc ActivePerl >>perldoc.txt
echo generating documentation for ActivePerl

cmd /c perldoc perlreftut >>perldoc.txt
echo generating documentation for perlreftut

cmd /c perldoc perldsc >>perldoc.txt
echo generating documentation for perldsc

cmd /c perldoc perllol >>perldoc.txt
echo generating documentation for perllol

cmd /c perldoc perlrequick >>perldoc.txt
echo generating documentation for perlrequick

cmd /c perldoc perlretut >>perldoc.txt
echo generating documentation for perlretut

cmd /c perldoc perlboot >>perldoc.txt
echo generating documentation for perlboot

cmd /c perldoc perltoot >>perldoc.txt
echo generating documentation for perltoot

cmd /c perldoc perltooc >>perldoc.txt
echo generating documentation for perltooc

cmd /c perldoc perlbot >>perldoc.txt
echo generating documentation for perlbot

cmd /c perldoc perlstyle >>perldoc.txt
echo generating documentation for perlstyle

cmd /c perldoc perlcheat >>perldoc.txt
echo generating documentation for perlcheat

cmd /c perldoc perltrap >>perldoc.txt
echo generating documentation for perltrap

cmd /c perldoc perldebtut >>perldoc.txt
echo generating documentation for perldebtut

cmd /c perldoc perlfaq >>perldoc.txt
echo generating documentation for perlfaq

cmd /c perldoc perlfaq1 >>perldoc.txt
echo generating documentation for perlfaq1

cmd /c perldoc perlfaq2 >>perldoc.txt
echo generating documentation for perlfaq2

cmd /c perldoc perlfaq3 >>perldoc.txt
echo generating documentation for perlfaq3

cmd /c perldoc perlfaq4 >>perldoc.txt
echo generating documentation for perlfaq4

cmd /c perldoc perlfaq5 >>perldoc.txt
echo generating documentation for perlfaq5

cmd /c perldoc perlfaq6 >>perldoc.txt
echo generating documentation for perlfaq6

cmd /c perldoc perlfaq7 >>perldoc.txt
echo generating documentation for perlfaq7

cmd /c perldoc perlfaq8 >>perldoc.txt
echo generating documentation for perlfaq8

cmd /c perldoc perlfaq9 >>perldoc.txt
echo generating documentation for perlfaq9

cmd /c perldoc perlsyn >>perldoc.txt
echo generating documentation for perlsyn

cmd /c perldoc perldata >>perldoc.txt
echo generating documentation for perldata

cmd /c perldoc perlop >>perldoc.txt
echo generating documentation for perlop

cmd /c perldoc perlsub >>perldoc.txt
echo generating documentation for perlsub

cmd /c perldoc perlfunc >>perldoc.txt
echo generating documentation for perlfunc

cmd /c perldoc perlopentut >>perldoc.txt
echo generating documentation for perlopentut

cmd /c perldoc perlpacktut >>perldoc.txt
echo generating documentation for perlpacktut

cmd /c perldoc perlpod >>perldoc.txt
echo generating documentation for perlpod

cmd /c perldoc perlpodspec >>perldoc.txt
echo generating documentation for perlpodspec

cmd /c perldoc perlrun >>perldoc.txt
echo generating documentation for perlrun

cmd /c perldoc perldiag >>perldoc.txt
echo generating documentation for perldiag

cmd /c perldoc perllexwarn >>perldoc.txt
echo generating documentation for perllexwarn

cmd /c perldoc perldebug >>perldoc.txt
echo generating documentation for perldebug

cmd /c perldoc perlvar >>perldoc.txt
echo generating documentation for perlvar

cmd /c perldoc perlre >>perldoc.txt
echo generating documentation for perlre

cmd /c perldoc perlreref >>perldoc.txt
echo generating documentation for perlreref

cmd /c perldoc perlref >>perldoc.txt
echo generating documentation for perlref

cmd /c perldoc perlform >>perldoc.txt
echo generating documentation for perlform

cmd /c perldoc perlobj >>perldoc.txt
echo generating documentation for perlobj

cmd /c perldoc perltie >>perldoc.txt
echo generating documentation for perltie

cmd /c perldoc perldbmfilter >>perldoc.txt
echo generating documentation for perldbmfilter

cmd /c perldoc perlipc >>perldoc.txt
echo generating documentation for perlipc

cmd /c perldoc perlfork >>perldoc.txt
echo generating documentation for perlfork

cmd /c perldoc perlnumber >>perldoc.txt
echo generating documentation for perlnumber

cmd /c perldoc perlthrtut >>perldoc.txt
echo generating documentation for perlthrtut

cmd /c perldoc perlothrtut >>perldoc.txt
echo generating documentation for perlothrtut

cmd /c perldoc perlport >>perldoc.txt
echo generating documentation for perlport

cmd /c perldoc perllocale >>perldoc.txt
echo generating documentation for perllocale

cmd /c perldoc perluniintro >>perldoc.txt
echo generating documentation for perluniintro

cmd /c perldoc perlunicode >>perldoc.txt
echo generating documentation for perlunicode

cmd /c perldoc perlebcdic >>perldoc.txt
echo generating documentation for perlebcdic

cmd /c perldoc perlsec >>perldoc.txt
echo generating documentation for perlsec

cmd /c perldoc perlmod >>perldoc.txt
echo generating documentation for perlmod

cmd /c perldoc perlmodlib >>perldoc.txt
echo generating documentation for perlmodlib

cmd /c perldoc perlmodstyle >>perldoc.txt
echo generating documentation for perlmodstyle

cmd /c perldoc perlmodinstall >>perldoc.txt
echo generating documentation for perlmodinstall

cmd /c perldoc perlnewmod >>perldoc.txt
echo generating documentation for perlnewmod

cmd /c perldoc perlutil >>perldoc.txt
echo generating documentation for perlutil

cmd /c perldoc perlcompile >>perldoc.txt
echo generating documentation for perlcompile

cmd /c perldoc perlfilter >>perldoc.txt
echo generating documentation for perlfilter

cmd /c perldoc perlglossary >>perldoc.txt
echo generating documentation for perlglossary

cmd /c perldoc perlembed >>perldoc.txt
echo generating documentation for perlembed

cmd /c perldoc perldebguts >>perldoc.txt
echo generating documentation for perldebguts

cmd /c perldoc perlxstut >>perldoc.txt
echo generating documentation for perlxstut

cmd /c perldoc perlxs >>perldoc.txt
echo generating documentation for perlxs

cmd /c perldoc perlclib >>perldoc.txt
echo generating documentation for perlclib

cmd /c perldoc perlguts >>perldoc.txt
echo generating documentation for perlguts

cmd /c perldoc perlcall >>perldoc.txt
echo generating documentation for perlcall

cmd /c perldoc perlapi >>perldoc.txt
echo generating documentation for perlapi

cmd /c perldoc perlintern >>perldoc.txt
echo generating documentation for perlintern

cmd /c perldoc perliol >>perldoc.txt
echo generating documentation for perliol

cmd /c perldoc perlapio >>perldoc.txt
echo generating documentation for perlapio

cmd /c perldoc perlhack >>perldoc.txt
echo generating documentation for perlhack

cmd /c perldoc perlbook >>perldoc.txt
echo generating documentation for perlbook

cmd /c perldoc perltodo >>perldoc.txt
echo generating documentation for perltodo

cmd /c perldoc perldoc >>perldoc.txt
echo generating documentation for perldoc

cmd /c perldoc perlhist >>perldoc.txt
echo generating documentation for perlhist

cmd /c perldoc activeperl >>perldoc.txt
echo generating documentation for activeperl

cmd /c perldoc activeperl >>perldoc.txt
echo generating documentation for activeperl

cmd /c perldoc perlartistic >>perldoc.txt
echo generating documentation for perlartistic

cmd /c perldoc perlgpl >>perldoc.txt
echo generating documentation for perlgpl

cmd /c perldoc perlcn >>perldoc.txt
echo generating documentation for perlcn

cmd /c perldoc perljp >>perldoc.txt
echo generating documentation for perljp

cmd /c perldoc perlko >>perldoc.txt
echo generating documentation for perlko

cmd /c perldoc perltw >>perldoc.txt
echo generating documentation for perltw

cmd /c perldoc perlaix >>perldoc.txt
echo generating documentation for perlaix

cmd /c perldoc perlamiga >>perldoc.txt
echo generating documentation for perlamiga

cmd /c perldoc perlapollo >>perldoc.txt
echo generating documentation for perlapollo

cmd /c perldoc perlbeos >>perldoc.txt
echo generating documentation for perlbeos

cmd /c perldoc perlbs2 >>perldoc.txt
echo generating documentation for perlbs2

cmd /c perldoc perlce >>perldoc.txt
echo generating documentation for perlce

cmd /c perldoc perlcygwin >>perldoc.txt
echo generating documentation for perlcygwin

cmd /c perldoc perldgux >>perldoc.txt
echo generating documentation for perldgux

cmd /c perldoc perldos >>perldoc.txt
echo generating documentation for perldos

cmd /c perldoc perlepoc >>perldoc.txt
echo generating documentation for perlepoc

cmd /c perldoc perlfreebsd >>perldoc.txt
echo generating documentation for perlfreebsd

cmd /c perldoc perlhpux >>perldoc.txt
echo generating documentation for perlhpux

cmd /c perldoc perlhurd >>perldoc.txt
echo generating documentation for perlhurd

cmd /c perldoc perlirix >>perldoc.txt
echo generating documentation for perlirix

cmd /c perldoc perllinux >>perldoc.txt
echo generating documentation for perllinux

cmd /c perldoc perlmachten >>perldoc.txt
echo generating documentation for perlmachten

cmd /c perldoc perlmacos >>perldoc.txt
echo generating documentation for perlmacos

cmd /c perldoc perlmacosx >>perldoc.txt
echo generating documentation for perlmacosx

cmd /c perldoc perlmint >>perldoc.txt
echo generating documentation for perlmint

cmd /c perldoc perlmpeix >>perldoc.txt
echo generating documentation for perlmpeix

cmd /c perldoc perlnetware >>perldoc.txt
echo generating documentation for perlnetware

cmd /c perldoc perlopenbsd >>perldoc.txt
echo generating documentation for perlopenbsd

cmd /c perldoc perlos2 >>perldoc.txt
echo generating documentation for perlos2

cmd /c perldoc perlos39 >>perldoc.txt
echo generating documentation for perlos39

cmd /c perldoc perlos4 >>perldoc.txt
echo generating documentation for perlos4

cmd /c perldoc perlplan9 >>perldoc.txt
echo generating documentation for perlplan9

cmd /c perldoc perlqnx >>perldoc.txt
echo generating documentation for perlqnx

cmd /c perldoc perlsolaris >>perldoc.txt
echo generating documentation for perlsolaris

cmd /c perldoc perltru64 >>perldoc.txt
echo generating documentation for perltru64

cmd /c perldoc perluts >>perldoc.txt
echo generating documentation for perluts

cmd /c perldoc perlvmesa >>perldoc.txt
echo generating documentation for perlvmesa

cmd /c perldoc perlvms >>perldoc.txt
echo generating documentation for perlvms

cmd /c perldoc perlvos >>perldoc.txt
echo generating documentation for perlvos

cmd /c perldoc perlwin32 >>perldoc.txt
echo generating documentation for perlwin32

cmd /c perldoc perlfunc >>perldoc.txt

cmd /c start /max textpad "%cd%\perldoc.txt"

2007-01-17

how to capture a command output or errors

package echoer;


main();

sub main
{
foreach (@ARGV)
{
$cmd .=$_ . " ";
}
my $result = `$cmd 2>&1`;
print "the result of the command is \n $result \n" ;
}


1 ;


__END__

2007-01-07

Code2HTML by SETH


########################################################################
# #
# Code2HTML #
# --------- #
# #
# Code2Html, peter@palfrader.org #
# #
# $Date: 2002/01/12 21:17:02 $
# $Revision: 1.13 $
# $Id: code2html,v 1.13 2002/01/12 21:17:02 weaselp Exp $
# #
# AUTHOR #
# Peter Palfrader. Written in 1999, 2000, 2001, 2002. #
# A lot of other people. See CREDITS file. #
# #
# DESCRIPTION #
# code2html is a perlscript which converts a program #
# source code to syntax highlighted HTML by applying a set #
# of regular expressions depending on the language #
# the source code is written. #
# #
# see the man-page for details, #
# #
########################################################################
# #
# update code2html #
# new: output as strict html #
# $Date: 2005-07-09 20:11:00 $
# modified: sub get_default_stylesheet #
# created: sub put_css_output #
# by: seth #
# #
########################################################################

use strict;
use Getopt::Long;

my $FILES_DISALLOWED_IN_CGI = 1;

# you may set this to false to allow file reading from your hd in
# cgi mode. This may be not good if your httpd runs as 'root' (yes, I've
# seen this!) and so any user could with some knowledge easily read
# your /etc/shadow for example!
my $FILES_REDIRECT_DISALLOWED = 1;
my $LANG_TEST_LENGTH = 1024;

# PP: I think Compress::Zlib could be nice for this. but it's not very widespread :(
# PP: A hash would be nicer but then it would not possible to get the keys in this very order (AFAIK)
# PP: If names contain meta characters, then those must be metaquoted (if you don't want the meta chars to be meta chars of course)
my @CGI_ENCODING = (['bzip2', '/usr/bin/bzip2', '--stdout'], ['gzip', '/bin/gzip', '--stdout'], ['compress', '/usr/bin/compress', '-c']);

# undefine the input record separator so everything gets loaded in one turn
undef $/;

my $pure_version_message = "code2html, version $vernr, $monthshort $year, peter\@palfrader.org (update: seth_code2html\@wg-karlsruhe.de)";
my $version_message = "$pure_version_message\n";

my $short_short_help = "Try `code2html --help' for more information.\n";
my $short_help = "$pure_version_message
Usage: code2html [options] [input_file [output_file]]

Convert a program source to syntax highlighted HTML,
or any other format for wich rules are defined.

-l, --language-mode set language mode
--fallback LANG fallback language mode
-v, --verbose prints progress information to STDERR
-n, --linenumbers print out the source code with line numbers
-P, --prefix optional prefix to use for linenumber anchors
-N, --linknumbers linenumbers will link to themselves
-t, --replace-tabs[=TABSTOP-WIDTH]
replace <tabs> with spaces
-L, --language-file=LANGUAGE-FILE
specify an alternate file for definitions
-m, --modes print all available modes
-h, --help print this message
-V, --version print version
-c, --content-type prints a Content-Type header
-o, --output-format selects the output-format
-H, --no-header don't use the template
--template=FILE override template
-T, --title set title

-w, --linewidth max characters per line
-b, --linebreakprefix prefix of the new lines

see the man-page code2html for further help
"
;

my $USE_CGI_FOR_ERRORS = 0; # is switched on in parse params if necessary
$SIG{'__DIE__'} = sub {
if ($USE_CGI_FOR_ERRORS) {print "Content-Type: text/plain\n\n", $0, ': ', $_[0], "\n";}
else {print STDERR $0, ': ', $_[0];}
exit 1;
};

$SIG{'__WARN__'} = sub {
unless ($USE_CGI_FOR_ERRORS) {print STDERR $0 . ': ' . $_[0];}
};

my $DEFAULT_OUTPUTFORMAT = 'html';
my $DEFAULT_OUTPUTFORMAT_IN_CGI = 'html';
my $ENTITIES;
my %ENTITIES;

my %params = &parse_params;
if ($params{'what_to_do'} eq 'patch_html') {&patch_html(\%params)}
elsif ($params{'what_to_do'} eq 'normal') {&main(\%params)}
else {die("I don't know what to do :(\n")}

sub main {
my %params = %{shift()};

print STDERR "getting patterns...\n" if ($params{'verbose'});

# building up the database
# newer entries overwrite old ones
my @CONFIG_FILES;
push @CONFIG_FILES, "/etc/code2html.config";
push @CONFIG_FILES, $ENV{'HOME'} . "/.code2html.config" if (defined($ENV{'HOME'}));
push @CONFIG_FILES, split(/:/, $ENV{'CODE2HTML_CONFIG'}) if ($ENV{'CODE2HTML_CONFIG'});
push @CONFIG_FILES, split(/:/, $params{'langfile'}) if defined($params{'langfile'});

my %STYLESHEET = %{&get_default_stylesheet};
my %LANGUAGE = %{&get_default_database};

for (@CONFIG_FILES) {
if (-r $_) {

# if I use `do $_` instead of scalar eval... %LANGUAGE is not exported and imported correctly (read: at all) (PP)
unless (scalar eval `cat $_`) {
warn "couldn't parse $_: $@" if $@;
}
}
}

if (defined($params{'modes'}) && $params{'modes'}) {
print "Defined modes: ";
print join(', ', sort keys %LANGUAGE), ".\n";
print "Defined outputformats: ";
print join(', ', sort keys %STYLESHEET), ".\n";
exit;
}

# set outputformat
die "Outputformat $params{'outputformat'} not defined" unless defined $STYLESHEET{$params{'outputformat'}};
my %STYLE = %{$STYLESHEET{$params{'outputformat'}}};

# load alternate template if given
if (($params{'template'} ne "") && (!$params{'noheader'})) {
open(FILE, $params{'template'}) || die("Could not open template file $params{'template'}: $!");
$STYLE{'template'} = <FILE>;
close(FILE);
}

# set up the global ENTITIES variables ( the scalar and the hash ) from the STYLE definition
$ENTITIES = ${$STYLE{'entities'}}{'listofchars'};
%ENTITIES = %{${$STYLE{'entities'}}{'replace_by'}};

# modify the header and footer so that the template variables are set correcly
unless ($STYLE{'template'} =~ /^(.*)%%code%%(.*)$/s) {
die "template does not contain a %%code%% variable";
}
$STYLE{'header'} = $1;
$STYLE{'footer'} = $2;
$STYLE{'header'} =~ s/%%title%%/$params{'title'}/g;
$STYLE{'footer'} =~ s/%%title%%/$params{'title'}/g;
$STYLE{'header'} =~ s/%%version%%/$vernr/g;
$STYLE{'footer'} =~ s/%%version%%/$vernr/g;

# load the input file and set params{'langmode'} if it is not already. this is done by probing a
# set of rules defined in %LANGUAGE
my $code_ref;
print STDERR "loading input file...\n" if ($params{'verbose'});
$code_ref = &get_input_file(\%params, \%LANGUAGE, $params{'langmode'}, $params{'alt_langmode'});

# select the rules for out language.
my $language_rules_ref = $LANGUAGE{lc($params{'langmode'})}->{'patterns'};

print STDERR "applying stylesheet...\n" if ($params{'verbose'});

# Apply the Stylesheets
# set 'starttag' and 'endtag' for every rule according to its 'style' value
# the tags are defined in the stylesheet
&apply_stylesheets_to_rules($language_rules_ref, \%STYLE);

print STDERR "outputting headers...\n" if ($params{'verbose'});
&put_headers(\%params, \%STYLE);

my $snippetlist_ref = [];
print STDERR "creating snippet-list...\n" if $params{'verbose'};
&create_snippetlist($language_rules_ref, $$code_ref, $snippetlist_ref, \%STYLE);

print STDERR "outputting file...\n" if $params{'verbose'};
&put_css_output(\%STYLE);
return &put_output(\%params, $snippetlist_ref, \%STYLE);
}

sub patch_html {
my %params = %{shift()};
my $code;

open(FILEHANDLE, $params{'infile'}) || die("While opening '$params{'infile'}' for input: " . $! . "\n");
$code = <FILEHANDLE>;
close(FILEHANDLE);

$code =~ s/<!-- code2html delete start -->.*?<!-- code2html delete stop -->//gs;
my $counter = 0;
my @chunks = split(/(<!-- code2html add.*?-->)/s, $code);

$code = '';
for (@chunks) {
$code .= $_;
if ($_ =~ /<!-- code2html add(.*?)(\n.*?)?-->/s) {
my $cmdline = $1;
my $input = $2;
$cmdline =~ s/^[ \t]*//g;
$cmdline =~ s/[ \t]*$//g;
@ARGV = split(/ /, $cmdline);
my %new_params = &parse_params;

$new_params{'input'} = $input if ($new_params{'infile'} eq "-");

undef $new_params{'outfile'};
++$counter;
$new_params{'line_number_prefix'} = $counter unless (defined $new_params{'line_number_prefix'});

$new_params{'verbose'} = $params{'verbose'};

my $no_header = $new_params{'noheader'};
$new_params{'noheader'} = 1;
$new_params{'dont_print_output'} = 1;

if ($no_header) {
$code .= '<!-- code2html delete start -->' .. &main(\%new_params) . '<!-- code2html delete stop -->';
} else {
$code .= '<!-- code2html delete start --><pre>' . &main(\%new_params) . '</pre><!-- code2html delete stop -->';
}
}
}

open(FILEHANDLE, '>' . $params{'outfile'}) || die("While opening '$params{'outfile'}' for output: " . $! . "\n");
print FILEHANDLE $code;
close(FILEHANDLE);
}

#####################################################################
################### get_input_data ##################################
#####################################################################
# Reads the input data for the cgi script.
# in : nothing
# out: a hash with the input data
sub get_input_data {
my $input_data;
my %f;
if ($ENV{'REQUEST_METHOD'} eq 'GET') {$input_data = $ENV{'QUERY_STRING'};}
else {read(STDIN, $input_data, $ENV{'CONTENT_LENGTH'});}

if ($ENV{'CONTENT_TYPE'} =~ m/^multipart\/form-data; boundary=(.*)$/i) {
my $boundary = quotemeta($1);
my @blocks = split(/$boundary/, $input_data);

for (@blocks) {
if (my $dummy = m/name="(.*?)"/i) {
my $name = $1;
$_ =~ s/\r\n/\n/g;
m/\n\n(.*)\n/s;
my $value = $1;
$f{$name} = $value;
}
}
} elsif ($ENV{'CONTENT_TYPE'} =~ m/^multipart\/form-data;$/i) # if the boundary is not in the enviroment variable we'll guess
{
my $dummy = $input_data =~ m/^(.*?)(\n|\r)/;
my $boundary = $1;

my @blocks = split(/$boundary/, $input_data);

for (@blocks) {
if (my $dummy = m/name="(.*?)"/i) {
my $name = $1;
$_ =~ s/\r\n/\n/g;
m/\n\n(.*)\n/s;
my $value = $1;
$f{$name} = $value;
}
}
} else {
my @form_fields = split(/&/, $input_data);

for (@form_fields) {
my ($name, $value) = split(/=/, $_);
$value =~ tr/+/ /;
$value =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;

$f{$name} = $value;
}
}

return %f;
}

################################################################################
####################### parse_params ###########################################
################################################################################
sub parse_params {
my %RESULT;

if (defined($ENV{'GATEWAY_INTERFACE'}) && (!scalar(@ARGV))) # if there is a CGI enviroment and no parameters/options given
{
$USE_CGI_FOR_ERRORS = 1;
$RESULT{'content-type'} = 1;
$RESULT{'what_to_do'} = 'normal';

my %input = &get_input_data;

$input{'input-selector'} = $input{'input_selector'} unless (defined $input{'input-selector'});
$input{'no-encoding'} = $input{'no_encoding'} unless (defined $input{'no-encoding'});
$input{'line-numbers'} = $input{'line_numbers'} unless (defined $input{'line-numbers'});
$input{'replace-tabs'} = $input{'replace_tabs'} unless (defined $input{'replace-tabs'});
$input{'language-mode'} = $input{'language_mode'} unless (defined $input{'language-mode'});
$input{'cgi-input1'} = $input{'cgi_input1'} unless (defined $input{'cgi-input1'});
$input{'cgi-input2'} = $input{'cgi_input2'} unless (defined $input{'cgi-input2'});

if ($input{'input-selector'} =~ /^cgi[-_]input[12]$/) {
my $input_selector = $input{'input-selector'};
die("CGI parse error: $input_selector does not exist!") unless (defined $input{$input_selector});
$RESULT{'input'} = $input{$input_selector};
$RESULT{'title'} = 'code2html result of cgi input form';
} elsif ($input{'input-selector'} eq "file") {
die('CGI parse error: option not supported due to security reasons!') if ($FILES_DISALLOWED_IN_CGI);
die('CGI parse error: filename not defined!') unless (defined $input{'filename'});
$RESULT{'infile'} = $input{'filename'};
$RESULT{'title'} = $RESULT{'infile'};
} elsif ($input{'input-selector'} eq "REDIRECT_URL") {
die('CGI parse error: option not supported due to security reasons!') if ($FILES_REDIRECT_DISALLOWED);
die('CGI parse error: ENV: REDIRECT_URL not defined!') unless (defined $ENV{'REDIRECT_URL'});
$RESULT{'infile'} = $ENV{'DOCUMENT_ROOT'} . $ENV{'REDIRECT_URL'};
$RESULT{'title'} = $RESULT{'infile'};
} else {
die('CGI parse error: input selector not given!');
}

if ((!defined($input{'no-encoding'})) || $input{'no-encoding'}) {
for (@CGI_ENCODING) {
if (
($ENV{'HTTP_ACCEPT_ENCODING'} =~ m/\b $_->[0] \b/x) && # PP: if supported by the browser
(-x $_->[1])
) # PP: and executable by the script
{
$RESULT{'encoding'} = $_->[0];
$RESULT{'encoder'} = $_->[1] . ' ' . $_->[2];
last;
}
}
}

$RESULT{'linenumbers'} = 'none';
if ($input{'line-numbers'} eq "yes") {$RESULT{'linenumbers'} = 'normal';}
if ($input{'line-numbers'} eq "link") {$RESULT{'linenumbers'} = 'linked';}
if (defined($input{'replace_tabs'})) {$RESULT{'replacetabs'} = $input{'replace-tabs'}}
if (defined($input{'fallback'})) {$RESULT{'alt_langmode'} = $input{'fallback'}}
if (defined($input{'language_mode'})) {$RESULT{'langmode'} = $input{'language-mode'}}
if (defined($input{'title'})) {$RESULT{'title'} = $input{'title'}}

$RESULT{'content_type'} = 1;
$RESULT{'outputformat'} = $DEFAULT_OUTPUTFORMAT_IN_CGI;
$RESULT{'outfile'} = '-';
} else {
my $verbose = 0;
my $linenumbers = 0;
my $linknumbers = 0;
my $replace_tabs = 0;
my $language_file = '';
my $language_mode = '';
my $modes = 0;
my $fallback = '';
my $help = 0;
my $version = 0;
my $content_type = 0;
my $no_header = 0;
my $outputformat = $DEFAULT_OUTPUTFORMAT;
my $template = '';
my $title = "__NOTHING__$$"; # some magix ;(
my $prefix = undef;
my $linewidth = undef;
my $linebreakprefix = undef;
my $linebreakprefixdefault = '» ';

my $patch_html;

# Get Options does not like - as a parameters (used for STDIN and STDOUT)
# So we're using a stupid magix again
@ARGV = map {$_ eq '-' ? "__STD__$$" : $_} @ARGV;

Getopt::Long::config('bundling');
unless (
GetOptions(
"--verbose", \$verbose,
"-v", \$verbose,

"--linenumbers", \$linenumbers,
"-n", \$linenumbers,

"--linknumbers", \$linknumbers,
"-N", \$linknumbers,

"--prefix=s", \$prefix,
"-P=s", \$prefix,

"--replace-tabs=i", \$replace_tabs,
"--replace_tabs=i", \$replace_tabs,
"-t=i", \$replace_tabs,

"--language-file=s", \$language_file,
"--language_file=s", \$language_file,
"-L=s", \$language_file,

"--language-mode=s", \$language_mode,
"--language_mode=s", \$language_mode,
"-l=s", \$language_mode,

"--title=s", \$title,
"-T=s", \$title,

"--modes", \$modes,
"-m", \$modes,

"--fallback=s", \$fallback,

"--output=s", \$outputformat,
"-o=s", \$outputformat,

"--template=s", \$template,

"--help", \$help,
"-h", \$help,

"--version", \$version,
"-V", \$version,

"--content-type", \$content_type,
"--content_type", \$content_type,
"-c", \$content_type,

"--no-header", \$no_header,
"--no_header", \$no_header,
"-H", \$no_header,

"--patch-html", \$patch_html,
"--patch_html", \$patch_html,
"-p", \$patch_html,

"--linewidth=i", \$linewidth,
"-w=i", \$linewidth,
"--linebreakprefix=s", \$linebreakprefix,
"-b=s", \$linebreakprefix,
)
)
{
print STDERR $short_short_help;
exit 1;
}

#reversing magix
@ARGV = map {$_ eq "__STD__$$" ? '-' : $_} @ARGV;

if ($help) {print STDERR $short_help; exit 0;}
if ($version) {print $version_message; exit 0;}

if ($patch_html) {
$RESULT{'what_to_do'} = 'patch_html';
$RESULT{'verbose'} = $verbose;

if (!defined($RESULT{'infile'} = shift(@ARGV))) {$RESULT{'infile'} = '-'}
if (!defined($RESULT{'outfile'} = shift(@ARGV))) {$RESULT{'outfile'} = $RESULT{'infile'}}
if (defined(shift(@ARGV))) {
print STDERR "too many parameters!\n";
print STDERR $short_help;
exit 1;
}
} else {
$RESULT{'what_to_do'} = 'normal';

$RESULT{'verbose'} = $verbose;
if ($linknumbers) {$RESULT{'linenumbers'} = 'linked'}
elsif ($linenumbers) {$RESULT{'linenumbers'} = 'normal'}
else {$RESULT{'linenumbers'} = 'none'}
$RESULT{'line_number_prefix'} = $prefix;
$RESULT{'replacetabs'} = $replace_tabs;
$RESULT{'langfile'} = $language_file;
$RESULT{'modes'} = $modes;
$RESULT{'alt_langmode'} = $fallback;
$RESULT{'content_type'} = $content_type;
$RESULT{'noheader'} = $no_header;
$RESULT{'langmode'} = $language_mode;
$RESULT{'template'} = $template;
$RESULT{'outputformat'} = $outputformat;
$RESULT{'linewidth'} = $linewidth;
$RESULT{'linebreakprefix'} = $linebreakprefix;

if (defined($RESULT{'linebreakprefix'})
&& !defined($RESULT{'linewidth'}))
{
printf(STDERR "--linebreakprefix|-b does not make sense without --linewidth|-w!\n");
print STDERR $short_help;
exit 1;
}
if (defined($RESULT{'linewidth'})) {
if ($RESULT{'linewidth'} <= 0) {
printf(STDERR "linewidth must be greater then 0!\n");
print STDERR $short_help;
exit 1;
}
if (!defined($RESULT{'linebreakprefix'})) {
$RESULT{'linebreakprefix'} = $linebreakprefixdefault;
}
}

if (!defined($RESULT{'infile'} = shift(@ARGV))) {$RESULT{'infile'} = '-'}
if (!defined($RESULT{'outfile'} = shift(@ARGV))) {$RESULT{'outfile'} = '-'}
if (defined(shift(@ARGV))) {
print STDERR "too many parameters!\n";
print STDERR $short_help;
exit 1;
}
}

#the magix again
$RESULT{'title'} = $title eq "__NOTHING__$$" ? ($RESULT{'infile'} eq '-' ? 'STDIN' : $RESULT{'infile'}) : $title;
}

return %RESULT;
}

################################################################################
####################### checkTabulator #########################################
################################################################################
sub checkTabulator {
my ($line, $TABSTOP) = @_;

while ((my $at = index($line, "\t")) != -1) {
my $cnt = ($TABSTOP - ($at % $TABSTOP));
my $replace_with = ' ' x $cnt if ($cnt);
$line =~ s/\t/$replace_with/;
}

return $line;
}

################################################################################
####################### splitLine ##############################################
################################################################################
sub splitLine {
my ($line, $linewidth, $prefix) = @_;

my $length = length($line);
my $pos = 0;

while ($length - $pos > $linewidth) {
my $maxoff =
($pos + $linewidth > $length)
? ($length - 1)
: ($pos + $linewidth);
my $newpos = rindex($line, " ", $maxoff);
if ($newpos > $pos) {
$pos = $newpos;
$line = substr($line, 0, $pos) . "\0$prefix" . substr($line, $pos + 1, $length);
} else {
$pos = $pos + $linewidth + 1;
$line = substr($line, 0, $pos) . "\0$prefix" . substr($line, $pos, $length);
}
}

return $line;
}

################################################################################
####################### get_input_file #########################################
################################################################################
sub get_input_file {

# in : \%params
# in : \%LANGUAGE;
# in/out : $langmode;
# in/out : $alt_langmode;
# returns: input file

my %PARAMS = %{$_[0]};
my %LANGUAGE = %{$_[1]};
my $langmode = $_[2];
my $alt_langmode = $_[3];
my $code;

if (defined $PARAMS{'input'}) {
$code = $PARAMS{'input'};
$code =~ s/\r//g;
} else {
open(FILEHANDLE, $PARAMS{'infile'}) || die("While opening '$PARAMS{'infile'}' for input: " . $! . "\n");
$code = <FILEHANDLE>;
close(FILEHANDLE);
}

if ($PARAMS{'replacetabs'} != 0) {
$code = join("\n", map {&checkTabulator($_, $PARAMS{'replacetabs'})} my @dummy = split(/\n/, $code));
}

if (defined($PARAMS{'linewidth'})) {
$code = join("\n", map {&splitLine($_, $PARAMS{'linewidth'}, $PARAMS{'linebreakprefix'})} my @dummy = split(/\n/, $code));
}

if ((!defined($langmode)) || ($langmode eq '')) {
my $test_code = substr($code, 0, $LANG_TEST_LENGTH);
warn("language mode not given. guessing...\n");

$langmode = '';

for (keys %LANGUAGE) {
if ( (($LANGUAGE{$_}->{'filename'} ne '') && ($PARAMS{'infile'} =~ m/$LANGUAGE{$_}->{filename}/))
|| (($LANGUAGE{$_}->{'regex'} ne '') && ($test_code =~ m/$LANGUAGE{$_}->{regex}/)))
{
$langmode = $_;
last;
}
}

if ($langmode eq '') {
if ((defined($alt_langmode)) && ($alt_langmode ne '')) {
warn("Guessing language mode failed. Using fallback mode: '$alt_langmode'\n");
$langmode = $alt_langmode;
$alt_langmode = '';
} else {
die(
"Guessing language mode failed.\n");
}
} else {
warn("using '$langmode'\n");
}
}

$_[2] = $langmode;
$_[3] = $alt_langmode;
return \$code;
}

################################################################################
####################### put_headers ############################################
################################################################################
sub put_headers {
my %PARAMS = %{shift()};
my $STYLE_REF = shift();

if (defined($PARAMS{'outfile'})) {
unless ($PARAMS{'outfile'} eq '-') {
open(SAVEOUT, ">&STDOUT");
print SAVEOUT ''; # so perl does not typo warn
open(STDOUT, '>' . $PARAMS{'outfile'}) || die("While redirecting STDOUT to '$PARAMS{'outfile'}' for output: " . $! . "\n");
}

if (defined $PARAMS{'encoding'}) {
$| = 1; # PP: so the header is written before the data!
# PP: this took me hours of debugging :(
print "Content-Type: $$STYLE_REF{'content-type'}\n" if ($PARAMS{'content_type'});
print "Content-Encoding: $PARAMS{'encoding'}\n\n";
open(FILEHANDLE, "|$PARAMS{'encoder'}") || die("While opening '$PARAMS{'encoder'}': " . $! . "\n");
} else {
open(FILEHANDLE, ">&STDOUT");
print FILEHANDLE "Content-Type: $$STYLE_REF{'content-type'}\n\n" if ($PARAMS{'content_type'});
}

print FILEHANDLE $$STYLE_REF{'header'} unless $PARAMS{'noheader'};
}
}

################################################################################
####################### apply_stylesheets_to_rules #############################
################################################################################
sub apply_stylesheets_to_rules {
my ($regexps_ref, $style_ref) = @_;

for (@$regexps_ref) {

# warn ("Style '".$_->{style}."' not defined in stylesheet.\n") unless defined $ { $$style_ref{'tags'} } { $_->{style} };
if (defined(${$$style_ref{'tags'}}{$_->{style}})) {
$_->{'starttag'} = '<span class="'.${${$$style_ref{'tags'}}{$_->{style}}}{'class'}.'">';
$_->{'endtag'} = '</span>'
} else {

# no style no formating; if style == '' formating is done by childregex
warn("Style '" . $_->{style} . "' not defined in stylesheet.\n") if ($_->{style} ne '');
$_->{'starttag'} = '';
$_->{'endtag'} = '';
}
apply_stylesheets_to_rules($_->{childregex}, $style_ref) if $_->{childregex};
}
}

################################################################################
####################### create_snippetlist #####################################
################################################################################
sub create_snippetlist {
my ($regexps_ref, $code, $snippetlist_ref, $style_ref) = @_;
my $length = length($code);

## An array of regular expression sturctures, each of which is an
## array. @res is kept sorted by starting position of the RExen and
## then by the position of the regex in the language file. This allows
## us to just evaluate $res[0], and to hand write fast code that typically
## handles 90% of the cases without resorting to the _big_ guns.
##
## FWIW, I pronounce '@res' REEZE, as in the plural of '$re'.
##
my @res;

my $pos;

for (@$regexps_ref) {
pos($code) = 0;

#++$m ;
next unless $code; =~ m/($_->{regex})/gms;

$pos = pos($code);

# $res[@res] = [
# $_->{regex},
# '<span class="'.${${$$style_ref{'tags'}}{$_->{style}}}{'class'}.'">',
# '</span>',
# $_->{childregex},
# $pos - length( $1 ),
# $pos,
# scalar( @res ),
# ] ;
$res[@res] = [$_->{regex}, $_->{starttag}, $_->{endtag}, $_->{childregex}, $pos - length($1), $pos, scalar(@res),];
}

## 90% of all child regexes end up with 0 or 1 regex that needs to be
## worried about. Trimming out the 0's speeds things up a bit and
## makes the below loop simpler, since there's always at least
## 1 regexp. It donsn't speed things up much by itself: the percentage
## of times this fires is really small. But it does simplify the loop
## below and speed it up.
unless (@res) {
$code =~ s/($ENTITIES)/$ENTITIES{$1}/ge;
push @$snippetlist_ref, $code;
return;
}

@res = sort {$a->[4] <=> $b->[4] || $a->[6] <=> $b->[6]} @res;

## Add a dummy at the end, which makes the logic below simpler / faster.
$res[@res] = [undef, undef, undef, undef, $length, $length, scalar(@res),];

## These are declared here for (minor) speed improvement.
my $re;
my $match_spos;
my $match_pos;
my $re_spos;
my $re_pos;
my $re_num;
my $prefix;
my $snippet;
my $rest;
my $i;
my $l;

my @changed_res;
my $j;

$pos = 0;
MAIN:
while ($pos < $length) {
$re = $res[0];

$match_spos = $re->[4];
$match_pos = $re->[5];

if ($match_spos > $pos) {
$prefix = substr($code, $pos, $match_spos - $pos);
$prefix =~ s/($ENTITIES)/$ENTITIES{$1}/ge;
push @$snippetlist_ref, $prefix;
}

if ($match_pos > $match_spos) {
$snippet = substr($code, $match_spos, $match_pos - $match_spos);
if (@{$re->[3]}) {
push @$snippetlist_ref, $re->[1];
create_snippetlist($re->[3], $snippet, $snippetlist_ref, $style_ref);
push @$snippetlist_ref, $re->[2];
} else {
$snippet =~ s/($ENTITIES)/$ENTITIES{$1}/ge;
push @$snippetlist_ref, $re->[1], $snippet, $re->[2];
}
}

$pos = $match_pos;

##
## Hand coded optimizations. Luckily, the cases that arise most often
## are the easiest to tune.
##

# =pod

if ($res[1]->[4] >= $pos) {
## Only first regex needs to be moved, 2nd and later are still valid.
## This is often 90% of the cases for Perl or C (others not tested,
## just uncomment the $n, $o, and $p lines and try it yourself).
#++$n{1} ;
#++$m ;
pos($code) = $pos;
unless ($code =~ m/($re->[0])/gms) {

#++$o{'0'} ;
if (@res == 2) {
## If the only regexp left is the dummy, we're done.
$rest = substr($code, $pos);
$rest =~ s/($ENTITIES)/$ENTITIES{$1}/ge;
push @$snippetlist_ref, $rest;
last;
}
shift @res;
} else {
$re->[5] = $re_pos = pos($code);
$re->[4] = $re_spos = $re_pos - length($1);

## Walk down the array looking for $re's new home.
## The first few loop iterations are unrolled and done manually
## for speed, which handles 85 to 90% of the cases where only
## $re needs to be moved.
##
## Here's where that dummy regexp at the end of the array comes
## in handy: we don't need to worry about array size here, since
## it will always be after $re no matter what. The unrolled
## loop stuff is outdented to make the conditionals fit on one
## 80 char line.
## Element 4 in @{$res[x]} is the start position of the match.
## Element 6 is the order in which it was declared in the lang file.
$re_num = $re->[6];
if (($re_spos <=> $res[1]->[4] || $re_num <=> $res[1]->[6]) <= 0) {

#++$o{'1'} ;
next
}
$res[0] = $res[1];

#++$o{'2'} ;
if (($re_spos <=> $res[2]->[4] || $re_num <=> $res[2]->[6]) <= 0) {
$res[1] = $re;
next;
}
$res[1] = $res[2];

if (($re_spos <=> $res[3]->[4] || $re_num <=> $res[3]->[6]) <= 0) {

#++$o{'3'} ;
$res[2] = $re;
next;
}
$res[2] = $res[3];

if (($re_spos <=> $res[4]->[4] || $re_num <=> $res[4]->[6]) <= 0) {

#++$o{'3'} ;
$res[3] = $re;
next;
}
$res[3] = $res[4];

if (($re_spos <=> $res[5]->[4] || $re_num <=> $res[5]->[6]) <= 0) {

#++$o{'4'} ;
$res[4] = $re;
next;
}
$res[4] = $res[5];

#++$o{'ugh'} ;
$i = 6;
$l = $#res;
for (; $i < $l; ++$i) {
last
if (($re_spos <=> $res[$i]->[4] || $re_num <=> $res[$i]->[6]) <= 0);
$res[$i - 1] = $res[$i];
}

#++$p{sprintf( "%2d", $i )} ;
$res[$i - 1] = $re;
}

next;
}

# =cut

##
## End optimizations. You can comment them all out and this net
## does all the work, just more slowly. If you do that, then
## you also need to comment out the code below that deals with
## the second entry in @res.
##

#my $ni = 0 ;
## First re always needs to be tweaked
#++$m ;
#++$ni ;
pos($code) = $pos;
unless ($code =~ m/($re->[0])/gms) {
if (@res == 2) {
## If the only regexp left is the dummy, we're done.
$rest = substr($code, $pos);
$rest =~ s/($ENTITIES)/$ENTITIES{$1}/ge;
push @$snippetlist_ref, $rest;
last;
}
shift @res;
@changed_res = ();
$i = 0;
} else {
$re->[5] = $re_pos = pos($code);
$re->[4] = $re_pos - length($1);
@changed_res = ($re);
$i = 1;
}

## If the optimizations above are in, the second one always
## needs to be tweaked, too.
$re = $res[$i];

#++$m ;
#++$ni ;
pos($code) = $pos;
unless ($code =~ m/($re->[0])/gms) {
if (@res == 2) {
## If the only regexp left is the dummy, we're done.
$rest = substr($code, $pos);
$rest =~ s/($ENTITIES)/$ENTITIES{$1}/ge;
push @$snippetlist_ref, $rest;
last;
}
shift @res;
} else {
$re->[5] = $re_pos = pos($code);
$re->[4] = $re_spos = $re_pos - length($1);
if (
@changed_res
&& ( $changed_res[0]->[4] <=> $re_spos
|| $changed_res[0]->[6] <=> $re->[6]) > 0
)
{
unshift @changed_res, $re;
} else {
$changed_res[$i] = $re;
}
++$i;
}

for (;; ++$i) {
local $_ = $res[$i];

#++$m ;
last if $_->[4] >= $pos;

#++$ni ;
#++$m ;
pos($code) = $pos;
unless ($code =~ m/($_->[0])/gms) {
if (@res <= 2) {
$rest = substr($code, $pos);
$rest =~ s/($ENTITIES)/$ENTITIES{$1}/ge;
push @$snippetlist_ref, $rest;
last MAIN;
}
## If this regex is no longer needed, remove it by not pushing it
## on to @changed_res. This means we need one less slot in @res.
shift @res;
redo;
}

$_->[5] = $re_pos = pos($code);
$_->[4] = $re_spos = $re_pos - length($1);

## Insertion sort in to @changed_res
$re_num = $_->[6];
for ($j = $#changed_res; $j > -1; --$j) {
last
if (($changed_res[$j]->[4] <=> $re_spos || $changed_res[$j]->[6] <=> $re_num) < 0);
$changed_res[$j + 1] = $changed_res[$j];
}
$changed_res[$j + 1] = $_;
}

## Merge sort @changed_res and @res in to @res
$j = 0;
$l = $#res;
for (@changed_res) {
while ($i < $l
&& ($_->[4] <=> $res[$i]->[4] || $_->[6] <=> $res[$i]->[6]) > 0)
{
$res[$j++] = $res[$i++];
}
$res[$j++] = $_;
}

# =cut
}
}

##################################################################################
######################### create_snippetlist #####################################
##################################################################################
##sub create_snippetlist
## {
## my ( $regexps_ref, $code, $snippetlist_ref ) = @_ ;

## my $length = length( $code );
## my @regexps;
## $regexps[scalar(@$regexps_ref)] = undef;

## my $head_ptr = undef;
## my $current_ptr;
## my $help_ptr;

## my $index = 0;

## for (@$regexps_ref)
## {
## $current_ptr = $regexps[$index]; #0: start_ptr 1: length 2: next_ptr, 3: regex, 4:start, 5:end, 6: child 7: index
## $current_ptr->[7] = $index++;
## $current_ptr->[6] = $$_{'childregex'};
## $current_ptr->[5] = $$_{'endtag'};
## $current_ptr->[4] = $$_{'starttag'};
## $current_ptr->[3] = $$_{'regex'};

## pos( $code ) = 0;
## if ( $code =~ /($current_ptr->[3])/gms ) { $current_ptr->[0] = pos ($code) - length($1); $current_ptr->[1] = length($1); } else {next};

## if (!defined ($head_ptr) || $current_ptr->[0] < $head_ptr->[0] )
## {
## $current_ptr->[2] = $head_ptr;
## $head_ptr = $current_ptr;
## }
## else
## {
## $help_ptr = $head_ptr;
## $help_ptr = $help_ptr->[2]
## while (defined ( $help_ptr->[2] ) && ($current_ptr->[0] >= $help_ptr->[2]->[0]) ); #iow: while (defined help->next && current->pos <= help->next->pos)

## $current_ptr->[2] = $help_ptr->[2];
## $help_ptr->[2] = $current_ptr;
## };
## };

## my $endpos = 0;
## my $oldhead;

## my %entities ;
## $entities{'&'} = '&amp;' ;
## $entities{'<'} = '&lt;' ;
## $entities{'>'} = '&gt;' ;
## $entities{'"'} = '&quot;' ;

## my $snippet;
## while (defined $head_ptr)
## {
## if ($head_ptr->[0] - $endpos > 0) {
## $snippet = substr($code, $endpos, $head_ptr->[0] - $endpos);
## $snippet =~ s/($ENTITIES)/$ENTITIES{$1}/ge; #"]);
## push @$snippetlist_ref, $snippet;
## };
## push @$snippetlist_ref, $head_ptr->[4];

## &create_snippetlist( $head_ptr->[6], substr($code, $head_ptr->[0], $head_ptr->[1]) , $snippetlist_ref);
## push @$snippetlist_ref, $head_ptr->[5];

## $endpos = $head_ptr->[0] + $head_ptr->[1];

## # update & repair list :

## $oldhead = $head_ptr;
## # 1) shift now invalid matches from list

## $help_ptr = $head_ptr;
## $help_ptr = $help_ptr->[2]
## while (defined ( $help_ptr->[2] ) && ($endpos > $help_ptr->[2]->[0]) );
## $head_ptr = $help_ptr->[2];
## $help_ptr->[2] = undef;

## # 2) rematch invalid matches and insert them into the list

## while (defined $oldhead)
## {
## $current_ptr = $oldhead;
## $oldhead = $oldhead->[2];

## pos( $code ) = $endpos;
## if ( $code =~ /($current_ptr->[3])/gms ) { $current_ptr->[0] = pos ($code) - length($1); $current_ptr->[1] = length($1); } else {next};
## if (!defined ($head_ptr) ||
## ($current_ptr->[0] < $head_ptr->[0]) ||
## (
## ( $current_ptr->[0] == $head_ptr->[0]) &&
## ( $current_ptr->[7] < $head_ptr->[7])
## )
## )
## {
## $current_ptr->[2] = $head_ptr;
## $head_ptr = $current_ptr;
## }
## else
## {
## $help_ptr = $head_ptr;
## $help_ptr = $help_ptr->[2]
## while (defined ( $help_ptr->[2] ) &&
## (
## ($current_ptr->[0] > $help_ptr->[2]->[0]) ||
## (
## ( $current_ptr->[0] == $help_ptr->[2]->[0]) &&
## ( $current_ptr->[7] > $help_ptr->[2]->[7])
## )
## )
## ); #iow: while (defined help->next && current->pos <= help->next->pos) # if two patterns match at the same pos
## # the one that was declared earlier is taken

## $current_ptr->[2] = $help_ptr->[2];
## $help_ptr->[2] = $current_ptr;
## };
## };

## # 3) done
## };

## $snippet = substr($code, $endpos); $snippet =~ s/($ENTITIES)/$ENTITIES{$1}/ge; #" ]);
## push @$snippetlist_ref, $snippet;
## };

################################################################################
####################### put_output #############################################
################################################################################
sub put_output {
my ($params, $snippetlist_ref, $STYLE_REF) = @_;

my $result;

my $prefix = '';
$prefix = $params->{'line_number_prefix'} . '_' if defined $params->{'line_number_prefix'};
$result = &{${$$STYLE_REF{'linenumbers'}}{$params->{'linenumbers'}}}(join('', @$snippetlist_ref), $prefix);

if (defined($params{'linewidth'})) {
$result =~ tr=\0=\n=;
}

print FILEHANDLE $result unless (defined $params->{'dont_print_output'} && $params->{'dont_print_output'});
print FILEHANDLE $$STYLE_REF{'footer'} unless $params->{'noheader'};

if (defined($params->{'outfile'})) {
unless ($params->{'outfile'} eq '-') {
close(FILEHANDLE);
close(STDOUT);
open(STDOUT, ">&SAVEOUT");
}
}
return $result;
}

################################################################################
####################### put_css_output #########################################
################################################################################
sub put_css_output {
my $style_ref = shift;
if (-e $$style_ref{'css_file'}) {
warn('css-file not written! '.$$style_ref{'css_file'}.' already exists!'."\n");
}else{
open(FH, '>'.$$style_ref{'css_file'}) || die("could not write css-file $$style_ref{'css_file'}: $!");
print FH $$style_ref{'css'};
close(FH);
}
}

################################################################################
####################### get_default_stylesheet #################################
################################################################################
sub get_default_stylesheet {

my %STYLESHEET;
my $tags;
my $css_file='code2html_format.css';

my $html_header='<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<!-- syntax highlighted by code2html v%%version%% http://www.wg-karlsruhe.de/seth/tools.php
orig.: Code2HTML, http://www.palfrader.org/code2html -->
<html>
<head>
<title>%%title%%</title>
<meta http-equiv="content-type" content="text/html; charset=ISO-8859-1">
<link rel="stylesheet" type="text/css" href="'
.$css_file.'">
</head>
<body>
<pre>%%code%%</pre>
</body>
</html>
'
;
$tags={
'comment' => {'class' => 'c2h_com'},
'doc comment' => {'class' => 'c2h_doc_com'},
'string' => {'class' => 'c2h_str'},
'esc string' => {'class' => 'c2h_esc_str'},
'character' => {'class' => 'c2h_char'},
'esc character' => {'class' => 'c2h_esc_char'},
'numeric' => {'class' => 'c2h_num'},
'identifier' => {'class' => 'c2h_id'},
'predefined identifier' => {'class' => 'c2h_prdef_id'},
'type' => {'class' => 'c2h_typ'},
'predefined type' => {'class' => 'c2h_prdef_ty'},
'reserved word' => {'class' => 'c2h_res_wrd'},
'library function' => {'class' => 'c2h_lib_f'},
'include' => {'class' => 'c2h_incl'},
'preprocessor' => {'class' => 'c2h_prepr'},
'braces' => {'class' => 'c2h_bra'},
'symbol' => {'class' => 'c2h_symb'},
'function header' => {'class' => 'c2h_fct_hd'},
'function header name' => {'class' => 'c2h_fct_hd_n'},
'function header args' => {'class' => 'c2h_fct_hd_a'},
'regex' => {'class' => 'c2h_regex'},
'text' => {'class' => 'c2h_txt'},
# HTML
'entity' => {'class' => 'c2h_ent'},
# MAKEFILE
'assignment' => {'class' => 'c2h_ass'},
'dependency line' => {'class' => 'c2h_dep_ln'},
'dependency target' => {'class' => 'c2h_dep_ta'},
'dependency continuation' => {'class' => 'c2h_dep_co'},
'continuation' => {'class' => 'c2h_cont'},
'macro' => {'class' => 'c2h_macro'},
'int macro' => {'class' => 'c2h_int_macro'},
'esc $$$' => {'class' => 'c2h_esc_'},
# PATCH
'separator' => {'class' => 'c2h_sep'},
'line spec' => {'class' => 'c2h_ln_spc'},
'deletion' => {'class' => 'c2h_del'},
'insertion' => {'class' => 'c2h_ins'}
};
##########
########## different color modes for html.
# those are named html-dark, html-nobc and html-light.
# html-light is also named html
# the only difference between html-light and html-nobc is
# that html-light defines a body background and text color.
# nobc stands for no body colors.

$STYLESHEET{'html-light'} = {
'css_file' => $css_file,
'template' => $html_header,
'content-type' => 'text/html',
'entities' => {
'listofchars' => '[<>&"]', # a regex actually
'replace_by' => {
'&' => '&amp;',
'<' => '&lt;',
'>' => '&gt;',
'"' => '&quot;'
}
},
'linenumbers' => {
'none' => sub {
return $_[0];
},
'normal' => sub {

# o as the first parameter is the joined snippetlist
# o the second is an optional prefix, needed if more than one block
# in a file is highlighted. needed in patch-mode. may be empty
# the sub should the return a scalar made up of the joined lines including linenumbers
my @lines = split(/\n/, $_[0]);

my $nr = 0;
my $lengthofnr = length(@lines);
my $format = qq{<a name="$_[1]line%u">%${lengthofnr}u</a> %s\n};
join(
'',
map ({
$nr++;
sprintf($format, $nr, $nr, $_)
} @lines)
);
},
'linked' => sub {

# this should do the same as above only with linenumbers that link to themselves
# If this style does not support this, use the same as above.
my @lines = split(/\n/, $_[0]);

my $nr = 0;
my $lengthofnr = length(@lines);
my $format = qq{<a name="$_[1]line%u" href="#$_[1]line%u">%$ {lengthofnr}u</a> %s\n};
join(
'',
map ({
$nr++;
sprintf($format, $nr, $nr, $nr, $_)
} @lines)
);
}
},
'tags' => $tags,
'css' => 'body{
color:#000000;}
body{
margin:1pt 1pt 1pt 1pt;
background-color:#ffffff;
padding: 3pt 3pt 0 0;}
.'
.${$$tags{'comment'}} {'class'}.' {color:#444444;}
.'
.${$$tags{'doc comment'}} {'class'}.' {color:#444444; font-style:italic;}
.'
.${$$tags{'string'}} {'class'}.' {color:#008000;}
.'
.${$$tags{'esc string'}} {'class'}.' {color:#77dd77;}
.'
.${$$tags{'character'}} {'class'}.' {color:#008000;}
.'
.${$$tags{'esc character'}} {'class'}.' {color:#77dd77;}
.'
.${$$tags{'numeric'}} {'class'}.' {color:#ff0000;}
.'
.${$$tags{'identifier'}} {'class'}.' {color:#2040a0;}
.'
.${$$tags{'predefined identifier'}} {'class'}.' {color:#2040a0; font-weight:bold;}
.'
.${$$tags{'type'}} {'class'}.' {color:#2040a0; font-weight:bold;}
.'
.${$$tags{'predefined type'}} {'class'}.' {color:#2040a0; font-weight:bold;}
.'
.${$$tags{'reserved word'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'library function'}} {'class'}.' {color:#a52a2a; font-weight:bold;}
.'
.${$$tags{'include'}} {'class'}.' {color:#0000ff; font-weight:bold;}
.'
.${$$tags{'preprocessor'}} {'class'}.' {color:#0000ff; font-weight:bold;}
.'
.${$$tags{'braces'}} {'class'}.' {color:#4444ff; font-weight:bold;}
.'
.${$$tags{'symbol'}} {'class'}.' {color:#4444ff;}
.'
.${$$tags{'function header'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'function header name'}} {'class'}.' {color:#ff0000;}
.'
.${$$tags{'function header args'}} {'class'}.' {color:#2040a0;}
.'
.${$$tags{'regex'}} {'class'}.' {color:#b000d0;}
.'
.${$$tags{'text'}} {'class'}.' {font-style:italic;}
.'
.${$$tags{'entity'}} {'class'}.' {color:#ff0000;}
.'
.${$$tags{'assignment'}} {'class'}.' {color:#2040a0;}
.'
.${$$tags{'dependency line'}} {'class'}.' {color:#8b2252;}
.'
.${$$tags{'dependency target'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'dependency continuation'}} {'class'}.' {color:#000000; font-weight:bold;}
.'
.${$$tags{'continuation'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'macro'}} {'class'}.' {color:#2040a0;}
.'
.${$$tags{'int macro'}} {'class'}.' {color:#4080ff;}
.'
.${$$tags{'esc $$$'}} {'class'}.' {color:#444444;}
.'
.${$$tags{'separator'}} {'class'}.' {color:#00A040; font-weight:bold;}
.'
.${$$tags{'line spec'}} {'class'}.' {color:#A0A000; font-weight:bold;}
.'
.${$$tags{'deletion'}} {'class'}.' {color:#ff0000; font-weight:bold;}
.'
.${$$tags{'insertion'}} {'class'}.' {color:#0000ff; font-weight:bold;}
'

};

# html-light is also called html

$STYLESHEET{'html'} = $STYLESHEET{'html-light'};

# html-nobc is a modification of html-light
# in such a way, that the body tag does not define
# a background and a text color
# nobc stands for no body colors.

%{$STYLESHEET{'html-nobg'}} = %{$STYLESHEET{'html-light'}};
${$STYLESHEET{'html-nobg'}}{'css'} = 'body{
margin:1 1 1 1pt;
padding: 3pt 3pt 0 0;}
'
;

# html-dark is a modification of html-light
# in such a way, that the body tag does define
# different colors and that the <span> colors are different.

%{$STYLESHEET{'html-dark'}} = %{$STYLESHEET{'html-light'}};
${$STYLESHEET{'html-dark'}}{'css'} = 'body{
color:#c0c0c0;}
body{
margin:1 1 1 1pt;
background-color:#000000;
padding: 3pt 3pt 0 0;}
.'
.${$$tags{'comment'}} {'class'}.' {color:#909000;}
.'
.${$$tags{'doc comment'}} {'class'}.' {color:#909000; font-style:italic;}
.'
.${$$tags{'string'}} {'class'}.' {color:#ffff00;}
.'
.${$$tags{'esc string'}} {'class'}.' {color:#77dd77;}
.'
.${$$tags{'character'}} {'class'}.' {color:#ffff00;}
.'
.${$$tags{'esc character'}} {'class'}.' {color:#77dd77;}
.'
.${$$tags{'numeric'}} {'class'}.' {color:#ff0000;}
.'
.${$$tags{'identifier'}} {'class'}.' {color:#b0b0b0;}
.'
.${$$tags{'predefined identifier'}} {'class'}.' {color:#2040a0; font-weight:bold;}
.'
.${$$tags{'type'}} {'class'}.' {color:#2040a0; font-weight:bold;}
.'
.${$$tags{'predefined type'}} {'class'}.' {color:#2040a0; font-weight:bold;}
.'
.${$$tags{'reserved word'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'library function'}} {'class'}.' {color:#a52a2a; font-weight:bold;}
.'
.${$$tags{'include'}} {'class'}.' {color:#0000ff;}
.'
.${$$tags{'preprocessor'}} {'class'}.' {color:#0000ff;}
.'
.${$$tags{'braces'}} {'class'}.' {color:#008b8b; font-weight:bold;}
.'
.${$$tags{'symbol'}} {'class'}.' {color:#008b8b;}
.'
.${$$tags{'function header'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'function header name'}} {'class'}.' {color:#ff0000;}
.'
.${$$tags{'function header args'}} {'class'}.' {color:#2040a0;}
.'
.${$$tags{'regex'}} {'class'}.' {color:#b000d0;}
.'
.${$$tags{'text'}} {'class'}.' {font-style:italic;}
.'
.${$$tags{'entity'}} {'class'}.' {color:#ff0000;}
.'
.${$$tags{'assignment'}} {'class'}.' {color:#2040a0;}
.'
.${$$tags{'dependency line'}} {'class'}.' {color:#8b2252;}
.'
.${$$tags{'dependency target'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'dependency continuation'}} {'class'}.' {color:#000000; font-weight:bold;}
.'
.${$$tags{'continuation'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'macro'}} {'class'}.' {color:#2040a0;}
.'
.${$$tags{'int macro'}} {'class'}.' {color:#4080ff;}
.'
.${$$tags{'esc $$$'}} {'class'}.' {color:#444444;}
.'
.${$$tags{'separator'}} {'class'}.' {color:#00ff00; font-weight:bold;}
.'
.${$$tags{'line spec'}} {'class'}.' {color:#ffff00; font-weight:bold;}
.'
.${$$tags{'deletion'}} {'class'}.' {color:#ff0000; font-weight:bold;}
.'
.${$$tags{'insertion'}} {'class'}.' {color:#0000ff; font-weight:bold;}
'
;

#####
#
# nocolor
#
%{$STYLESHEET{'html-nocolor'}} = %{$STYLESHEET{'html-nobg'}};
${$STYLESHEET{'html-nocolor'}}{'css'} = 'body{
margin:1 1 1 1pt;
padding: 3pt 3pt 0 0;}
.'
.${$$tags{'comment'}} {'class'}.' {font-style:italic;}
.'
.${$$tags{'doc comment'}} {'class'}.' {}
.'
.${$$tags{'string'}} {'class'}.' {font-style:italic;}
.'
.${$$tags{'esc string'}} {'class'}.' {}
.'
.${$$tags{'character'}} {'class'}.' {}
.'
.${$$tags{'esc character'}} {'class'}.' {}
.'
.${$$tags{'numeric'}} {'class'}.' {}
.'
.${$$tags{'identifier'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'predefined identifier'}} {'class'}.' {text-decoration:underline;}
.'
.${$$tags{'type'}} {'class'}.' {}
.'
.${$$tags{'predefined type'}} {'class'}.' {text-decoration:underline;}
.'
.${$$tags{'reserved word'}} {'class'}.' {}
.'
.${$$tags{'library function'}} {'class'}.' {}
.'
.${$$tags{'include'}} {'class'}.' {}
.'
.${$$tags{'preprocessor'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'braces'}} {'class'}.' {}
.'
.${$$tags{'symbol'}} {'class'}.' {}
.'
.${$$tags{'function header'}} {'class'}.' {}
.'
.${$$tags{'function header name'}} {'class'}.' {}
.'
.${$$tags{'function header args'}} {'class'}.' {}
.'
.${$$tags{'regex'}} {'class'}.' {}
.'
.${$$tags{'text'}} {'class'}.' {}
.'
.${$$tags{'entity'}} {'class'}.' {}
.'
.${$$tags{'assignment'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'dependency line'}} {'class'}.' {}
.'
.${$$tags{'dependency target'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'dependency continuation'}} {'class'}.' {}
.'
.${$$tags{'continuation'}} {'class'}.' {}
.'
.${$$tags{'macro'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'int macro'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'esc $$$'}} {'class'}.' {}
.'
.${$$tags{'separator'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'line spec'}} {'class'}.' {}
.'
.${$$tags{'deletion'}} {'class'}.' {}
.'
.${$$tags{'insertion'}} {'class'}.' {}
'
;

#####
#
# simple
#
%{$STYLESHEET{'html-simple'}} = %{$STYLESHEET{'html-nocolor'}};

# Vincent Sanders <vince@trinity.fluff.org>
# html-fntlck is a modification of html-light
# in such a way, that the body tag does define
# different colors and that the <span> colors are different.
#it is supposed to be the colours i get from emacs default font-lock mode

%{$STYLESHEET{'html-fntlck'}} = %{$STYLESHEET{'html-light'}};
${$STYLESHEET{'html-fntlck'}}{'css'} = 'body{
color:#000000;}
body{
margin:1 1 1 1pt;
background-color:#ffffff;
padding: 3pt 3pt 0 0;}
.'
.${$$tags{'comment'}} {'class'}.' {color:#bb0000;}
.'
.${$$tags{'doc comment'}} {'class'}.' {color:#bb0000; font-style:italic;}
.'
.${$$tags{'string'}} {'class'}.' {color:#bb7766;}
.'
.${$$tags{'esc string'}} {'class'}.' {color:#cc8877;}
.'
.${$$tags{'character'}} {'class'}.' {color:#bb7766;}
.'
.${$$tags{'esc character'}} {'class'}.' {color:#cc8877;}
.'
.${$$tags{'numeric'}} {'class'}.' {color:#0000ff;}
.'
.${$$tags{'identifier'}} {'class'}.' {color:#b0b0b0;}
.'
.${$$tags{'predefined identifier'}} {'class'}.' {color:#2040a0; font-weight:bold;}
.'
.${$$tags{'type'}} {'class'}.' {color:#2040a0; font-weight:bold;}
.'
.${$$tags{'predefined type'}} {'class'}.' {color:#2040a0; font-weight:bold;}
.'
.${$$tags{'reserved word'}} {'class'}.' {color:#b000e0;}
.'
.${$$tags{'library function'}} {'class'}.' {color:#a52a2a; font-weight:bold;}
.'
.${$$tags{'include'}} {'class'}.' {color:#0000ff; font-weight:bold;}
.'
.${$$tags{'preprocessor'}} {'class'}.' {color:#0000ff; font-weight:bold;}
.'
.${$$tags{'braces'}} {'class'}.' {color:#4444ff; font-weight:bold;}
.'
.${$$tags{'symbol'}} {'class'}.' {color:#000000;}
.'
.${$$tags{'function header'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'function header name'}} {'class'}.' {color:#ff0000;}
.'
.${$$tags{'function header args'}} {'class'}.' {color:#2040a0;}
.'
.${$$tags{'regex'}} {'class'}.' {color:#b000d0;}
.'
.${$$tags{'text'}} {'class'}.' {font-style:italic;}
.'
.${$$tags{'entity'}} {'class'}.' {color:#ff0000;}
.'
.${$$tags{'assignment'}} {'class'}.' {color:#2040a0;}
.'
.${$$tags{'dependency line'}} {'class'}.' {color:#8b2252;}
.'
.${$$tags{'dependency target'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'dependency continuation'}} {'class'}.' {color:#000000; font-weight:bold;}
.'
.${$$tags{'continuation'}} {'class'}.' {font-weight:bold;}
.'
.${$$tags{'macro'}} {'class'}.' {color:#2040a0;}
.'
.${$$tags{'int macro'}} {'class'}.' {color:#4080ff;}
.'
.${$$tags{'esc $$$'}} {'class'}.' {color:#444444;}
.'
.${$$tags{'separator'}} {'class'}.' {color:#00a040; font-weight:bold;}
.'
.${$$tags{'line spec'}} {'class'}.' {color:#a0a000; font-weight:bold;}
.'
.${$$tags{'deletion'}} {'class'}.' {color:#ff0000; font-weight:bold;}
.'
.${$$tags{'insertion'}} {'class'}.' {color:#0000ff; font-weight:bold;}
'
;
return \%STYLESHEET;

}

################################################################################
####################### get_default_database ###################################
################################################################################
sub get_default_database {

my %LANGUAGE;

# written by PP
$LANGUAGE{'plain'} = {
'filename' => '',
'regex' => '',
'patterns' => []
};

# taken from nedit
# modified by PP
$LANGUAGE{'ada'} = {
'filename' => '(?i)\\.a(d[asb]?)?$',
'regex' => '',
'patterns' => [
{
'name' => 'Comments',
'regex' => '--.*?$',
'style' => 'comment',
'childregex' => [],
},
{
'name' => 'String Literals',
'regex' => '".*?("|$)',
'style' => 'string',
'childregex' => []
},
{
'name' => 'Character Literals',
'regex' => '\'.\'',
'style' => 'character',
'childregex' => []
},
{
'name' => 'Ada Attributes',
'regex' => '\'[a-zA-Z][a-zA-Z_]+\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'Numeric Literals',
'regex' => '(((2|8|10|16)#[_0-9a-fA-F]*#)|[0-9.]+)',
'style' => 'numeric',
'childregex' => []
},
{
'name' => 'Withs Pragmas Use',
'regex' => '\\b(?i)((with|pragma|use)[ \\t\\n\\f\\r]+[a-zA-Z0-9_.]+;)+\\b',
'style' => 'include',
'childregex' => []
},
{
'name' => 'Predefined Types',
'regex' => '\\b(?i)(boolean|character|count|duration|float|integer|long_float|long_integer|priority|short_float|short_integer|string)\\b',
'style' => 'predefined type',
'childregex' => []
},
{
'name' => 'Predefined Subtypes',
'regex' => '\\b(?i)field|natural|number_base|positive|priority\\b',
'style' => 'predefined type',
'childregex' => []
},
{
'name' => 'Reserved Words',
'regex' =>
'\\b(?i)(abort|abs|accept|access|and|array|at|begin|body|case|constant|declare|delay|delta|digits|do|else|elsif|end|entry|exception|exit|for|function|generic|goto|if|in|is|limited|loop|mod|new|not|null|of|or|others|out|package|pragma|private|procedure|raise|range|record|rem|renames|return|reverse|select|separate|subtype|task|terminate|then|type|use|when|while|with|xor)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'Ada 95 Only',
'regex' => '\\b(?i)(abstract|tagged|all|protected|aliased|requeue|until)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'Identifiers',
'regex' => '\\b[a-zA-Z][a-zA-Z0-9_]*\\b',
'style' => 'identifier',
'childregex' => []
},
{
'name' => 'Dot All',
'regex' => '(?i)\\.all\\b',
'style' => 'predefined identifier',
'childregex' => []
}
]
};
$LANGUAGE{'ada95'} = $LANGUAGE{'ada'};

# written by JA
$LANGUAGE{'awk'} = {
'filename' => '(?i)\\.awk$',
'regex' => '^\\s*#\\s*![^\\s]*awk',
'patterns' => [
{
'name' => 'comment',
'regex' => '#.*?$',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'string',
'regex' => '""|".*?([^\\\\](\\\\\\\\)*)"|"\\\\\\\\"',

# 'regex' => '""|"\\\\\\\\"|"[^"\\\\]"|"[^"].*?[^\\\\]"',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => 'string',
'regex' => '\'\'|\'.*?([^\\\\](\\\\\\\\)*)\'|\'\\\\\\\\\'',

# 'regex' => '\'\'|\'\\\\\\\\\'|\'[^\'\\\\]\'|\'[^\'].*?[^\\\\]\'',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => 'function header',
'regex' => 'function[\\t ]+([a-zA-Z0-9_]+)[\\t \\n]*(\\{|\\n)',
'style' => 'function header',
'childregex' => [
{
'name' => 'function coloring',
'regex' => '[\\t ]([a-zA-Z0-9_]+)',
'style' => 'function header name',
'childregex' => []
}
]
},
{
'name' => 'regex matching I 1',
'regex' => '(\\b| )?(/)(\\\\/|[^/\\n])*(/[gimesox]*)',
'style' => 'regex',
'childregex' => []
},
{
'name' => 'regex matching I 2',
'regex' => '(?:\\b| )(?:(?:m|q|qq)([!"#$%&\'*+-/]))(\\\\\\2|[^\\2\\n])*(\\2[gimesox]*)',
'style' => 'regex',
'childregex' => []
},
{
'name' => 'regex matching II',
'regex' => '(?:\\b| )?(?:s([!"#$%&\'*+-/]))(?:\\\\\\2|[^\\2\\n])*?(\\2)[^(\\2)\\n]*?(\\2[gimesox]*)',
'style' => 'regex',
'childregex' => []
},
{
'name' => 'translate',
'regex' => '(?:\\b| )(?:(?:tr|y)([^\w\s]))(?:\\\\\\2|[^\\2\\n])*?(\\2)[^(\\2)\\n]*?(\\2[gimesox]*)',
'style' => 'regex',
'childregex' => []
},
{
'name' => 'keywords',
'regex' =>
'\\b(BEGIN|END|ARGC|ARGIND|ARGV|CONVFMT|ENVIRON|ERRNO|FIELDWIDTHS|FILENAME|FNR|FS|IGNORECASE|NF|NR|OFMT|OFS|ORS|RS|RT|RSTART|RLENGTH|SUBSEP)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'keywords 2',
'regex' => '\\b(if|while|do|for|in|break|continue|delete|exit|next|nextfile|function)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'library fns',
'regex' =>
'\\b(close|getline|print|printf|system|fflush|atan2|cos|exp|int|log|rand|sin|sqrt|srand|gensub|gsub|index|length|split|sprintf|sub|substr|tolower|toupper|systime|strftime)\\b',
'style' => 'library function',
'childregex' => []
},
{
'name' => 'braces and parens',
'regex' => '[\\[\\]\\{\\}\\(\\)]',
'style' => 'braces',
'childregex' => []
},
{
'name' => '<< stuff',
'regex' => '<<\'([^\\n]*)\';.*?^\\2$',
'style' => 'text',
'childregex' => []
},
{
'name' => '<< stuff',
'regex' => '<<([^\\n]*).*?^\\2$',
'style' => 'text',
'childregex' => []
}
]
};

# taken from nedit
# modified by PP
$LANGUAGE{'c'} = {
'filename' => '\\.[ch]$',
'regex' => '',
'patterns' => [
{
'name' => 'doc comment',
'regex' => '/\\*\\*.*?\\*/',
'style' => 'doc comment',
'childregex' => []
},
{
'name' => 'comment',
'regex' => '/\\*.*?\\*/',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'string',
'regex' => '""|".*?([^\\\\](\\\\\\\\)*)"|"\\\\\\\\"',

# 'regex' => '""|"\\\\\\\\"|"[^"\\\\]"|"[^"].*?[^\\\\]"',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => 'preprocessor line',
'regex' => '^[ \\t]*#.*?$',
'style' => 'preprocessor',
'childregex' => [
{
'name' => 'string',
'regex' => '""|".*?([^\\\\](\\\\\\\\)*)"|"\\\\\\\\"',

# 'regex' => '""|"\\\\\\\\"|"[^"\\\\]"|"[^"].*?[^\\\\]"',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => '<files>',
'regex' => '<.*?>',
'style' => 'string',
'childregex' => []
},
{
'name' => 'comment',
'regex' => '[^/]/\\*.*?\\*/',
'style' => 'comment',
'childregex' => []
}
]
},
{
'name' => 'character constant',
'regex' => '\'(\\\\)?.\'',
'style' => 'character',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => 'numeric constant',
'regex' => '\\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\\.?[0-9]*)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f)?\\b',
'style' => 'numeric',
'childregex' => []
},
{
'name' => 'storage keyword',
'regex' => '\\b(const|extern|auto|register|static|unsigned|signed|volatile|char|double|float|int|long|short|void|typedef|struct|union|enum)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'keyword',
'regex' => '\\b(return|goto|if|else|case|default|switch|break|continue|while|do|for|sizeof)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'braces',
'regex' => '[\\{\\}]',
'style' => 'braces',
'childregex' => []
},
{
'name' => 'symbols',
'regex' => '([\\*\\-\\+=:;%&\\|<>\\(\\)\\[\\]!])',
'style' => 'symbol',
'childregex' => []
},
{
'name' => 'identifiers',
'regex' => '([a-zA-Z_][a-zA-Z_0-9]*)',
'style' => 'identifier',
'childregex' => []
}
]
};

# taken from nedit
# modified by PP
$LANGUAGE{'c++'} = {
'filename' => '\\.(c(c|pp|xx)|h(h|pp|xx)|C(C|PP|XX)?|H(H|PP|XX)?|i)$',
'regex' => '',
'patterns' => [
{
'name' => 'doc comment',
'regex' => '/\\*\\*.*?\\*/',
'style' => 'doc comment',
'childregex' => []
},
{
'name' => 'comment',
'regex' => '/\\*.*?\\*/',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'cplus comment',
'regex' => '//.*?$',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'string',
'regex' => '""|"\\\\\\\\"|".*?([^\\\\](\\\\\\\\)*)"',

# 'regex' => '""|"\\\\\\\\"|"[^"\\\\]"|"[^"].*?[^\\\\]"',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => 'preprocessor line',
'regex' => '^[ \\t]*#.*?$',
'style' => 'preprocessor',
'childregex' => [
{
'name' => 'string',
'regex' => '""|".*?([^\\\\](\\\\\\\\)*)"|"\\\\\\\\"',

# 'regex' => '""|"\\\\\\\\"|"[^"\\\\]"|"[^"].*?[^\\\\]"',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => '<files>',
'regex' => '<.*?>',
'style' => 'string',
'childregex' => []
},
{
'name' => 'comment',
'regex' => '[^/]/\\*.*?\\*/',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'cplus comment',
'regex' => '//.*?$',
'style' => 'comment',
'childregex' => []
}
]
},
{
'name' => 'character constant',
'regex' => '\'(\\\\)?.\'',
'style' => 'character',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => 'numeric constant',
'regex' => '\\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\\.?[0-9]*)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f)?\\b',
'style' => 'numeric',
'childregex' => []
},
{
'name' => 'storage keyword',
'regex' =>
'\\b(class|typename|typeid|template|friend|virtual|inline|explicit|operator|overload|public|private|protected|const|extern|auto|register|static|mutable|unsigned|signed|volatile|char|double|float|int|long|short|bool|wchar_t|void|typedef|struct|union|enum)\\b',
'style' => 'reserved word',
'childregex' => [],
},
{
'name' => 'keyword',
'regex' =>
'\\b(new|delete|this|return|goto|if|else|case|default|switch|break|continue|while|do|for|catch|throw|sizeof|true|false|namespace|using|dynamic_cast|static_cast|reinterpret_cast)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'braces',
'regex' => '[\\{\\}]',
'style' => 'braces',
'childregex' => []
},
{
'name' => 'symbols',
'regex' => '([\\*\\-\\+=:;%&\\|<>\\(\\)\\[\\]!])',
'style' => 'symbol',
'childregex' => []
},
{
'name' => 'identifiers',
'regex' => '([a-zA-Z_][a-zA-Z_0-9]*)',
'style' => 'identifier',
'childregex' => []
}
]
};
$LANGUAGE{'cc'} = $LANGUAGE{'c++'};
$LANGUAGE{'cpp'} = $LANGUAGE{'c++'};
$LANGUAGE{'cxx'} = $LANGUAGE{'c++'};

# written by VRS
$LANGUAGE{'gpasm'} = {
'filename' => '(?i)\\.(asm|inc)$',
'regex' => '',
'patterns' => [
{
'name' => 'args',
'regex' => '^.*$',
'style' => 'symbol',
'childregex' => [
{
'name' => 'comment',
'regex' => ';.*?$',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'labels',
'regex' => '^[A-Za-z_][A-Za-z_0-9]*:?',
'style' => 'identifier',
'childregex' => []
},

{
'name' => 'menonics',
'regex' => '^[ \t]+[A-Za-z_][A-Za-z_0-9]*',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'string',
'regex' => '""|".*?([^\\\\](\\\\\\\\)*)"|"\\\\\\\\"',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
}

]
}
]
};

# written by JA
$LANGUAGE{'groff'} = {
'filename' => '\\.groff$',
'regex' => '',
'patterns' => [
{
'name' => 'comment',
'regex' => '\\\\".*?$',
'style' => 'comment',
'childregex' => []
}
]
};

# taken from nedit
# modified by PP
$LANGUAGE{'html'} = {
'filename' => '(?i)\\.html?$',
'regex' => '',
'patterns' => [
{
'name' => 'comment',
'regex' => '<!--.*?-->',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'entity',
'regex' => '\\&[-.a-zA-Z0-9#]*;?',
'style' => 'entity',
'childregex' => []
},
{
'name' => 'tag',
'regex' => '<(/|!)?[-.a-zA-Z0-9]*.*?>',
'style' => 'predefined identifier',
'childregex' => [
{
'name' => 'double quote string',
'regex' => '".*?"',
'style' => 'string',
'childregex' => []
},
{
'name' => 'single quote string',
'regex' => '\'.*?\'',
'style' => 'string',
'childregex' => []
},
{
'name' => 'brackets',
'regex' => '[<>]',
'style' => 'braces',
'childregex' => []
},
{
'name' => 'attribute',
'regex' => '[^\'" ]+(?=.)',
'style' => 'identifier',
'childregex' => []
}
]
}
]
};

# taken from nedit
# modified by PP
$LANGUAGE{'java'} = {
'filename' => '\\.java$',
'regex' => '',
'patterns' => [
{
'name' => 'doc comment',
'regex' => '/\\*\\*.*?\\*/',
'style' => 'doc comment',
'childregex' => []
},
{
'name' => 'comment',
'regex' => '/\\*.*?\\*/',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'cplus comment',
'regex' => '//.*?$',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'string',
'regex' => '""|".*?([^\\\\](\\\\\\\\)*)"|"\\\\\\\\"',

# 'regex' => '""|"\\\\\\\\"|"[^"\\\\]"|"[^"].*?[^\\\\]"',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => 'single quoted',
'regex' => '\'\'|\'.*?([^\\\\](\\\\\\\\)*)\'|\'\\\\\\\\\'',

# 'regex' => '\'\'|\'\\\\\\\\\'|\'[^\'\\\\]\'|\'[^\'].*?[^\\\\]\'',
'style' => 'string',
'childregex' => []
},
{
'name' => 'numeric constant',
'regex' => '\\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\\.?[0-9]*)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f)?\\b',
'style' => 'numeric',
'childregex' => []
},
{
'name' => 'include',
'regex' => '\\b(import|package)\\b.*?$',
'style' => 'include',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\(.|\\n)',
'style' => 'esc character',
'childregex' => []
},
{
'name' => 'comment',
'regex' => '[^/]/\\*.*?\\*/',
'style' => 'comment',
'childregex' => []
}
]
},
{
'name' => 'storage keyword',
'regex' =>
'\\b(abstract|boolean|byte|char|class|double|extends|final|float|int|interface|long|native|private|protected|public|short|static|transient|synchronized|void|volatile|implements)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'keyword',
'regex' =>
'\\b(break|case|catch|continue|default|do|else|false|finally|for|if|instanceof|new|null|return|super|switch|this|throw|throws|true|try|while)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'braces and parens',
'regex' => '[\\{\\}\\(\\)\\[\\]]',
'style' => 'braces',
'childregex' => []
},
{
'name' => 'Identifiers',
'regex' => '\\b[a-zA-Z_][a-zA-Z0-9_]*\\b',
'style' => 'identifier',
'childregex' => []
},
{
'name' => 'symbols',
'regex' => '([\\*\\-\\+=:;%&\\|<>!])',
'style' => 'symbol',
'childregex' => []
}
]
};

# taken from nedit
# modified by PP
$LANGUAGE{'javascript'} = {
'filename' => '(?i)\\.js$',
'regex' => '',
'patterns' => [
{
'name' => 'comment',
'regex' => '/\\*.*?\\*/',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'cplus comment',
'regex' => '//.*?$',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'numeric constant',
'regex' => '\\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\\.?[0-9]*)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f)?\\b',
'style' => 'numeric',
'childregex' => []
},
{
'name' => 'events',
'regex' =>
'\\b(onAbort|onBlur|onClick|onChange|onDblClick|onDragDrop|onError|onFocus|onKeyDown|onKeyPress|onLoad|onMouseDown|onMouseMove|onMouseOut|onMouseOver|onMouseUp|onMove|onResize|onSelect|onSubmit|onUnload)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'braces',
'regex' => '[\\{\\}]',
'style' => 'braces',
'childregex' => []
},
{
'name' => 'statements',
'regex' => '\\b(break|continue|else|for|if|in|new|return|this|typeof|var|while|with)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'function',
'regex' => 'function[\\t ]+([a-zA-Z0-9_]+)[\\t \\(]+.*?[\\n{]',
'style' => 'function header',
'childregex' => [
{
'name' => 'function args',
'regex' => '\\(.*?\\)',
'style' => 'function header args',
'childregex' => []
},
{
'name' => 'function name',
'regex' => '[\\t ][a-zA-Z0-9_]+',
'style' => 'function header name',
'childregex' => []
}
]
},
{
'name' => 'built in object type',
'regex' =>
'\\b(anchor|Applet|Area|Array|button|checkbox|Date|document|elements|FileUpload|form|frame|Function|hidden|history|Image|link|location|Math|navigator|Option|password|Plugin|radio|reset|select|string|submit|text|textarea|window)\\b',
'style' => 'predefined type',
'childregex' => []
},
{
'name' => 'string',
'regex' => '".*?("|$)',
'style' => 'string',
'childregex' => [
{
'name' => 'colors',
'regex' =>
'(aliceblue|antiquewhite|aqua|aquamarine|azure|beige|bisque|black|blanchedalmond|blue|blueviolet|brown|burlywood|cadetblue|chartreuse|chocolate|coral|cornflowerblue|cornsilk|crimson|cyan|darkblue|darkcyan|darkgoldenrod|darkgray|darkgreen|darkkhaki|darkmagenta|darkolivegreen|darkorange|darkorchid|darkred|darksalmon|darkseagreen|darkslateblue|darkslategray|darkturquoise|darkviolet|deeppink|deepskyblue|dimgray|dodgerblue|firebrick|floralwhite|forestgreen|fuchsia|gainsboro|ghostwhite|gold|goldenrod|gray|green|greenyellow|honeydew|hotpink|indianred|indigo|ivory|khaki|lavender|lavenderblush|lawngreen|lemonchiffon|lightblue|lightcoral|lightcyan|lightgoldenrodyellow|lightgreen|lightgrey|lightpink|lightsalmon|lightseagreen|lightskyblue|lightslategray|lightsteelblue|lightyellow|lime|limegreen|linen|magenta|#008000|mediumaquamarine|mediumblue|mediumorchid|mediumpurple|mediumseagreen|mediumslateblue|mediumspringgreen|mediumturquoise|mediumvioletred|midnightblue|mintcream|mistyrose|moccasin|navajowhite|navy|oldlace|olive|olivedrab|orange|orangered|orchid|palegoldenrod|palegreen|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|powderblue|purple|red|rosybrown|royalblue|saddlebrown|salmon|sandybrown|seagreen|seashell|sienna|silver|skyblue|slateblue|slategray|snow|springgreen|steelblue|tan|teal|thistle|tomato|turquoise|violet|wheat|white|whitesmoke|yellow|yellowgreen|#[A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9])',
'style' => 'identifier',
'childregex' => []
}
]
},
{
'name' => 'string',
'regex' => '\'.*?(\'|$)',
'style' => 'string',
'childregex' => [
{
'name' => 'colors',
'regex' =>
'(aliceblue|antiquewhite|aqua|aquamarine|azure|beige|bisque|black|blanchedalmond|blue|blueviolet|brown|burlywood|cadetblue|chartreuse|chocolate|coral|cornflowerblue|cornsilk|crimson|cyan|darkblue|darkcyan|darkgoldenrod|darkgray|darkgreen|darkkhaki|darkmagenta|darkolivegreen|darkorange|darkorchid|darkred|darksalmon|darkseagreen|darkslateblue|darkslategray|darkturquoise|darkviolet|deeppink|deepskyblue|dimgray|dodgerblue|firebrick|floralwhite|forestgreen|fuchsia|gainsboro|ghostwhite|gold|goldenrod|gray|green|greenyellow|honeydew|hotpink|indianred|indigo|ivory|khaki|lavender|lavenderblush|lawngreen|lemonchiffon|lightblue|lightcoral|lightcyan|lightgoldenrodyellow|lightgreen|lightgrey|lightpink|lightsalmon|lightseagreen|lightskyblue|lightslategray|lightsteelblue|lightyellow|lime|limegreen|linen|magenta|#008000|mediumaquamarine|mediumblue|mediumorchid|mediumpurple|mediumseagreen|mediumslateblue|mediumspringgreen|mediumturquoise|mediumvioletred|midnightblue|mintcream|mistyrose|moccasin|navajowhite|navy|oldlace|olive|olivedrab|orange|orangered|orchid|palegoldenrod|palegreen|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|powderblue|purple|red|rosybrown|royalblue|saddlebrown|salmon|sandybrown|seagreen|seashell|sienna|silver|skyblue|slateblue|slategray|snow|springgreen|steelblue|tan|teal|thistle|tomato|turquoise|violet|wheat|white|whitesmoke|yellow|yellowgreen|#[A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9])',
'style' => 'identifier',
'childregex' => [],
}
]
},
{
'name' => 'event capturing',
'regex' => '\\b(captureEvents|releaseEvents|routeEvent|handleEvent)\\b.*?(\\)|$)',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'predefined methods',
'regex' =>
'\\b(abs|acos|alert|anchor|asin|atan|atan2|back|big|blink|blur|bold|ceil|charAt|clear|clearTimeout|click|close|confirm|cos|escape|eval|exp|fixed|floor|focus|fontcolor|fontsize|forward|getDate|getDay|getHours|getMinutes|getMonth|getSeconds|getTime|getTimezoneOffset|getYear|go|indexOf|isNaN|italics|javaEnabled|join|lastIndexOf|link|log|max|min|open|parse|parseFloat|parseInt|pow|prompt|random|reload|replace|reset|reverse|round|scroll|select|setDate|setHours|setMinutes|setMonth|setSeconds|setTimeout|setTime|setYear|sin|small|sort|split|sqrt|strike|sub|submit|substring|sup|taint|tan|toGMTString|toLocaleString|toLowerCase|toString|toUpperCase|unescape|untaint|UTC|write|writeln)\\b',
'style' => 'library function',
'childregex' => []
},
{
'name' => 'properties',
'regex' =>
'\\b(action|alinkColor|anchors|appCodeName|appName|appVersion|bgColor|border|checked|complete|cookie|defaultChecked|defaultSelected|defaultStatus|defaultValue|description|E|elements|enabledPlugin|encoding|fgColor|filename|forms|frames|hash|height|host|hostname|href|hspace|index|lastModified|length|linkColor|links|LN2|LN10|LOG2E|LOG10E|lowsrc|method|name|opener|options|parent|pathname|PI|port|protocol|prototype|referrer|search|selected|selectedIndex|self|SQRT1_2|SQRT2|src|status|target|text|title|top|type|URL|userAgent|value|vlinkColor|vspace|width|window)\\b',
'style' => 'predefined identifier',
'childregex' => []
},
{
'name' => 'operators',
'regex' => '([=;->/&|])',
'style' => 'symbol',
'childregex' => []
}
]
};
$LANGUAGE{'js'} = $LANGUAGE{'javascript'};

# written by Andreas Krennmair
# extremely incomplete

$LANGUAGE{'lisp'} = {
'filename' => '\\.(lsp|l)$',
'regex' => '',
'patterns' => [
{
'name' => 'parens',
'regex' => '[()]',
'style' => 'braces',
'childregex' => []
},
{
'name' => 'comment',
'regex' => ';.*?$',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'string',
'regex' => '".*?("|$)',
'style' => 'string',
'childregex' => []
},
{
'name' => 'keywords',
'regex' => '\\b(defun |xyz)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'numeric constant',
'regex' => '(#\([0-9]+ [0-9]+\)|[0-9]+)',
'style' => 'numeric',
'childregex' => []
},
{
'name' => 'identifiers',
'regex' => '([-a-zA-Z]+)',
'style' => 'identifier',
'childregex' => []
}
]
};

# written by JA
$LANGUAGE{'m4'} = {
'filename' => '\\.m4$',
'regex' => '',
'patterns' => [
{
'regex' => 'dnl.*?$',
'style' => 'doc comment',
'childregex' => []
},
{
'regex' => '#.*?$',
'style' => 'comment',
'childregex' => []
},
{
'regex' =>
'\\b(define|undefine|defn|pushdef|popdef|indir|builtin|changequote|changecom|changeword|m4wrap|m4exit|include|sinclude|divert|undivert|divnum|cleardiv|shift|dumpdef|traceon|traceoff|debugfile|debugmode|len|index|regexp|substr|translit|patsubst|format|incr|decr|syscmd|esyscmd|sysval|maketemp|errprint)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'regex' => '\\b(ifdef|ifelse|loops)\\b',
'style' => 'reserved word',
'childregex' => [
{
'regex' => '[$]\\$?({[^}]*}|[^a-zA-Z0-9_/\\t\\n\\.,\\\\[\\\\{\\\\(]|[0-9]+|[a-zA-Z_][a-zA-Z0-9_]*)?',
'style' => 'identifier',
'childregex' => []
}
]
}
]
};

# taken from nedit
# modified by PP
$LANGUAGE{'make'} = {
'filename' => '[Mm]akefile.*',
'regex' => '',
'patterns' => [
{
'name' => 'Comment',
'regex' => '#.*?$',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'Assignment',
'regex' => '^( *| [ \\t]*)[A-Za-z0-9_+]*[ \\t]*(\\+|:)?=',
'style' => 'assignment',
'childregex' => []
},
{
'name' => 'Dependency Line',
'regex' => '^ *([A-Za-z0-9./$(){} _%+-]|\\n)*::?',
'style' => 'dependency line',
'childregex' => [
{
'name' => 'Dependency Target',
'regex' => '[A-Za-z0-9./$(){} _%+-]+',
'style' => 'dependency target',
'childregex' => []
},
{
'name' => 'Dependency Continuation',
'regex' => '\\\\\\n',
'style' => 'dependency continuation',
'childregex' => []
},
{
'name' => 'comment',
'regex' => '#.*?$',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'macro',
'regex' => '\\$([A-Za-z0-9_]|\\([^)]*\\)|{[^}]*})',
'style' => 'macro',
'childregex' => []
},
{
'name' => 'int macro',
'regex' => '\\$([<@*?%]|\\$@)',
'style' => 'int macro',
'childregex' => []
}
]
},
{
'name' => 'Continuation',
'regex' => '\\\\$',
'style' => 'continuation',
'childregex' => []
},
{
'name' => 'Macro',
'regex' => '\\$([A-Za-z0-9_]|\\([^)]*\\)|{[^}]*})',
'style' => 'macro',
'childregex' => []
},
{
'name' => 'Internal Macro',
'regex' => '\\$([<@*?%]|\\$@)',
'style' => 'int macro',
'childregex' => []
},
{
'name' => 'Escaped $$$',
'regex' => '\\$\\$',
'style' => 'esc $$$',
'childregex' => []
},
{
'name' => 'Include',
'regex' => '^include[ \\t]',
'style' => 'include',
'childregex' => []
}
]
};
$LANGUAGE{'makefile'} = $LANGUAGE{'make'};

# taken from nedit
# modified by PP
$LANGUAGE{'pas'} = {
'filename' => '(?i)\\.p(as)?$',
'regex' => '',
'patterns' => [
{
'name' => 'comment1 (* *)',
'regex' => '\\(\\*.*?\\*\\)',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'comment2 { }',
'regex' => '\\{.*?\\}',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'string',
'regex' => '\'.*?(\'|$)',
'style' => 'string',
'childregex' => []
},
{
'name' => 'preprocessor line',
'regex' => '^[ \\t]*#.*?$',
'style' => 'preprocessor',
'childregex' => [
{
'name' => 'comment1 (* *)',
'regex' => '\\(\\*.*?\\*\\)',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'comment2 { }',
'regex' => '\\{.*?\\}',
'style' => 'comment',
'childregex' => []
}
]
},
{
'name' => 'character constant',
'regex' => '\'.\'',
'style' => 'character',
'childregex' => []
},
{
'name' => 'numeric constant',
'regex' => '\\b((0(x|X)[0-9a-fA-F]*)|[0-9.]+((e|E)(\\+|-)?)?[0-9]*)(L|l|UL|ul|u|U|F|f)?\\b',
'style' => 'numeric',
'childregex' => []
},
{
'name' => 'storage and ops',
'regex' =>
'\\b(?i)(and|array|const|div|export|file|function|import|in|label|mod|module|nil|not|only|or|packed|pow|pragma|procedure|program|protected|qualified|record|restricted|set|type|var)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'keywords',
'regex' => '\\b(?i)(begin|case|do|downto|else|end|for|goto|if|of|otherwise|repeat|then|to|until|while|with)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'sumbols',
'regex' => '([\\*\\-\\+=:;<>\\(\\)\\[\\]!]|[^/]/[^/])',
'style' => 'symbol',
'childregex' => []
},
{
'name' => 'identifiers',
'regex' => '([a-zA-Z_][a-zA-Z_0-9.^]*[a-zA-Z_0-9]|[a-zA-Z_][a-zA-Z_0-9]*)',
'style' => 'identifier',
'childregex' => [
{
'regex' => '(\\.|\\^)+',
'style' => 'symbol',
'childregex' => []
}
]
}
],
};
$LANGUAGE{'pascal'} = $LANGUAGE{'pas'};

# taken from nedit
# modified by PP
# modified by BS
# modified by JD
# modified by JP
$LANGUAGE{'perl'} = {
'filename' => '(?i)\\.p([lm5]|od)$',
'regex' => '^\\s*#\\s*![^\\s]*perl',
'patterns' => [
{
'name' => 'comment',
'regex' => '(?:#.*?(?:\r?\n\s*)+)+',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'variables',
'regex' => '[\\$@%]\\$?(?:{[^}]*}|[^a-zA-Z0-9_/\\t\\n\\.,\\\\[\\\\{\\\\(]|[0-9]+|[a-zA-Z_][a-zA-Z0-9_]*)?',
'style' => 'identifier',
'childregex' => []
},
{
'name' => '"" string',
'regex' => '""|".*?([^\\\\](\\\\\\\\)*)"|"\\\\\\\\"',

# 'regex' => '""|"\\\\\\\\"|"[^"\\\\]"|"[^"].*?[^\\\\]"',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
},
{
'name' => 'variables',
'regex' => '[\\$@%]\\$?(?:{[^}]*}|[^a-zA-Z0-9_/\\t\\n\\.,\\\\[\\\\{\\\\(]|[0-9]+|[a-zA-Z_][a-zA-Z0-9_]*)?',
'style' => 'identifier',
'childregex' => []
}
]
},
{
'name' => '\'\' string',
'regex' => '\'\'|\'.*?([^\\\\](\\\\\\\\)*)\'|\'\\\\\\\\\'',

# 'regex' => '\'\'|\'\\\\\\\\\'|\'[^\'\\\\]\'|\'[^\'].*?[^\\\\]\'',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => 'more strings - q// qw//',
'regex' => '(?:\\b| )(?:q|qw)([^\w\s])(?:\\\\\\2|[^\\2\\n])*\\2',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => 'more strings - qq// qx//',
'regex' => '(?:\\b| )(?:qq|qx)([^\w\s])(?:\\\\\\2|[^\\2\\n])*\\2',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
},
{
'name' => 'variables',
'regex' => '[\\$@%]\\$?(?:{[^}]*}|[^a-zA-Z0-9_/\\t\\n\\.,\\\\[\\\\{\\\\(]|[0-9]+|[a-zA-Z_][a-zA-Z0-9_]*)?',
'style' => 'identifier',
'childregex' => []
}
]
},
{
'name' => 'subroutine header',
'regex' => 'sub[\\t ]+(?:[a-zA-Z0-9_]+)[\\t \\n]*(?:\\{|\\(|\\n)',
'style' => 'function header',
'childregex' => [
{
'name' => 'subroutine header coloring',
'regex' => '[\\t ][a-zA-Z0-9_]+',
'style' => 'function header name',
'childregex' => []
}
]
},
{
'name' => 'regex matching I',
'regex' => '(?:\\b| )?(?:/(?:\\\\/|[^/\\n])*(?:/[gimesox]*)|s([^\w\s])(?:\\\\\\2|[^\\2\\n])*?(\\2)[^(\\2)\\n]*?(\\2[gimesox]*))',
'style' => 'regex',
'childregex' => []
},
{
'name' => 'regex matching II',
'regex' => '(?:\\b| )(?:m|qq?|tr|y)([^\w\s])(?:\\\\\\2|[^\\2\\n])*(?:\\2[gimesox]*)',
'style' => 'regex',
'childregex' => []
},
{
'name' => 'keywords',
'regex' =>
'\\b(my|local|new|if|until|while|elsif|else|eval|unless|for|foreach|continue|exit|die|last|goto|next|redo|return|local|exec|do|use|require|package|eval|BEGIN|END|eq|ne|not|\\|\\||\\&\\&|and|or)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'library functions',
'regex' =>
'\\b(?:a(?:bs|ccept|larm|tan2)|b(?:ind|inmode|less)|c(?:aller|hdir|hmod|homp|hop|hr|hroot|hown|losedir|lose|onnect|os|rypt)|d(?:bmclose|bmopen|efined|elete|ie|ump)|e(?:ach|nd(?:grent|hostent|netent|protoent|pwent|servent)|of|xec|xists|xp)|f(?:ctnl|ileno|lock|ork|ormat|ormline)|g(?:et(?:c|grent|grgid|grnam|hostbyaddr|hostbyname|hostent|login|netbyaddr|netbyname|netent|peername|pgrp|ppid|priority|protobyname|protobynumber|protoent|pwent|pwnam|pwuid|servbyname|servbyport|servent|sockname|sockopt)|lob|mtime|rep)|hex|i(?:mport|ndex|nt|octl)|join|keys|kill|l(?:cfirst|c|ength|ink|isten|og|ocaltime|stat)|m(?:ap|kdir|sgctl|sgget|sgrcv)|no|o(?:ct|pendir|pen|rd)|p(?:ack|ipe|op|os|rintf|rint|ush)|quotemeta|r(?:and|eaddir|ead|eadlink|ecv|ef|ename|eset|everse|ewinddir|index|mdir)|s(?:calar|eekdir|eek|elect|emctl|emget|emop|end|et(?:grent|hostent|netent|pgrp|priority|protoent|pwent|sockopt)|hift|hmctl|hmget|hmread|hmwrite|hutdown|in|leep|ocket|ocketpair|ort|plice|plit|printf|qrt|rand|tat|tudy|ubstr|ymlink|yscall|ysopen|ysread|ystem|yswrite)|t(?:elldir|ell|ie|ied|ime|imes|runcate)|u(?:c|cfirst|mask|ndef|nlink|npack|nshift|ntie|time)|values|vec|w(?:ait|aitpid|antarray|arn|rite)|qw|-[rwxoRWXOezsfdlpSbctugkTBMAC])\\b',
'style' => 'library function',
'childregex' => []
},
{
'name' => 'braces, parens and brakets',
'regex' => '[\\[\\]\\{\\}\\(\\)]',
'style' => 'braces',
'childregex' => []
},
{
'name' => '<< stuff',
'regex' => '<<(?:("|\')([^\\n]*)\\2|\\w*).*?^\\3$',
'style' => 'text',
'childregex' => []
},
{
'name' => 'POD',
'regex' => '^=.*?^(?:=cut|\\Z)',
'style' => 'doc comment',
'childregex' => []
}
]
};

# Thanks to Matt Giwer <jull43@ij.net>
$LANGUAGE{'pov'} = {
'filename' => '(?i)\\.pov$',
'regex' => '',
'patterns' => [
{
'name' => 'doc comment',
'regex' => '/\\*\\*.*?\\*/',
'style' => 'doc comment',
'childregex' => []
},
{
'name' => 'comment',
'regex' => '/\\*.*?\\*/',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'cplus comment',
'regex' => '//.*?$',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'string',
'regex' => '""|".*?([^\\\\](\\\\\\\\)*)"|"\\\\\\\\"',

# 'regex' => '""|"\\\\\\\\"|"[^"\\\\]"|"[^"].*?[^\\\\]"',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => 'preprocessor line',
'regex' => '^[ \\t]*#.*?$',
'style' => 'preprocessor',
'childregex' => [
{
'name' => 'string',
'regex' => '""|".*?([^\\\\](\\\\\\\\)*)"|"\\\\\\\\"',

# 'regex' => '""|"\\\\\\\\"|"[^"\\\\]"|"[^"].*?[^\\\\]"',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => '<files>',
'regex' => '<.*?>',
'style' => 'string',
'childregex' => []
},
{
'name' => 'comment',
'regex' => '[^/]/\\*.*?\\*/',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'cplus comment',
'regex' => '//.*?$',
'style' => 'comment',
'childregex' => []
}
]
},
{
'name' => 'character constant',
'regex' => '\'(\\\\)?.\'',
'style' => 'character',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex'<;/span> => []
}
]
},
{
'name' => 'numeric constant',
'regex' => '\\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\\.?[0-9]*)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f)?\\b',
'style' => 'numeric',
'childregex' => []
},
{
'name' => 'keyword',
'regex' =>
'\\b(abs|absorption|acos|acosh|adaptive|adc_bailout|agate|agate_turb|all|alpha|ambient|ambient_light|angle|aperture|append|arc_angle|area_light|array|asc|asin|asinh|assumed_gamma|atan|atan2|atanh|average|background|bezier_spline|bicubic_patch|black_hole|blob|blue|blur_samples|bounded_by|box|boxed|bozo|break|brick|brick_size|brightness|brilliance|bumps|bump_map|bump_size|camera|case|caustics|ceil|checker|chr|clipped_by|clock|clock_delta|color|color_map|colour|colour_map|component|composite|concat|cone|confidence|conic_sweep|control0|control1|cos|cosh|count|crackle|crand|cube|cubic|cubic_spline|cubic_wave|cylinder|cylindrical|debug|declare|default|defined|degrees|density|density_file|density_map|dents|difference|diffuse|dimensions|dimension_size|direction|disc|distance|distance_maximum|div|eccentricity|else|emission|end|error|error_bound|exp|extinction|fade_distance|fade_power|falloff|falloff_angle|false|fclose|file_exists|filter|finish|fisheye|flatness|flip|floor|focal_point|fog|fog_alt|fog_offset|fog_type|fopen|frequency|gif|global_settings|gradient|granite|gray_threshold|green|height_field|hexagon|hf_gray_16|hierarchy|hollow|hypercomplex|if|ifdef|iff|ifndef|image_map|include|int|interior|interpolate|intersection|intervals|inverse|ior|irid|irid_wavelength|jitter|julia_fractal|lambda|lathe|leopard|light_source|linear_spline|linear_sweep|local|location|log|looks_like|look_at|low_error_factor|macro|mandel|map_type|marble|material|material_map|matrix|max|max_intersections|max_iteration|max_trace_level|media|media_attenuation|media_interaction|merge|mesh|metallic|min|minimum_reuse|mod|mortar|nearest_count|no|normal|normal_map|no_shadow|number_of_waves|object|octaves|off|offset|omega|omnimax|on|once|onion|open|orthographic|panoramic|perspective|pgm|phase|phong|phong_size|pi|pigment|pigment_map|planar|plane|png|point_at|poly|polygon|poly_wave|pot|pow|ppm|precision|prism|pwr|quadratic_spline|quadric|quartic|quaternion|quick_color|quick_colour|quilted|radial|radians|radiosity|radius|rainbow|ramp_wave|rand|range|ratio|read|reciprocal|recursion_limit|red|reflection|reflection_exponent|refraction|render|repeat|rgb|rgbf|rgbft|rgbt|right|ripples|rotate|roughness|samples|scale|scallop_wave|scattering|seed|shadowless|sin|sine_wave|sinh|sky|sky_sphere|slice|slope_map|smooth|smooth_triangle|sor|specular|sphere|spherical|spiral1|spiral2|spotlight|spotted|sqr|sqrt|statistics|str|strcmp|strength|strlen|strlwr|strupr|sturm|substr|superellipsoid|switch|sys|t|tan|tanh|text|texture|texture_map|tga|thickness|threshold|tightness|tile2|tiles|torus|track|transform|translate|transmit|triangle|triangle_wave|true|ttf|turbulence|turb_depth|type|u|ultra_wide_angle|undef|union|up|use_color|use_colour|use_index|u_steps|v|val|variance|vaxis_rotate|vcross|vdot|version|vlength|vnormalize|vrotate|v_steps|warning|warp|water_level|waves|while|width|wood|wrinkles|write|x|y|yes|z)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'braces',
'regex' => '[\\{\\}]',
'style' => 'braces',
'childregex' => []
},
{
'name' => 'symbols',
'regex' => '([\\*\\-\\+=:;%&\\|<>\\(\\)\\[\\]!])',
'style' => 'symbol',
'childregex' => []
},
{
'name' => 'identifiers',
'regex' => '([a-zA-Z_][a-zA-Z_0-9]*)',
'style' => 'identifier',
'childregex' => []
}
]
};
$LANGUAGE{'povray'} = $LANGUAGE{'pov'};

# by Tom Good
$LANGUAGE{'python'} = {
'filename' => '(?i)\\.py$',
'regex' => '^\\s*#\\s*![^\\s]*python',
'patterns' => [
{
'name' => 'python comment',
'regex' => '#.*?$',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'single quote string',
'regex' => '\'.*?\'',
'style' => 'string',
'childregex' => []
},

{
'name' => 'string',
'regex' => '""|"\\\\\\\\"|".*?([^\\\\](\\\\\\\\)*)"',
'regex' => '""|".*?([^\\\\](\\\\\\\\)*)"|"\\\\\\\\"',
'regex' => '""|"\\\\\\\\"|"[^"\\\\]"|"[^"].*?[^\\\\]"',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => 'character constant',
'regex' => '\'(\\\\)?.\'',
'style' => 'character',
'childregex' => [
{
'name' => 'esc character',
'regex' => '\\\\.',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => 'numeric constant',
'regex' => '\\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\\.?[0-9]*)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f)?\\b',
'style' => 'numeric',
'childregex' => []
},
{
'name' => 'keyword',
'regex' =>
'\\b(and|assert|break|class|continue|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|not|or|pass|print|raise|return|try|while)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'braces',
'regex' => '[\\{\\}]',
'style' => 'braces',
'childregex' => []
},
{
'name' => 'symbols',
'regex' => '([\\*\\-\\+=:;%&\\|<>\\(\\)\\[\\]!])',
'style' => 'symbol',
'childregex' => []
},
{
'name' => 'identifiers',
'regex' => '([a-zA-Z_][a-zA-Z_0-9]*)',
'style' => 'identifier',
'childregex' => []
},
{
'name' => 'function',
'regex' => '[\\t ]*def[\\t ]+([a-zA-Z0-9_]+)[\\t \\(]+.*?[\\n{]',
'style' => 'function header',
'childregex' => [
{
'name' => 'function args',
'regex' => '\\(.*?\\)',
'style' => 'function header args',
'childregex' => []
},
{
'name' => 'function name',
'regex' => '[\\t ][a-zA-Z0-9_]+',
'style' => 'function header name',
'childregex' => []
}
]
},
{
'name' => 'library functions',
'regex' =>
'\\b(__import__|abs|apply|buffer|callable|chr|cmp|coerce|compile|complex|delatter|dir|divmod|eval|execfile|filter|float|getattr|globals|hasattr|hash|hex|id|input|int|intern|isinstance|issubclass|len|list|locals|long|map|max|min|oct|open|ord|pow|range|raw_input|reduce|reload|repr|round|setattr|slice|str|tuple|type|unichr|unicode|vars|xrange|zip)\\b',
'style' => 'library function',
'childregex' => []
},
]
};

# by Joshua Swink <jswink@pacbell.net>
$LANGUAGE{'ruby'} = {
'filename' => '\\.rb$',
'regex' => '^\\s*#\\s*![^\\s]*\\bruby\\b',
'patterns' => [
{
'name' => 'comment',
'regex' => '(?:#.*?(?:\r?\n\s*)+)+',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'predefined variables',
'regex' =>
'(?:\\$(?:[!@&`\'+\\d~=/\\\\,;.<>_*\\$?:"]|DEBUG|FILENAME|LOAD_PATH|stdin|stdout|stderr|VERBOSE|-[0adFiIlpv])|\\b(?:TRUE|FALSE|NIL|STDIN|STDOUT|STDERR|ENV|ARGF|ARGV|DATA|RUBY_VERSION|RUBY_RELEASE_DATE|RUBY_PLATFORM)\\b)',
'style' => 'predefined identifier',
'childregex' => []
},
{
'name' => 'variables',
'regex' => '[\\$@](?:{[^}]*}|[^\\w/\\t\\n\\.,\\\\[\\\\{\\\\(]|[0-9]+|[a-zA-Z_][\\w.]*)?',
'style' => 'identifier',
'childregex' => []
},
{
'name' => '"" string',
'regex' =>
'""|"(?:\\\\\\\\)+"|".*?(?:[^\\\\](?:\\\\\\\\)*)"|%[Qwx]?([^\\w\\[\\](){}<>])\\2|%[Qwx]?([^\\w\\[\\](){}<>]).*?(?:[^\\\\](?:\\\\\\\\)*)\\3|%[Qwx]?([^\\w\\[\\](){}<>])\\\\\\\\\\4|%[Qwx]?\\[\\]|%[Qwx]?\\[.*?([^\\\\](\\\\\\\\)*)\\]|%[Qwx]?\\[\\\\\\\\\\]|%[Qwx]?\\{\\}|%[Qwx]?\\{.*?([^\\\\](\\\\\\\\)*)\\}|%[Qwx]?\\{\\\\\\\\\\}|%[Qwx]?\\(\\)|%[Qwx]?\\(.*?([^\\\\](\\\\\\\\)*)\\)|%[Qwx]?\\(\\\\\\\\\\)|%[Qwx]?<>|%[Qwx]?<.*?([^\\\\](\\\\\\\\)*)>|%[Qwx]?<\\\\\\\\>',

'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex', => '\\\\(?:x[\\da-fA-F]{2}|\d\d\d|c.|M-\\\\C-.|M-.|C-.|.)',
'style' => 'esc character',
'childregex' => []
},
{
'name' => 'string expression',
'regex' => '#[\\$\\@][a-zA-Z_][\\w.]*|#\\{[\\$\\@]?[^\\}]*\\}',
'style' => 'identifier',
'childregex' => []
}
]
},
{
'name' => '\'\' string',
'regex' =>
'\'\'|\'(?:\\\\\\\\)+\'|\'.*?(?:[^\\\\](?:\\\\\\\\)*)\'|%q([^\\w\\[\\](){}<>])\\2|%q([^\\w\\[\\](){}<>]).*?(?:[^\\\\](?:\\\\\\\\)*)\\3|%q([^\\w\\[\\](){}<>])\\\\\\\\\\4|%q\\[\\]|%q\\[.*?([^\\\\](\\\\\\\\)*)\\]|%q\\[\\\\\\\\\\]|%q\\{\\}|%q\\{.*?([^\\\\](\\\\\\\\)*)\\}|%q\\{\\\\\\\\\\}|%q\\(\\)|%q\\(.*?([^\\\\](\\\\\\\\)*)\\)|%q\\(\\\\\\\\\\)|%q<>|%q<.*?([^\\\\](\\\\\\\\)*)>|%q<\\\\\\\\>',
'style' => 'string',
'childregex' => [
{
'name' => 'esc character',
'regex' => '(?:\\\\\'|\\\\\\\\)',
'style' => 'esc character',
'childregex' => []
}
]
},
{
'name' => 'subroutine header',
'regex' => 'def[\\t ]+\\w[\\w.]*(?:\\([^)]*\\))?',
'style' => 'function header',
'childregex' => [
{
'name' => 'arg list',
'regex' => '\\(.*\\)',
'style' => 'function header args',
'childregex' => [
{
'name' => 'arg list parens',
'regex' => '[\\(\\)]',
'style' => 'symbol',
'childregex' => []
}
]
},
{
'name' => 'subroutine header',
'regex' => '[\\t ]\w+',
'style' => 'function header name',
'childregex' => []
}
]
},
{
'name' => 'class header',
'regex' => 'class[\\t ]+\\w+(?:\\s*<\\s*\\w+)?',
'style' => 'function header',
'childregex' => [
{
'name' => 'class ancestor',
'regex' => '<\\s*\\w+',
'style' => 'include',
'childregex' => [
{
'name' => 'inheritance doohickey',
'regex' => '<',
'style' => 'symbol',
'childregex' => []
}
]
},
{
'name' => 'class main',
'regex' => '[\\t ]\\w+',
'style' => 'type',
'childregex' => []
}
]
},
{
'name' => 'regex matching 0',
'regex' =>
'(?:%r([^\\w\\[\\](){}<>])\\2|%r([^\\w\\[\\](){}<>]).*?(?:[^\\\\](?:\\\\\\\\)*)\\3|%r([^\\w\\[\\](){}<>])\\\\\\\\\\4|%r\\[\\]|%r\\[.*?([^\\\\](\\\\\\\\)*)\\]|%r\\[\\\\\\\\\\]|%r\\{\\}|%r\\{.*?([^\\\\](\\\\\\\\)*)\\}|%r\\{\\\\\\\\\\}|%r\\(\\)|%r\\(.*?([^\\\\](\\\\\\\\)*)\\)|%r\\(\\\\\\\\\\)|%r<>|%r<.*?([^\\\\](\\\\\\\\)*)>|%r<\\\\\\\\>)[ixpno]*',
'style' => 'regex',
'childregex' => [
{
'name' => 'string expression',
'regex' => '#[\\$\\@][a-zA-Z_][\\w.]*|#\\{[\\$\\@]?[a-zA-Z_][^\\}]*\\}',
'style' => 'identifier',
'childregex' => []
}
]
},
{
'name' => 'regex matching I',
'regex' => '(?:\\b| )?(?:/(?:\\\\/|[^/\\n])*(?:/[ixpno]*))',
'style' => 'regex',
'childregex' => [
{
'name' => 'string expression',
'regex' => '#[\\$\\@][a-zA-Z_][\\w.]*|#\\{[\\$\\@]?[a-zA-Z_][^\\}]*\\}',
'style' => 'identifier',
'childregex' => []
}
]
},
{
'name' => 'reserved words',
'regex' =>
'\\b(BEGIN|class|ensure|nil|self|when|END|def|false|not|super|while|alias|defined|for|or|then|yield|and|do|if|redo|true|begin|else|in|rescue|undef|break|elsif|module|retry|unless|case|end|next|return|until)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'kernel module methods',
'regex', =>
'\\b(Array|Float|Integer|String|at_exit|autoload|binding|caller|catch|chop|chomp|chomp!|eval|exec|exit|fail|fork|format|gets|global_variables|gsub|iterator|lambda|load|local_variables|loop|open|p|print|printf|proc|putc|puts|raise|rand|readline|readlines|require|select|sleep|split|sprintf|srand|sub|syscall|system|test|trace_var|trap|untrace_var)\\b',
'style' => 'library function',
'childregex' => []
},
{
'name' => 'braces, parens and brakets',
'regex' => '[\\[\\]\\{\\}\\(\\)]',
'style' => 'braces',
'childregex' => []
},
{
'name' => '<< stuff',
'regex' => '<<(?:("|\')([^\\n]*)\\2|\\w*).*?^\\3$',
'style' => 'text',
'childregex' => []
},
{
'name' => 'symbols',
'regex' => '(?:[:*-+<>=^!,/]+|\.\.+)',
'style' => 'symbol',
'childregex' => []
},
{
'name' => 'numbers',
'regex' => '\d[\d.]*',
'style' => 'numeric',
'childregex' => []
},
{
'name' => 'embedded documentation',
'regex' => '^=.*?^(?:=end|\\Z)',
'style' => 'doc comment',
'childregex' => []
}
]
};

# taken from nedit
# modified by PP
# very inclomplete!
$LANGUAGE{'sql'} = {
'filename' => '(?i)\\.sql$',
'regex' => '',
'patterns' => [
{
'name' => 'keywords I',
'regex' => '(?i)(,|%|<|>|:=|=|\\(|\\)|\\bselect|on|from|order by|desc|where|and|or|not|null|true|false)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'comment I',
'regex' => '--.*?$',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'comment II',
'regex' => '/\\*.*?\\*/',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'string',
'regex' => '\'\'|\'.*?([^\\\\](\\\\\\\\)*)\'|\'\\\\\\\\\'',

# 'regex' => '(\'\'|\'[^\'\\\\]\'|\'[^\'].*?[^\\\\]\')',
'style' => 'string',
'childregex' => []
},
{
'name' => 'keywords II',
'regex' =>
'(?i)end if;|\\b(create|replace|begin|end|function|return|fetch|open|close|into|is|in|when|others|grant|on|to|exception|show|set|out|pragma|as|package)\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'keywords III',
'regex' => '(?i)\\balter\\b',
'style' => 'reserved word',
'childregex' => []
},
{
'name' => 'datatypes',
'regex' => '(?i)\\b(integer|blol|date|numeric|character|varying|varchar|char)\\b',
'style' => 'predefined type',
'childregex' => []
},
{
'name' => 'words',
'regex' => '(?i)\\b(constraint|key|references|primary|table|foreign|add|insert|group by)\\b',
'style' => 'reserved word',
'childregex' => []
}
]
};

$LANGUAGE{'patch'} = {
'filename' => '(?i)\\.patch$|\\.diff$',
'regex' => '',
'patterns' => [
{
'name' => 'header',
'regex' => '^Index: .*?$|^===== .*?$|^diff .*?$|^--- .*?$|^\+\+\+ .*?$',
'style' => 'separator',
'childregex' => []
},
{
'name' => 'hunk',
'regex' => '^@@ .*?$',
'style' => 'line spec',
'childregex' => []
},
{
'name' => 'from',
'regex' => '^-.*?$',
'style' => 'deletion',
'childregex' => []
},
{
'name' => 'to',
'regex' => '^\+.*?$',
'style' => 'insertion',
'childregex' => []
}
]
};

#####
#
# LANGUAGE: shell script
#

$LANGUAGE{'shellscript'} = {
'filename' => '\\.(sh|shell)$',
'regex' => '^\\s*#\\s*![^\\s]*(sh|bash|ash|zsh|ksh)',
'patterns' => [
{
'name' => 'comment',

# 'regex' => '^[ \t]*[^$]?\#[^!]?.*?$',
'regex' => '(^| )#([^\\!].)*?$',
'style' => 'comment',
'childregex' => []
},
{
'name' => 'identifier',
'regex' => '[a-zA-Z][a-zA-Z0-9_]*=',
'style' => '',
'childregex' => [
{
'name' => 'identifier',
'regex' => '[a-zA-Z][a-zA-Z0-9_]*',
'style' => 'identifier',
'childregex' => []
}
]
},
{
'name' => 'identifier',
'regex' => '\\$([0-9#\\*]|[a-zA-Z][a-zA-Z0-9_]*)',
'style' => 'identifier',
'childregex' => []
},
{
'name' => 'interpreter line',
'regex' => '^[ \t]*#!.*?$',
'style' => 'preprocessor',
childregex => []
},
{
'name' => 'string',
'regex' => '""|"(\\\\"|[^\\"])*"',
'style' => 'string',
childregex => [
{
'name' => 'identifier',
'regex' => '\\$([0-9#\\*]|[a-zA-Z][a-zA-Z0-9_]*)',
'style' => 'identifier',
'childregex' => []
}
]
}
]
};

$LANGUAGE{'sh'} = $LANGUAGE{'shellscript'};
return \%LANGUAGE;

}

Labels

perl (41) Cheat Sheet (25) how-to (24) sql server 2008 (13) windows (13) linux (12) oracle (12) sql (12) Unix (11) cmd windows batch (10) mssql (10) cmd (9) script (9) textpad (9) netezza (8) sql server 2005 (8) cygwin (7) meta data mssql (7) metadata (7) bash (6) code generation (6) Informatica (5) cheatsheet (5) energy (5) tsql (5) utilities (5) excel (4) future (4) generic (4) html (4) perl modules (4) programs (4) settings (4) sh (4) shortcuts (4) поуки (4) принципи (4) Focus Fusion (3) Solaris (3) cool programs (3) development (3) economy (3) example (3) freeware (3) fusion (3) git cheat sheet (3) logging (3) morphus (3) mssql 2005 (3) nuclear (3) nz (3) parse (3) python (3) sftp (3) sofware development (3) source (3) sqlplus (3) table (3) vim (3) .Net (2) C# (2) China (2) GUI (2) Google (2) GoogleCL (2) Solaris Unix (2) ascii (2) awk (2) batch (2) cas (2) chrome extensions (2) code2html (2) columns (2) configuration (2) conversion (2) duplicates (2) excel shortcuts (2) export (2) file (2) free programs (2) informatica sql repository (2) mssql 2008 (2) mysql (2) next big future (2) nsis (2) nz netezza cheat sheet (2) nzsql (2) ora (2) prediction (2) publish (2) release management (2) report (2) security (2) single-click (2) sqlserver 2005 (2) sqlserver 2008 (2) src (2) ssh (2) template (2) tools (2) vba (2) video (2) xlt (2) xml (2) youtube videos (2) *nix (1) .vimrc (1) .virmrc vim settings configs (1) BSD license (1) Bulgaria (1) Dallas (1) Database role (1) Dense plasma focus (1) Deployment (1) ERP (1) ExcelToHtml (1) GD (1) GDP (1) HP-UX (1) Hosting (1) INC (1) IT general (1) ITIL management bullshit-management (1) IZarc (1) Java Web Start (1) JavaScript anchor html jquery (1) Khan Academy (1) LINUX UNIX BASH AND CYGWIN TIPS AND TRICKS (1) Linux Unix rpm cpio build install configure (1) Linux git source build .configure make (1) ListBox (1) MIT HYDROGEN VIRUS (1) OO (1) Obama (1) PowerShell (1) Run-time (1) SDL (1) SIWA (1) SOX (1) Scala (1) Services (1) Stacks (1) SubSonic (1) TED (1) abstractions (1) ansible hosts linux bash (1) ansible linux deployment how-to (1) ansible yum pip python (1) apache (1) apache 2.2 (1) application life cycle (1) architecture (1) archive (1) arguments (1) avatar (1) backup (1) bash Linux open-ssh ssh ssh_server ssh_client public-private key authentication (1) bash perl search and replace (1) bash stub (1) bin (1) biofuels (1) biology (1) books (1) browser (1) bubblesort (1) bugs (1) build (1) byte (1) cas_sql_dev (1) chennai (1) chrome (1) class (1) claut (1) cmdow (1) code generation sqlserver (1) command (1) command line (1) conf (1) confluence (1) console (1) convert (1) cool programs windows free freeware (1) copy-paste (1) csv (1) ctags (1) current local time (1) cygwin X11 port-forwarding mintty xclock Linux Unix X (1) cygwin bash how-to tips_n_tricks (1) cygwin conf how-to (1) data (1) data types (1) db2 cheat sheet (1) db2 starter ibm bash Linux (1) debt (1) diagram (1) dictionaries (1) digital (1) disk (1) disk space (1) documentation (1) dos (1) dubai (1) e-cars (1) electric cars (1) electricity (1) emulate (1) errors (1) exponents (1) export workflow (1) extract (1) fast export (1) fexp (1) file extension (1) file permissions (1) findtag (1) firewall (1) for loop (1) freaky (1) functions (1) fusion research (1) german (1) git gitlab issues handling system (1) google cli (1) google code (1) google command line interface (1) gpg (1) ha (1) head (1) helsinki (1) history (1) hop or flop (1) host-independant (1) how-to Windows cmd time date datetime (1) ibm db2 cognos installation example db deployment provisioning (1) ideas (1) image (1) informatica oracle sql (1) informatica repo sql workflows sessions file source dir (1) informatica source files etl (1) install (1) it management best practices (1) java (1) jump to (1) keyboard shortcuts (1) ksh (1) level (1) linkedin (1) linux bash ansible hosts (1) linux bash commands (1) linux bash how-to shell expansion (1) linux bash shell grep xargs (1) linux bash tips and t ricks (1) linux bash unix cygwin cheatsheet (1) linux bash user accounts password (1) linux bash xargs space (1) linux cheat sheet (1) linux cheat-sheet (1) linux cheatsheet cheat-sheet revised how-to (1) linux how-to non-root vim (1) linux ssh hosts parallel subshell bash oneliner (1) london (1) make (1) me (1) metacolumn (1) metadata functions (1) metaphonre (1) method (1) model (1) movie (1) multithreaded (1) mysql cheat sheet (1) mysql how-to table datatypes (1) n900 (1) nano (1) neteza (1) netezza bash linux nps (1) netezza nps (1) netezza nps nzsql (1) netezza nz Linux bash (1) netezza nz bash linux (1) netezza nz nzsql sql (1) netezza nzsql database db sizes (1) non-password (1) nord pol (1) nps backup nzsql schema (1) number formatting (1) nz db size (1) nz table count rows (1) nzsql date timestamp compare bigint to_date to_char now (1) on-lier (1) one-liners (1) one-to-many (1) oneliners (1) open (1) open source (1) openrowset (1) oracle PL/SQL (1) oracle Perl perl (1) oracle installation usability (1) oracle number formatting format-model ora-sql oracle (1) oracle templates create table (1) oracle trigger generic autoincrement (1) oracle vbox virtual box cheat sheet (1) oracle virtual box cheat sheet (1) outlook (1) parser (1) password (1) paths (1) perl @INC compile-time run-time (1) perl disk usage administration Linux Unix (1) perl modules configuration management (1) permissions (1) php (1) picasa (1) platform (1) postgreSQL how-to (1) powerShell cmd cygwin mintty.exe terminal (1) ppm (1) predictions (1) prices (1) principles (1) productivity (1) project (1) prompt (1) proxy account (1) public private key (1) publishing (1) putty (1) qt (1) read file (1) registry (1) relationship (1) repository (1) rm (1) scp (1) scripts (1) scsi (1) search and replace (1) sed (1) sendEmail (1) sh stub (1) shortcuts Windows sql developer Oracle (1) sidebar (1) silicon (1) smtp (1) software procurement (1) sofware (1) sort (1) sql script (1) sql_dev (1) sqlcmd (1) sqlite (1) sqlite3 (1) sshd (1) sshd cygwin (1) stackoverflow (1) stored procedure (1) stub (1) stupidity (1) subroutines (1) svn (1) sysinternals (1) tail (1) tar (1) temp table (1) templates (1) teradata (1) terminal (1) test (1) testing (1) theory (1) thorium (1) time (1) tip (1) title (1) tmux .tmux.conf configuration (1) tmux efficiency bash (1) tool (1) ui code prototyping tips and tricks (1) umask Linux Unix bash file permissions chmod (1) url (1) urls (1) user (1) utility (1) utils (1) vb (1) vim perl regex bash search for string (1) vim recursively hacks (1) vim starter (1) vim-cheat-sheet vim cheat-sheet (1) vimeo (1) visual stuio (1) warsaw (1) wiki (1) wikipedia (1) window (1) windows 7 (1) windows 8 (1) windows programs (1) windows reinstall (1) windows utility batch perl space Windows::Clipboard (1) wisdoms (1) workflow (1) worth-reading (1) wrapper (1) xp_cmdshell (1) xslt (1) youtube (1)

Blog Archive

Translate with Google Translate

My Blog List

VideoBar

This content is not yet available over encrypted connections.