fix build under newer KConfig by bump cmake min version
This commit is contained in:
33
3rdparty/lexilla540/lexilla/test/examples/perl/SciTE.properties
vendored
Normal file
33
3rdparty/lexilla540/lexilla/test/examples/perl/SciTE.properties
vendored
Normal file
@ -0,0 +1,33 @@
|
||||
lexer.*.pl=perl
|
||||
keywords.*.pl=\
|
||||
NULL __FILE__ __LINE__ __PACKAGE__ __DATA__ __END__ AUTOLOAD \
|
||||
BEGIN CORE DESTROY END EQ GE GT INIT LE LT NE CHECK abs accept \
|
||||
alarm and atan2 bind binmode bless caller chdir chmod chomp chop \
|
||||
chown chr chroot close closedir cmp connect continue cos crypt \
|
||||
dbmclose dbmopen defined delete die do dump each else elsif endgrent \
|
||||
endhostent endnetent endprotoent endpwent endservent eof eq eval \
|
||||
exec exists exit exp fcntl fileno flock for foreach fork format \
|
||||
formline ge getc getgrent getgrgid getgrnam gethostbyaddr gethostbyname \
|
||||
gethostent getlogin getnetbyaddr getnetbyname getnetent getpeername \
|
||||
getpgrp getppid getpriority getprotobyname getprotobynumber getprotoent \
|
||||
getpwent getpwnam getpwuid getservbyname getservbyport getservent \
|
||||
getsockname getsockopt glob gmtime goto grep gt hex if index \
|
||||
int ioctl join keys kill last lc lcfirst le length link listen \
|
||||
local localtime lock log lstat lt map mkdir msgctl msgget msgrcv \
|
||||
msgsnd my ne next no not oct open opendir or ord our pack package \
|
||||
pipe pop pos print printf prototype push quotemeta qu \
|
||||
rand read readdir readline readlink readpipe recv redo \
|
||||
ref rename require reset return reverse rewinddir rindex rmdir \
|
||||
scalar seek seekdir select semctl semget semop send setgrent \
|
||||
sethostent setnetent setpgrp setpriority setprotoent setpwent \
|
||||
setservent setsockopt shift shmctl shmget shmread shmwrite shutdown \
|
||||
sin sleep socket socketpair sort splice split sprintf sqrt srand \
|
||||
stat study sub substr symlink syscall sysopen sysread sysseek \
|
||||
system syswrite tell telldir tie tied time times truncate \
|
||||
uc ucfirst umask undef unless unlink unpack unshift untie until \
|
||||
use utime values vec wait waitpid wantarray warn while write \
|
||||
xor \
|
||||
given when default break say state UNITCHECK __SUB__ fc
|
||||
|
||||
fold=1
|
||||
fold.comment=1
|
||||
178
3rdparty/lexilla540/lexilla/test/examples/perl/perl-test-5220delta.pl
vendored
Normal file
178
3rdparty/lexilla540/lexilla/test/examples/perl/perl-test-5220delta.pl
vendored
Normal file
@ -0,0 +1,178 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#--------------------------------------------------------------------------
|
||||
# perl-test-5220delta.pl
|
||||
#--------------------------------------------------------------------------
|
||||
# REF: https://metacpan.org/pod/distribution/perl/pod/perldelta.pod
|
||||
# maybe future ref: https://metacpan.org/pod/distribution/perl/pod/perl5220delta.pod
|
||||
# also: http://perltricks.com/article/165/2015/4/10/A-preview-of-Perl-5-22
|
||||
#
|
||||
#--------------------------------------------------------------------------
|
||||
# Kein-Hong Man <keinhong@gmail.com> Public Domain 20151217
|
||||
#--------------------------------------------------------------------------
|
||||
# 20151217 initial document
|
||||
# 20151218 updated tests and comments
|
||||
#--------------------------------------------------------------------------
|
||||
|
||||
use v5.22; # may be needed
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# New bitwise operators
|
||||
#--------------------------------------------------------------------------
|
||||
|
||||
use feature 'bitwise' # enable feature, warning enabled
|
||||
use experimental "bitwise"; # enable feature, warning disabled
|
||||
|
||||
# numerical operands
|
||||
10&20 10|20 10^20 ~10
|
||||
$a&"8" $a|"8" $a^"8" ~$a ~"8"
|
||||
|
||||
# string operands
|
||||
'0'&."8" '0'|."8" '0'^."8" ~.'0' ~."8"
|
||||
# the following is AMBIGUOUS, perl sees 10 and not .10 only when bitwise feature is enabled
|
||||
# so it's feature-setting-dependent, no plans to change current behaviour
|
||||
$a&.10 $a|.10 $a^.10 ~.$a ~.10
|
||||
|
||||
# assignment variants
|
||||
$a&=10; $a|=10; $a^=10;
|
||||
$b&.='20'; $b|.='20'; $b^.='20';
|
||||
$c&="30"; $c|="30"; $c^="30";
|
||||
$d&.=$e; $d|.=$e; $d^.=$e;
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# New double-diamond operator
|
||||
#--------------------------------------------------------------------------
|
||||
# <<>> is like <> but each element of @ARGV will be treated as an actual file name
|
||||
|
||||
# example snippet from brian d foy's blog post
|
||||
while( <<>> ) { # new, safe line input operator
|
||||
...;
|
||||
}
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# New \b boundaries in regular expressions
|
||||
#--------------------------------------------------------------------------
|
||||
|
||||
qr/\b{gcb}/
|
||||
qr/\b{wb}/
|
||||
qr/\b{sb}/
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# Non-Capturing Regular Expression Flag
|
||||
#--------------------------------------------------------------------------
|
||||
# disables capturing and filling in $1, $2, etc
|
||||
|
||||
"hello" =~ /(hi|hello)/n; # $1 is not set
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# Aliasing via reference
|
||||
#--------------------------------------------------------------------------
|
||||
# Variables and subroutines can now be aliased by assigning to a reference
|
||||
|
||||
\$c = \$d;
|
||||
\&x = \&y;
|
||||
|
||||
# Aliasing can also be applied to foreach iterator variables
|
||||
|
||||
foreach \%hash (@array_of_hash_refs) { ... }
|
||||
|
||||
# example snippet from brian d foy's blog post
|
||||
|
||||
use feature qw(refaliasing);
|
||||
|
||||
\%other_hash = \%hash;
|
||||
|
||||
use v5.22;
|
||||
use feature qw(refaliasing);
|
||||
|
||||
foreach \my %hash ( @array_of_hashes ) { # named hash control variable
|
||||
foreach my $key ( keys %hash ) { # named hash now!
|
||||
...;
|
||||
}
|
||||
}
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# New :const subroutine attribute
|
||||
#--------------------------------------------------------------------------
|
||||
|
||||
my $x = 54321;
|
||||
*INLINED = sub : const { $x };
|
||||
$x++;
|
||||
|
||||
# more examples of attributes
|
||||
# (not 5.22 stuff, but some general examples for study, useful for
|
||||
# handling subroutine signature and subroutine prototype highlighting)
|
||||
|
||||
sub foo : lvalue ;
|
||||
|
||||
package X;
|
||||
sub Y::x : lvalue { 1 }
|
||||
|
||||
package X;
|
||||
sub foo { 1 }
|
||||
package Y;
|
||||
BEGIN { *bar = \&X::foo; }
|
||||
package Z;
|
||||
sub Y::bar : lvalue ;
|
||||
|
||||
# built-in attributes for subroutines:
|
||||
lvalue method prototype(..) locked const
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# Repetition in list assignment
|
||||
#--------------------------------------------------------------------------
|
||||
|
||||
# example snippet from brian d foy's blog post
|
||||
use v5.22;
|
||||
my(undef, $card_num, (undef)x3, $count) = split /:/;
|
||||
|
||||
(undef,undef,$foo) = that_function()
|
||||
# is equivalent to
|
||||
((undef)x2, $foo) = that_function()
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# Floating point parsing has been improved
|
||||
#--------------------------------------------------------------------------
|
||||
# Hexadecimal floating point literals
|
||||
|
||||
# some hex floats from a program by Rick Regan
|
||||
# appropriated and extended from Lua 5.2.x test cases
|
||||
# tested on perl 5.22/cygwin
|
||||
|
||||
0x1p-1074;
|
||||
0x3.3333333333334p-5;
|
||||
0xcc.ccccccccccdp-11;
|
||||
0x1p+1;
|
||||
0x1p-6;
|
||||
0x1.b7p-1;
|
||||
0x1.fffffffffffffp+1023;
|
||||
0x1p-1022;
|
||||
0X1.921FB4D12D84AP+1;
|
||||
0x1.999999999999ap-4;
|
||||
|
||||
# additional test cases for characterization
|
||||
0x1p-1074. # dot is a string operator
|
||||
0x.ABCDEFp10 # legal, dot immediately after 0x
|
||||
0x.p10 # perl allows 0x as a zero, then concat with p10 bareword
|
||||
0x.p 0x0.p # dot then bareword
|
||||
0x_0_.A_BC___DEF_p1_0 # legal hex float, underscores are mostly allowed
|
||||
0x0._ABCDEFp10 # _ABCDEFp10 is a bareword, no underscore allowed after dot
|
||||
|
||||
# illegal, but does not use error highlighting
|
||||
0x0p1ABC # illegal, highlighted as 0x0p1 abut with bareword ABC
|
||||
|
||||
# allowed to FAIL for now
|
||||
0x0.ABCDEFp_10 # ABCDEFp_10 is a bareword, '_10' exponent not allowed
|
||||
0xp 0xp1 0x0.0p # syntax errors
|
||||
0x41.65.65 # hex dot number, but lexer now fails with 0x41.65 left as a partial hex float
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# Support for ?PATTERN? without explicit operator has been removed
|
||||
#--------------------------------------------------------------------------
|
||||
# ?PATTERN? must now be written as m?PATTERN?
|
||||
|
||||
?PATTERN? # does not work in current LexPerl anyway, NO ACTION NEEDED
|
||||
m?PATTERN?
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# end of test file
|
||||
#--------------------------------------------------------------------------
|
||||
179
3rdparty/lexilla540/lexilla/test/examples/perl/perl-test-5220delta.pl.folded
vendored
Normal file
179
3rdparty/lexilla540/lexilla/test/examples/perl/perl-test-5220delta.pl.folded
vendored
Normal file
@ -0,0 +1,179 @@
|
||||
2 400 401 + # -*- coding: utf-8 -*-
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # perl-test-5220delta.pl
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # REF: https://metacpan.org/pod/distribution/perl/pod/perldelta.pod
|
||||
0 401 401 | # maybe future ref: https://metacpan.org/pod/distribution/perl/pod/perl5220delta.pod
|
||||
0 401 401 | # also: http://perltricks.com/article/165/2015/4/10/A-preview-of-Perl-5-22
|
||||
0 401 401 | #
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # Kein-Hong Man <keinhong@gmail.com> Public Domain 20151217
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # 20151217 initial document
|
||||
0 401 401 | # 20151218 updated tests and comments
|
||||
0 401 400 | #--------------------------------------------------------------------------
|
||||
1 400 400
|
||||
0 400 400 use v5.22; # may be needed
|
||||
1 400 400
|
||||
2 400 401 + #--------------------------------------------------------------------------
|
||||
0 401 401 | # New bitwise operators
|
||||
0 401 400 | #--------------------------------------------------------------------------
|
||||
1 400 400
|
||||
0 400 400 use feature 'bitwise' # enable feature, warning enabled
|
||||
0 400 400 use experimental "bitwise"; # enable feature, warning disabled
|
||||
1 400 400
|
||||
0 400 400 # numerical operands
|
||||
0 400 400 10&20 10|20 10^20 ~10
|
||||
0 400 400 $a&"8" $a|"8" $a^"8" ~$a ~"8"
|
||||
1 400 400
|
||||
0 400 400 # string operands
|
||||
0 400 400 '0'&."8" '0'|."8" '0'^."8" ~.'0' ~."8"
|
||||
2 400 401 + # the following is AMBIGUOUS, perl sees 10 and not .10 only when bitwise feature is enabled
|
||||
0 401 400 | # so it's feature-setting-dependent, no plans to change current behaviour
|
||||
0 400 400 $a&.10 $a|.10 $a^.10 ~.$a ~.10
|
||||
1 400 400
|
||||
0 400 400 # assignment variants
|
||||
0 400 400 $a&=10; $a|=10; $a^=10;
|
||||
0 400 400 $b&.='20'; $b|.='20'; $b^.='20';
|
||||
0 400 400 $c&="30"; $c|="30"; $c^="30";
|
||||
0 400 400 $d&.=$e; $d|.=$e; $d^.=$e;
|
||||
1 400 400
|
||||
2 400 401 + #--------------------------------------------------------------------------
|
||||
0 401 401 | # New double-diamond operator
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 400 | # <<>> is like <> but each element of @ARGV will be treated as an actual file name
|
||||
1 400 400
|
||||
0 400 400 # example snippet from brian d foy's blog post
|
||||
2 400 401 + while( <<>> ) { # new, safe line input operator
|
||||
0 401 401 | ...;
|
||||
0 401 400 | }
|
||||
1 400 400
|
||||
2 400 401 + #--------------------------------------------------------------------------
|
||||
0 401 401 | # New \b boundaries in regular expressions
|
||||
0 401 400 | #--------------------------------------------------------------------------
|
||||
1 400 400
|
||||
0 400 400 qr/\b{gcb}/
|
||||
0 400 400 qr/\b{wb}/
|
||||
0 400 400 qr/\b{sb}/
|
||||
1 400 400
|
||||
2 400 401 + #--------------------------------------------------------------------------
|
||||
0 401 401 | # Non-Capturing Regular Expression Flag
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 400 | # disables capturing and filling in $1, $2, etc
|
||||
1 400 400
|
||||
0 400 400 "hello" =~ /(hi|hello)/n; # $1 is not set
|
||||
1 400 400
|
||||
2 400 401 + #--------------------------------------------------------------------------
|
||||
0 401 401 | # Aliasing via reference
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 400 | # Variables and subroutines can now be aliased by assigning to a reference
|
||||
1 400 400
|
||||
0 400 400 \$c = \$d;
|
||||
0 400 400 \&x = \&y;
|
||||
1 400 400
|
||||
0 400 400 # Aliasing can also be applied to foreach iterator variables
|
||||
1 400 400
|
||||
0 400 400 foreach \%hash (@array_of_hash_refs) { ... }
|
||||
1 400 400
|
||||
0 400 400 # example snippet from brian d foy's blog post
|
||||
1 400 400
|
||||
0 400 400 use feature qw(refaliasing);
|
||||
1 400 400
|
||||
0 400 400 \%other_hash = \%hash;
|
||||
1 400 400
|
||||
0 400 400 use v5.22;
|
||||
0 400 400 use feature qw(refaliasing);
|
||||
1 400 400
|
||||
2 400 401 + foreach \my %hash ( @array_of_hashes ) { # named hash control variable
|
||||
2 401 402 + foreach my $key ( keys %hash ) { # named hash now!
|
||||
0 402 402 | ...;
|
||||
0 402 401 | }
|
||||
0 401 400 | }
|
||||
1 400 400
|
||||
2 400 401 + #--------------------------------------------------------------------------
|
||||
0 401 401 | # New :const subroutine attribute
|
||||
0 401 400 | #--------------------------------------------------------------------------
|
||||
1 400 400
|
||||
0 400 400 my $x = 54321;
|
||||
0 400 400 *INLINED = sub : const { $x };
|
||||
0 400 400 $x++;
|
||||
1 400 400
|
||||
2 400 401 + # more examples of attributes
|
||||
0 401 401 | # (not 5.22 stuff, but some general examples for study, useful for
|
||||
0 401 400 | # handling subroutine signature and subroutine prototype highlighting)
|
||||
1 400 400
|
||||
0 400 400 sub foo : lvalue ;
|
||||
1 400 400
|
||||
2 400 401 + package X;
|
||||
0 401 401 | sub Y::x : lvalue { 1 }
|
||||
1 401 401 |
|
||||
2 400 401 + package X;
|
||||
0 401 401 | sub foo { 1 }
|
||||
2 400 401 + package Y;
|
||||
0 401 401 | BEGIN { *bar = \&X::foo; }
|
||||
2 400 401 + package Z;
|
||||
0 401 401 | sub Y::bar : lvalue ;
|
||||
1 401 401 |
|
||||
0 401 401 | # built-in attributes for subroutines:
|
||||
0 401 401 | lvalue method prototype(..) locked const
|
||||
1 401 401 |
|
||||
2 401 402 + #--------------------------------------------------------------------------
|
||||
0 402 402 | # Repetition in list assignment
|
||||
0 402 401 | #--------------------------------------------------------------------------
|
||||
1 401 401 |
|
||||
0 401 401 | # example snippet from brian d foy's blog post
|
||||
0 401 401 | use v5.22;
|
||||
0 401 401 | my(undef, $card_num, (undef)x3, $count) = split /:/;
|
||||
1 401 401 |
|
||||
0 401 401 | (undef,undef,$foo) = that_function()
|
||||
0 401 401 | # is equivalent to
|
||||
0 401 401 | ((undef)x2, $foo) = that_function()
|
||||
1 401 401 |
|
||||
2 401 402 + #--------------------------------------------------------------------------
|
||||
0 402 402 | # Floating point parsing has been improved
|
||||
0 402 402 | #--------------------------------------------------------------------------
|
||||
0 402 401 | # Hexadecimal floating point literals
|
||||
1 401 401 |
|
||||
2 401 402 + # some hex floats from a program by Rick Regan
|
||||
0 402 402 | # appropriated and extended from Lua 5.2.x test cases
|
||||
0 402 401 | # tested on perl 5.22/cygwin
|
||||
1 401 401 |
|
||||
0 401 401 | 0x1p-1074;
|
||||
0 401 401 | 0x3.3333333333334p-5;
|
||||
0 401 401 | 0xcc.ccccccccccdp-11;
|
||||
0 401 401 | 0x1p+1;
|
||||
0 401 401 | 0x1p-6;
|
||||
0 401 401 | 0x1.b7p-1;
|
||||
0 401 401 | 0x1.fffffffffffffp+1023;
|
||||
0 401 401 | 0x1p-1022;
|
||||
0 401 401 | 0X1.921FB4D12D84AP+1;
|
||||
0 401 401 | 0x1.999999999999ap-4;
|
||||
1 401 401 |
|
||||
0 401 401 | # additional test cases for characterization
|
||||
0 401 401 | 0x1p-1074. # dot is a string operator
|
||||
0 401 401 | 0x.ABCDEFp10 # legal, dot immediately after 0x
|
||||
0 401 401 | 0x.p10 # perl allows 0x as a zero, then concat with p10 bareword
|
||||
0 401 401 | 0x.p 0x0.p # dot then bareword
|
||||
0 401 401 | 0x_0_.A_BC___DEF_p1_0 # legal hex float, underscores are mostly allowed
|
||||
0 401 401 | 0x0._ABCDEFp10 # _ABCDEFp10 is a bareword, no underscore allowed after dot
|
||||
1 401 401 |
|
||||
0 401 401 | # illegal, but does not use error highlighting
|
||||
0 401 401 | 0x0p1ABC # illegal, highlighted as 0x0p1 abut with bareword ABC
|
||||
1 401 401 |
|
||||
0 401 401 | # allowed to FAIL for now
|
||||
0 401 401 | 0x0.ABCDEFp_10 # ABCDEFp_10 is a bareword, '_10' exponent not allowed
|
||||
0 401 401 | 0xp 0xp1 0x0.0p # syntax errors
|
||||
0 401 401 | 0x41.65.65 # hex dot number, but lexer now fails with 0x41.65 left as a partial hex float
|
||||
1 401 401 |
|
||||
2 401 402 + #--------------------------------------------------------------------------
|
||||
0 402 402 | # Support for ?PATTERN? without explicit operator has been removed
|
||||
0 402 402 | #--------------------------------------------------------------------------
|
||||
0 402 401 | # ?PATTERN? must now be written as m?PATTERN?
|
||||
1 401 401 |
|
||||
0 401 401 | ?PATTERN? # does not work in current LexPerl anyway, NO ACTION NEEDED
|
||||
0 401 401 | m?PATTERN?
|
||||
1 401 401 |
|
||||
2 401 402 + #--------------------------------------------------------------------------
|
||||
0 402 402 | # end of test file
|
||||
0 402 401 | #--------------------------------------------------------------------------
|
||||
0 401 0 |
|
||||
178
3rdparty/lexilla540/lexilla/test/examples/perl/perl-test-5220delta.pl.styled
vendored
Normal file
178
3rdparty/lexilla540/lexilla/test/examples/perl/perl-test-5220delta.pl.styled
vendored
Normal file
@ -0,0 +1,178 @@
|
||||
{2}# -*- coding: utf-8 -*-
|
||||
#--------------------------------------------------------------------------
|
||||
# perl-test-5220delta.pl
|
||||
#--------------------------------------------------------------------------
|
||||
# REF: https://metacpan.org/pod/distribution/perl/pod/perldelta.pod
|
||||
# maybe future ref: https://metacpan.org/pod/distribution/perl/pod/perl5220delta.pod
|
||||
# also: http://perltricks.com/article/165/2015/4/10/A-preview-of-Perl-5-22
|
||||
#
|
||||
#--------------------------------------------------------------------------
|
||||
# Kein-Hong Man <keinhong@gmail.com> Public Domain 20151217
|
||||
#--------------------------------------------------------------------------
|
||||
# 20151217 initial document
|
||||
# 20151218 updated tests and comments
|
||||
#--------------------------------------------------------------------------
|
||||
{0}
|
||||
{5}use{0} {6}v5.22{10};{0} {2}# may be needed
|
||||
{0}
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# New bitwise operators
|
||||
#--------------------------------------------------------------------------
|
||||
{0}
|
||||
{5}use{0} {11}feature{0} {7}'bitwise'{0} {2}# enable feature, warning enabled
|
||||
{5}use{0} {11}experimental{0} {6}"bitwise"{10};{0} {2}# enable feature, warning disabled
|
||||
{0}
|
||||
{2}# numerical operands
|
||||
{4}10{10}&{4}20{0} {4}10{10}|{4}20{0} {4}10{10}^{4}20{0} {10}~{4}10{0}
|
||||
{12}$a{10}&{6}"8"{0} {12}$a{10}|{6}"8"{0} {12}$a{10}^{6}"8"{0} {10}~{12}$a{0} {10}~{6}"8"{0}
|
||||
|
||||
{2}# string operands
|
||||
{7}'0'{10}&.{6}"8"{0} {7}'0'{10}|.{6}"8"{0} {7}'0'{10}^.{6}"8"{0} {10}~.{7}'0'{0} {10}~.{6}"8"{0}
|
||||
{2}# the following is AMBIGUOUS, perl sees 10 and not .10 only when bitwise feature is enabled
|
||||
# so it's feature-setting-dependent, no plans to change current behaviour
|
||||
{0} {12}$a{10}&{4}.10{0} {12}$a{10}|{4}.10{0} {12}$a{10}^{4}.10{0} {10}~.{12}$a{0} {10}~{4}.10{0}
|
||||
|
||||
{2}# assignment variants
|
||||
{12}$a{10}&={4}10{10};{0} {12}$a{10}|={4}10{10};{0} {12}$a{10}^={4}10{10};{0}
|
||||
{12}$b{10}&.={7}'20'{10};{0} {12}$b{10}|.={7}'20'{10};{0} {12}$b{10}^.={7}'20'{10};{0}
|
||||
{12}$c{10}&={6}"30"{10};{0} {12}$c{10}|={6}"30"{10};{0} {12}$c{10}^={6}"30"{10};{0}
|
||||
{12}$d{10}&.={12}$e{10};{0} {12}$d{10}|.={12}$e{10};{0} {12}$d{10}^.={12}$e{10};{0}
|
||||
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# New double-diamond operator
|
||||
#--------------------------------------------------------------------------
|
||||
# <<>> is like <> but each element of @ARGV will be treated as an actual file name
|
||||
{0}
|
||||
{2}# example snippet from brian d foy's blog post
|
||||
{5}while{10}({0} {10}<<>>{0} {10}){0} {10}{{0} {2}# new, safe line input operator
|
||||
{0} {10}...;{0}
|
||||
{10}}{0}
|
||||
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# New \b boundaries in regular expressions
|
||||
#--------------------------------------------------------------------------
|
||||
{0}
|
||||
{29}qr/\b{gcb}/{0}
|
||||
{29}qr/\b{wb}/{0}
|
||||
{29}qr/\b{sb}/{0}
|
||||
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# Non-Capturing Regular Expression Flag
|
||||
#--------------------------------------------------------------------------
|
||||
# disables capturing and filling in $1, $2, etc
|
||||
{0}
|
||||
{6}"hello"{0} {10}=~{0} {17}/(hi|hello)/n{10};{0} {2}# $1 is not set
|
||||
{0}
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# Aliasing via reference
|
||||
#--------------------------------------------------------------------------
|
||||
# Variables and subroutines can now be aliased by assigning to a reference
|
||||
{0}
|
||||
{10}\{12}$c{0} {10}={0} {10}\{12}$d{10};{0}
|
||||
{10}\&{11}x{0} {10}={0} {10}\&{11}y{10};{0}
|
||||
|
||||
{2}# Aliasing can also be applied to foreach iterator variables
|
||||
{0}
|
||||
{5}foreach{0} {10}\{14}%hash{0} {10}({13}@array_of_hash_refs{10}){0} {10}{{0} {10}...{0} {10}}{0}
|
||||
|
||||
{2}# example snippet from brian d foy's blog post
|
||||
{0}
|
||||
{5}use{0} {11}feature{0} {30}qw(refaliasing){10};{0}
|
||||
|
||||
{10}\{14}%other_hash{0} {10}={0} {10}\{14}%hash{10};{0}
|
||||
|
||||
{5}use{0} {6}v5.22{10};{0}
|
||||
{5}use{0} {11}feature{0} {30}qw(refaliasing){10};{0}
|
||||
|
||||
{5}foreach{0} {10}\{5}my{0} {14}%hash{0} {10}({0} {13}@array_of_hashes{0} {10}){0} {10}{{0} {2}# named hash control variable
|
||||
{0} {5}foreach{0} {5}my{0} {12}$key{0} {10}({0} {5}keys{0} {14}%hash{0} {10}){0} {10}{{0} {2}# named hash now!
|
||||
{0} {10}...;{0}
|
||||
{10}}{0}
|
||||
{10}}{0}
|
||||
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# New :const subroutine attribute
|
||||
#--------------------------------------------------------------------------
|
||||
{0}
|
||||
{5}my{0} {12}$x{0} {10}={0} {4}54321{10};{0}
|
||||
{15}*INLINED{0} {10}={0} {5}sub{0} {10}:{0} {11}const{0} {10}{{0} {12}$x{0} {10}};{0}
|
||||
{12}$x{10}++;{0}
|
||||
|
||||
{2}# more examples of attributes
|
||||
# (not 5.22 stuff, but some general examples for study, useful for
|
||||
# handling subroutine signature and subroutine prototype highlighting)
|
||||
{0}
|
||||
{5}sub{0} {11}foo{0} {10}:{0} {11}lvalue{0} {10};{0}
|
||||
|
||||
{5}package{0} {11}X{10};{0}
|
||||
{5}sub{0} {11}Y{10}::{11}x{0} {10}:{0} {11}lvalue{0} {10}{{0} {4}1{0} {10}}{0}
|
||||
|
||||
{5}package{0} {11}X{10};{0}
|
||||
{5}sub{0} {11}foo{0} {10}{{0} {4}1{0} {10}}{0}
|
||||
{5}package{0} {11}Y{10};{0}
|
||||
{5}BEGIN{0} {10}{{0} {15}*bar{0} {10}={0} {10}\&{11}X{10}::{11}foo{10};{0} {10}}{0}
|
||||
{5}package{0} {11}Z{10};{0}
|
||||
{5}sub{0} {11}Y{10}::{11}bar{0} {10}:{0} {11}lvalue{0} {10};{0}
|
||||
|
||||
{2}# built-in attributes for subroutines:
|
||||
{11}lvalue{0} {11}method{0} {5}prototype{10}(..){0} {11}locked{0} {11}const{0}
|
||||
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# Repetition in list assignment
|
||||
#--------------------------------------------------------------------------
|
||||
{0}
|
||||
{2}# example snippet from brian d foy's blog post
|
||||
{5}use{0} {6}v5.22{10};{0}
|
||||
{5}my{10}({5}undef{10},{0} {12}$card_num{10},{0} {10}({5}undef{10})x{4}3{10},{0} {12}$count{10}){0} {10}={0} {5}split{0} {17}/:/{10};{0}
|
||||
|
||||
{10}({5}undef{10},{5}undef{10},{12}$foo{10}){0} {10}={0} {11}that_function{10}(){0}
|
||||
{2}# is equivalent to
|
||||
{10}(({5}undef{10})x{4}2{10},{0} {12}$foo{10}){0} {10}={0} {11}that_function{10}(){0}
|
||||
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# Floating point parsing has been improved
|
||||
#--------------------------------------------------------------------------
|
||||
# Hexadecimal floating point literals
|
||||
{0}
|
||||
{2}# some hex floats from a program by Rick Regan
|
||||
# appropriated and extended from Lua 5.2.x test cases
|
||||
# tested on perl 5.22/cygwin
|
||||
{0}
|
||||
{4}0x1p-1074{10};{0}
|
||||
{4}0x3.3333333333334p-5{10};{0}
|
||||
{4}0xcc.ccccccccccdp-11{10};{0}
|
||||
{4}0x1p+1{10};{0}
|
||||
{4}0x1p-6{10};{0}
|
||||
{4}0x1.b7p-1{10};{0}
|
||||
{4}0x1.fffffffffffffp+1023{10};{0}
|
||||
{4}0x1p-1022{10};{0}
|
||||
{4}0X1.921FB4D12D84AP+1{10};{0}
|
||||
{4}0x1.999999999999ap-4{10};{0}
|
||||
|
||||
{2}# additional test cases for characterization
|
||||
{4}0x1p-1074{10}.{0} {2}# dot is a string operator
|
||||
{4}0x.ABCDEFp10{0} {2}# legal, dot immediately after 0x
|
||||
{4}0x{10}.{11}p10{0} {2}# perl allows 0x as a zero, then concat with p10 bareword
|
||||
{4}0x{10}.{11}p{0} {4}0x0{10}.{11}p{0} {2}# dot then bareword
|
||||
{4}0x_0_.A_BC___DEF_p1_0{0} {2}# legal hex float, underscores are mostly allowed
|
||||
{4}0x0{10}.{11}_ABCDEFp10{0} {2}# _ABCDEFp10 is a bareword, no underscore allowed after dot
|
||||
{0}
|
||||
{2}# illegal, but does not use error highlighting
|
||||
{4}0x0p1{11}ABC{0} {2}# illegal, highlighted as 0x0p1 abut with bareword ABC
|
||||
{0}
|
||||
{2}# allowed to FAIL for now
|
||||
{4}0x0.ABCDEFp_10{0} {2}# ABCDEFp_10 is a bareword, '_10' exponent not allowed
|
||||
{4}0xp{0} {4}0xp1{0} {4}0x0.0p{0} {2}# syntax errors
|
||||
{4}0x41.65{10}.{4}65{0} {2}# hex dot number, but lexer now fails with 0x41.65 left as a partial hex float
|
||||
{0}
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# Support for ?PATTERN? without explicit operator has been removed
|
||||
#--------------------------------------------------------------------------
|
||||
# ?PATTERN? must now be written as m?PATTERN?
|
||||
{0}
|
||||
{10}?{11}PATTERN{10}?{0} {2}# does not work in current LexPerl anyway, NO ACTION NEEDED
|
||||
{17}m?PATTERN?{0}
|
||||
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# end of test file
|
||||
#--------------------------------------------------------------------------
|
||||
239
3rdparty/lexilla540/lexilla/test/examples/perl/perl-test-sub-prototypes.pl
vendored
Normal file
239
3rdparty/lexilla540/lexilla/test/examples/perl/perl-test-sub-prototypes.pl
vendored
Normal file
@ -0,0 +1,239 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#--------------------------------------------------------------------------
|
||||
# perl-test-sub-prototypes.pl
|
||||
#--------------------------------------------------------------------------
|
||||
# compiled all relevant subroutine prototype test cases
|
||||
#
|
||||
#--------------------------------------------------------------------------
|
||||
# Kein-Hong Man <keinhong@gmail.com> Public Domain
|
||||
#--------------------------------------------------------------------------
|
||||
# 20151227 initial document
|
||||
#--------------------------------------------------------------------------
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# test cases for sub syntax scanner
|
||||
#--------------------------------------------------------------------------
|
||||
# sub syntax: simple and with added module notation
|
||||
#--------------------------------------------------------------------------
|
||||
|
||||
sub fish($) { 123; }
|
||||
sub fish::chips($) { 123; } # module syntax
|
||||
sub fish::chips::sauce($) { 123; } # multiple module syntax
|
||||
|
||||
sub fish :: chips :: sauce ($) { 123; } # added whitespace
|
||||
|
||||
sub fish :: # embedded comment
|
||||
chips # embedded comment
|
||||
:: sauce ($) { 123; }
|
||||
|
||||
sub fish :: ($) { 123; } # incomplete or bad syntax examples
|
||||
sub fish :: 123 ($) { 123; }
|
||||
sub fish :: chips 123 ($) { 123; }
|
||||
sub 123 ($) { 123; }
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# sub syntax: prototype attributes
|
||||
#--------------------------------------------------------------------------
|
||||
|
||||
sub fish:prototype($) { 123; }
|
||||
sub fish : prototype ($) { 123; } # added whitespace
|
||||
|
||||
sub fish:salted($) { 123; } # wrong attribute example (must use 'prototype')
|
||||
sub fish : 123($) { 123; } # illegal attribute
|
||||
sub fish:prototype:salted($) { 123; } # wrong 'prototype' position
|
||||
sub fish:salted salt:prototype($) { 123; } # wrong attribute syntax
|
||||
|
||||
sub fish:const:prototype($) { 123; } # extra attributes
|
||||
sub fish:const:lvalue:prototype($) { 123; }
|
||||
sub fish:const:prototype($):lvalue{ 123; } # might be legal too
|
||||
sub fish :const :prototype($) { 123; } # extra whitespace
|
||||
|
||||
sub fish :const # embedded comment: a constant sub
|
||||
:prototype # embedded comment
|
||||
($) { 123; }
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# sub syntax: mixed
|
||||
#--------------------------------------------------------------------------
|
||||
|
||||
sub fish::chips:prototype($) { 123; }
|
||||
sub fish::chips::sauce:prototype($) { 123; }
|
||||
sub fish ::chips ::sauce :prototype($) { 123; } # +whitespace
|
||||
|
||||
sub fish::chips::sauce:const:prototype($) { 123; }
|
||||
sub fish::chips::sauce :const :prototype($) { 123; } # +whitespace
|
||||
|
||||
sub fish # embedded comment
|
||||
::chips ::sauce # embedded comment
|
||||
: const # embedded comment
|
||||
: prototype ($) { 123; }
|
||||
|
||||
# wrong syntax examples, parentheses must follow ':prototype'
|
||||
sub fish :prototype :const ($) { 123;}
|
||||
sub fish :prototype ::chips ($) { 123;}
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# perl-test-5200delta.pl
|
||||
#--------------------------------------------------------------------------
|
||||
# More consistent prototype parsing
|
||||
#--------------------------------------------------------------------------
|
||||
# - whitespace now allowed, lexer now allows spaces or tabs
|
||||
|
||||
sub foo ( $ $ ) {}
|
||||
sub foo ( ) {} # spaces/tabs empty
|
||||
sub foo ( * ) {}
|
||||
sub foo (@ ) {}
|
||||
sub foo ( %) {}
|
||||
|
||||
# untested, should probably be \[ but scanner does not check this for now
|
||||
sub foo ( \ [ $ @ % & * ] ) {}
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# perl-test-5140delta.pl
|
||||
#--------------------------------------------------------------------------
|
||||
# new + prototype character, acts like (\[@%])
|
||||
#--------------------------------------------------------------------------
|
||||
|
||||
# these samples work as before
|
||||
sub mylink ($$) # mylink $old, $new
|
||||
sub myvec ($$$) # myvec $var, $offset, 1
|
||||
sub myindex ($$;$) # myindex &getstring, "substr"
|
||||
sub mysyswrite ($$$;$) # mysyswrite $buf, 0, length($buf) - $off, $off
|
||||
sub myreverse (@) # myreverse $a, $b, $c
|
||||
sub myjoin ($@) # myjoin ":", $a, $b, $c
|
||||
sub myopen (*;$) # myopen HANDLE, $name
|
||||
sub mypipe (**) # mypipe READHANDLE, WRITEHANDLE
|
||||
sub mygrep (&@) # mygrep { /foo/ } $a, $b, $c
|
||||
sub myrand (;$) # myrand 42
|
||||
sub mytime () # mytime
|
||||
|
||||
# backslash group notation to specify more than one allowed argument type
|
||||
sub myref (\[$@%&*]) {}
|
||||
|
||||
sub mysub (_) # underscore can be optionally used FIXED 20151211
|
||||
|
||||
# these uses the new '+' prototype character
|
||||
sub mypop (+) # mypop @array
|
||||
sub mysplice (+$$@) # mysplice @array, 0, 2, @pushme
|
||||
sub mykeys (+) # mykeys %{$hashref}
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# perl-test-5200delta.pl
|
||||
#--------------------------------------------------------------------------
|
||||
# Experimental Subroutine signatures (mostly works)
|
||||
#--------------------------------------------------------------------------
|
||||
# INCLUDED FOR COMPLETENESS ONLY
|
||||
# IMPORTANT NOTE the subroutine prototypes lexing implementation has
|
||||
# no effect on subroutine signature syntax highlighting
|
||||
|
||||
# subroutine signatures mostly looks fine except for the @ and % slurpy
|
||||
# notation which are highlighted as operators (all other parameters are
|
||||
# highlighted as vars of some sort), a minor aesthetic issue
|
||||
|
||||
use feature 'signatures';
|
||||
|
||||
sub foo ($left, $right) { # mandatory positional parameters
|
||||
return $left + $right;
|
||||
}
|
||||
sub foo ($first, $, $third) { # ignore second argument
|
||||
return "first=$first, third=$third";
|
||||
}
|
||||
sub foo ($left, $right = 0) { # optional parameter with default value
|
||||
return $left + $right;
|
||||
}
|
||||
my $auto_id = 0; # default value expression, evaluated if default used only
|
||||
sub foo ($thing, $id = $auto_id++) {
|
||||
print "$thing has ID $id";
|
||||
}
|
||||
sub foo ($first_name, $surname, $nickname = $first_name) { # 3rd parm may depend on 1st parm
|
||||
print "$first_name $surname is known as \"$nickname\"";
|
||||
}
|
||||
sub foo ($thing, $ = 1) { # nameless default parameter
|
||||
print $thing;
|
||||
}
|
||||
sub foo ($thing, $=) { # (this does something, I'm not sure what...)
|
||||
print $thing;
|
||||
}
|
||||
sub foo ($filter, @inputs) { # additional arguments (slurpy parameter)
|
||||
print $filter->($_) foreach @inputs;
|
||||
}
|
||||
sub foo ($thing, @) { # nameless slurpy parameter FAILS for now
|
||||
print $thing;
|
||||
}
|
||||
sub foo ($filter, %inputs) { # slurpy parameter, hash type
|
||||
print $filter->($_, $inputs{$_}) foreach sort keys %inputs;
|
||||
}
|
||||
sub foo ($thing, %) { # nameless slurpy parm, hash type FAILS for now
|
||||
print $thing;
|
||||
}
|
||||
sub foo () { # empty signature no arguments (styled as prototype)
|
||||
return 123;
|
||||
}
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# perl-test-5200delta.pl
|
||||
#--------------------------------------------------------------------------
|
||||
# subs now take a prototype attribute
|
||||
#--------------------------------------------------------------------------
|
||||
|
||||
sub foo :prototype($) { $_[0] }
|
||||
|
||||
sub foo :prototype($$) ($left, $right) {
|
||||
return $left + $right;
|
||||
}
|
||||
|
||||
sub foo : prototype($$){} # whitespace allowed
|
||||
|
||||
# additional samples from perl-test-cases.pl with ':prototype' added:
|
||||
sub mylink :prototype($$) {} sub myvec :prototype($$$) {}
|
||||
sub myindex :prototype($$;$) {} sub mysyswrite :prototype($$$;$) {}
|
||||
sub myreverse :prototype(@) {} sub myjoin :prototype($@) {}
|
||||
sub mypop :prototype(\@) {} sub mysplice :prototype(\@$$@) {}
|
||||
sub mykeys :prototype(\%) {} sub myopen :prototype(*;$) {}
|
||||
sub mypipe :prototype(**) {} sub mygrep :prototype(&@) {}
|
||||
sub myrand :prototype($) {} sub mytime :prototype() {}
|
||||
# backslash group notation to specify more than one allowed argument type
|
||||
sub myref :prototype(\[$@%&*]) {}
|
||||
|
||||
# additional attributes may complicate scanning for prototype syntax,
|
||||
# for example (from https://metacpan.org/pod/perlsub):
|
||||
# Lvalue subroutines
|
||||
|
||||
my $val;
|
||||
sub canmod : lvalue {
|
||||
$val; # or: return $val;
|
||||
}
|
||||
canmod() = 5; # assigns to $val
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# perl-test-5220delta.pl
|
||||
#--------------------------------------------------------------------------
|
||||
# New :const subroutine attribute
|
||||
#--------------------------------------------------------------------------
|
||||
|
||||
my $x = 54321;
|
||||
*INLINED = sub : const { $x };
|
||||
$x++;
|
||||
|
||||
# more examples of attributes
|
||||
# (not 5.22 stuff, but some general examples for study, useful for
|
||||
# handling subroutine signature and subroutine prototype highlighting)
|
||||
|
||||
sub foo : lvalue ;
|
||||
|
||||
package X;
|
||||
sub Y::z : lvalue { 1 }
|
||||
|
||||
package X;
|
||||
sub foo { 1 }
|
||||
package Y;
|
||||
BEGIN { *bar = \&X::foo; }
|
||||
package Z;
|
||||
sub Y::bar : lvalue ;
|
||||
|
||||
# built-in attributes for subroutines:
|
||||
lvalue method prototype(..) locked const
|
||||
|
||||
#--------------------------------------------------------------------------
|
||||
# end of test file
|
||||
#--------------------------------------------------------------------------
|
||||
240
3rdparty/lexilla540/lexilla/test/examples/perl/perl-test-sub-prototypes.pl.folded
vendored
Normal file
240
3rdparty/lexilla540/lexilla/test/examples/perl/perl-test-sub-prototypes.pl.folded
vendored
Normal file
@ -0,0 +1,240 @@
|
||||
2 400 401 + # -*- coding: utf-8 -*-
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # perl-test-sub-prototypes.pl
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # compiled all relevant subroutine prototype test cases
|
||||
0 401 401 | #
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # Kein-Hong Man <keinhong@gmail.com> Public Domain
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # 20151227 initial document
|
||||
0 401 400 | #--------------------------------------------------------------------------
|
||||
1 400 400
|
||||
2 400 401 + #--------------------------------------------------------------------------
|
||||
0 401 401 | # test cases for sub syntax scanner
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # sub syntax: simple and with added module notation
|
||||
0 401 400 | #--------------------------------------------------------------------------
|
||||
1 400 400
|
||||
0 400 400 sub fish($) { 123; }
|
||||
0 400 400 sub fish::chips($) { 123; } # module syntax
|
||||
0 400 400 sub fish::chips::sauce($) { 123; } # multiple module syntax
|
||||
1 400 400
|
||||
0 400 400 sub fish :: chips :: sauce ($) { 123; } # added whitespace
|
||||
1 400 400
|
||||
0 400 400 sub fish :: # embedded comment
|
||||
0 400 400 chips # embedded comment
|
||||
0 400 400 :: sauce ($) { 123; }
|
||||
1 400 400
|
||||
0 400 400 sub fish :: ($) { 123; } # incomplete or bad syntax examples
|
||||
0 400 400 sub fish :: 123 ($) { 123; }
|
||||
0 400 400 sub fish :: chips 123 ($) { 123; }
|
||||
0 400 400 sub 123 ($) { 123; }
|
||||
1 400 400
|
||||
2 400 401 + #--------------------------------------------------------------------------
|
||||
0 401 401 | # sub syntax: prototype attributes
|
||||
0 401 400 | #--------------------------------------------------------------------------
|
||||
1 400 400
|
||||
0 400 400 sub fish:prototype($) { 123; }
|
||||
0 400 400 sub fish : prototype ($) { 123; } # added whitespace
|
||||
1 400 400
|
||||
0 400 400 sub fish:salted($) { 123; } # wrong attribute example (must use 'prototype')
|
||||
0 400 400 sub fish : 123($) { 123; } # illegal attribute
|
||||
0 400 400 sub fish:prototype:salted($) { 123; } # wrong 'prototype' position
|
||||
0 400 400 sub fish:salted salt:prototype($) { 123; } # wrong attribute syntax
|
||||
1 400 400
|
||||
0 400 400 sub fish:const:prototype($) { 123; } # extra attributes
|
||||
0 400 400 sub fish:const:lvalue:prototype($) { 123; }
|
||||
0 400 400 sub fish:const:prototype($):lvalue{ 123; } # might be legal too
|
||||
0 400 400 sub fish :const :prototype($) { 123; } # extra whitespace
|
||||
1 400 400
|
||||
0 400 400 sub fish :const # embedded comment: a constant sub
|
||||
0 400 400 :prototype # embedded comment
|
||||
0 400 400 ($) { 123; }
|
||||
1 400 400
|
||||
2 400 401 + #--------------------------------------------------------------------------
|
||||
0 401 401 | # sub syntax: mixed
|
||||
0 401 400 | #--------------------------------------------------------------------------
|
||||
1 400 400
|
||||
0 400 400 sub fish::chips:prototype($) { 123; }
|
||||
0 400 400 sub fish::chips::sauce:prototype($) { 123; }
|
||||
0 400 400 sub fish ::chips ::sauce :prototype($) { 123; } # +whitespace
|
||||
1 400 400
|
||||
0 400 400 sub fish::chips::sauce:const:prototype($) { 123; }
|
||||
0 400 400 sub fish::chips::sauce :const :prototype($) { 123; } # +whitespace
|
||||
1 400 400
|
||||
0 400 400 sub fish # embedded comment
|
||||
0 400 400 ::chips ::sauce # embedded comment
|
||||
0 400 400 : const # embedded comment
|
||||
0 400 400 : prototype ($) { 123; }
|
||||
1 400 400
|
||||
0 400 400 # wrong syntax examples, parentheses must follow ':prototype'
|
||||
0 400 400 sub fish :prototype :const ($) { 123;}
|
||||
0 400 400 sub fish :prototype ::chips ($) { 123;}
|
||||
1 400 400
|
||||
2 400 401 + #--------------------------------------------------------------------------
|
||||
0 401 401 | # perl-test-5200delta.pl
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # More consistent prototype parsing
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 400 | # - whitespace now allowed, lexer now allows spaces or tabs
|
||||
1 400 400
|
||||
0 400 400 sub foo ( $ $ ) {}
|
||||
0 400 400 sub foo ( ) {} # spaces/tabs empty
|
||||
0 400 400 sub foo ( * ) {}
|
||||
0 400 400 sub foo (@ ) {}
|
||||
0 400 400 sub foo ( %) {}
|
||||
1 400 400
|
||||
0 400 400 # untested, should probably be \[ but scanner does not check this for now
|
||||
0 400 400 sub foo ( \ [ $ @ % & * ] ) {}
|
||||
1 400 400
|
||||
2 400 401 + #--------------------------------------------------------------------------
|
||||
0 401 401 | # perl-test-5140delta.pl
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # new + prototype character, acts like (\[@%])
|
||||
0 401 400 | #--------------------------------------------------------------------------
|
||||
1 400 400
|
||||
0 400 400 # these samples work as before
|
||||
0 400 400 sub mylink ($$) # mylink $old, $new
|
||||
0 400 400 sub myvec ($$$) # myvec $var, $offset, 1
|
||||
0 400 400 sub myindex ($$;$) # myindex &getstring, "substr"
|
||||
0 400 400 sub mysyswrite ($$$;$) # mysyswrite $buf, 0, length($buf) - $off, $off
|
||||
0 400 400 sub myreverse (@) # myreverse $a, $b, $c
|
||||
0 400 400 sub myjoin ($@) # myjoin ":", $a, $b, $c
|
||||
0 400 400 sub myopen (*;$) # myopen HANDLE, $name
|
||||
0 400 400 sub mypipe (**) # mypipe READHANDLE, WRITEHANDLE
|
||||
0 400 400 sub mygrep (&@) # mygrep { /foo/ } $a, $b, $c
|
||||
0 400 400 sub myrand (;$) # myrand 42
|
||||
0 400 400 sub mytime () # mytime
|
||||
1 400 400
|
||||
0 400 400 # backslash group notation to specify more than one allowed argument type
|
||||
0 400 400 sub myref (\[$@%&*]) {}
|
||||
1 400 400
|
||||
0 400 400 sub mysub (_) # underscore can be optionally used FIXED 20151211
|
||||
1 400 400
|
||||
0 400 400 # these uses the new '+' prototype character
|
||||
0 400 400 sub mypop (+) # mypop @array
|
||||
0 400 400 sub mysplice (+$$@) # mysplice @array, 0, 2, @pushme
|
||||
0 400 400 sub mykeys (+) # mykeys %{$hashref}
|
||||
1 400 400
|
||||
2 400 401 + #--------------------------------------------------------------------------
|
||||
0 401 401 | # perl-test-5200delta.pl
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # Experimental Subroutine signatures (mostly works)
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # INCLUDED FOR COMPLETENESS ONLY
|
||||
0 401 401 | # IMPORTANT NOTE the subroutine prototypes lexing implementation has
|
||||
0 401 400 | # no effect on subroutine signature syntax highlighting
|
||||
1 400 400
|
||||
2 400 401 + # subroutine signatures mostly looks fine except for the @ and % slurpy
|
||||
0 401 401 | # notation which are highlighted as operators (all other parameters are
|
||||
0 401 400 | # highlighted as vars of some sort), a minor aesthetic issue
|
||||
1 400 400
|
||||
0 400 400 use feature 'signatures';
|
||||
1 400 400
|
||||
2 400 401 + sub foo ($left, $right) { # mandatory positional parameters
|
||||
0 401 401 | return $left + $right;
|
||||
0 401 400 | }
|
||||
2 400 401 + sub foo ($first, $, $third) { # ignore second argument
|
||||
0 401 401 | return "first=$first, third=$third";
|
||||
0 401 400 | }
|
||||
2 400 401 + sub foo ($left, $right = 0) { # optional parameter with default value
|
||||
0 401 401 | return $left + $right;
|
||||
0 401 400 | }
|
||||
0 400 400 my $auto_id = 0; # default value expression, evaluated if default used only
|
||||
2 400 401 + sub foo ($thing, $id = $auto_id++) {
|
||||
0 401 401 | print "$thing has ID $id";
|
||||
0 401 400 | }
|
||||
2 400 401 + sub foo ($first_name, $surname, $nickname = $first_name) { # 3rd parm may depend on 1st parm
|
||||
0 401 401 | print "$first_name $surname is known as \"$nickname\"";
|
||||
0 401 400 | }
|
||||
2 400 401 + sub foo ($thing, $ = 1) { # nameless default parameter
|
||||
0 401 401 | print $thing;
|
||||
0 401 400 | }
|
||||
2 400 401 + sub foo ($thing, $=) { # (this does something, I'm not sure what...)
|
||||
0 401 401 | print $thing;
|
||||
0 401 400 | }
|
||||
2 400 401 + sub foo ($filter, @inputs) { # additional arguments (slurpy parameter)
|
||||
0 401 401 | print $filter->($_) foreach @inputs;
|
||||
0 401 400 | }
|
||||
2 400 401 + sub foo ($thing, @) { # nameless slurpy parameter FAILS for now
|
||||
0 401 401 | print $thing;
|
||||
0 401 400 | }
|
||||
2 400 401 + sub foo ($filter, %inputs) { # slurpy parameter, hash type
|
||||
0 401 401 | print $filter->($_, $inputs{$_}) foreach sort keys %inputs;
|
||||
0 401 400 | }
|
||||
2 400 401 + sub foo ($thing, %) { # nameless slurpy parm, hash type FAILS for now
|
||||
0 401 401 | print $thing;
|
||||
0 401 400 | }
|
||||
2 400 401 + sub foo () { # empty signature no arguments (styled as prototype)
|
||||
0 401 401 | return 123;
|
||||
0 401 400 | }
|
||||
1 400 400
|
||||
2 400 401 + #--------------------------------------------------------------------------
|
||||
0 401 401 | # perl-test-5200delta.pl
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # subs now take a prototype attribute
|
||||
0 401 400 | #--------------------------------------------------------------------------
|
||||
1 400 400
|
||||
0 400 400 sub foo :prototype($) { $_[0] }
|
||||
1 400 400
|
||||
2 400 401 + sub foo :prototype($$) ($left, $right) {
|
||||
0 401 401 | return $left + $right;
|
||||
0 401 400 | }
|
||||
1 400 400
|
||||
0 400 400 sub foo : prototype($$){} # whitespace allowed
|
||||
1 400 400
|
||||
0 400 400 # additional samples from perl-test-cases.pl with ':prototype' added:
|
||||
0 400 400 sub mylink :prototype($$) {} sub myvec :prototype($$$) {}
|
||||
0 400 400 sub myindex :prototype($$;$) {} sub mysyswrite :prototype($$$;$) {}
|
||||
0 400 400 sub myreverse :prototype(@) {} sub myjoin :prototype($@) {}
|
||||
0 400 400 sub mypop :prototype(\@) {} sub mysplice :prototype(\@$$@) {}
|
||||
0 400 400 sub mykeys :prototype(\%) {} sub myopen :prototype(*;$) {}
|
||||
0 400 400 sub mypipe :prototype(**) {} sub mygrep :prototype(&@) {}
|
||||
0 400 400 sub myrand :prototype($) {} sub mytime :prototype() {}
|
||||
0 400 400 # backslash group notation to specify more than one allowed argument type
|
||||
0 400 400 sub myref :prototype(\[$@%&*]) {}
|
||||
1 400 400
|
||||
2 400 401 + # additional attributes may complicate scanning for prototype syntax,
|
||||
0 401 401 | # for example (from https://metacpan.org/pod/perlsub):
|
||||
0 401 400 | # Lvalue subroutines
|
||||
1 400 400
|
||||
0 400 400 my $val;
|
||||
2 400 401 + sub canmod : lvalue {
|
||||
0 401 401 | $val; # or: return $val;
|
||||
0 401 400 | }
|
||||
0 400 400 canmod() = 5; # assigns to $val
|
||||
1 400 400
|
||||
2 400 401 + #--------------------------------------------------------------------------
|
||||
0 401 401 | # perl-test-5220delta.pl
|
||||
0 401 401 | #--------------------------------------------------------------------------
|
||||
0 401 401 | # New :const subroutine attribute
|
||||
0 401 400 | #--------------------------------------------------------------------------
|
||||
1 400 400
|
||||
0 400 400 my $x = 54321;
|
||||
0 400 400 *INLINED = sub : const { $x };
|
||||
0 400 400 $x++;
|
||||
1 400 400
|
||||
2 400 401 + # more examples of attributes
|
||||
0 401 401 | # (not 5.22 stuff, but some general examples for study, useful for
|
||||
0 401 400 | # handling subroutine signature and subroutine prototype highlighting)
|
||||
1 400 400
|
||||
0 400 400 sub foo : lvalue ;
|
||||
1 400 400
|
||||
2 400 401 + package X;
|
||||
0 401 401 | sub Y::z : lvalue { 1 }
|
||||
1 401 401 |
|
||||
2 400 401 + package X;
|
||||
0 401 401 | sub foo { 1 }
|
||||
2 400 401 + package Y;
|
||||
0 401 401 | BEGIN { *bar = \&X::foo; }
|
||||
2 400 401 + package Z;
|
||||
0 401 401 | sub Y::bar : lvalue ;
|
||||
1 401 401 |
|
||||
0 401 401 | # built-in attributes for subroutines:
|
||||
0 401 401 | lvalue method prototype(..) locked const
|
||||
1 401 401 |
|
||||
2 401 402 + #--------------------------------------------------------------------------
|
||||
0 402 402 | # end of test file
|
||||
0 402 401 | #--------------------------------------------------------------------------
|
||||
0 401 0 |
|
||||
239
3rdparty/lexilla540/lexilla/test/examples/perl/perl-test-sub-prototypes.pl.styled
vendored
Normal file
239
3rdparty/lexilla540/lexilla/test/examples/perl/perl-test-sub-prototypes.pl.styled
vendored
Normal file
@ -0,0 +1,239 @@
|
||||
{2}# -*- coding: utf-8 -*-
|
||||
#--------------------------------------------------------------------------
|
||||
# perl-test-sub-prototypes.pl
|
||||
#--------------------------------------------------------------------------
|
||||
# compiled all relevant subroutine prototype test cases
|
||||
#
|
||||
#--------------------------------------------------------------------------
|
||||
# Kein-Hong Man <keinhong@gmail.com> Public Domain
|
||||
#--------------------------------------------------------------------------
|
||||
# 20151227 initial document
|
||||
#--------------------------------------------------------------------------
|
||||
{0}
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# test cases for sub syntax scanner
|
||||
#--------------------------------------------------------------------------
|
||||
# sub syntax: simple and with added module notation
|
||||
#--------------------------------------------------------------------------
|
||||
{0}
|
||||
{5}sub{0} {11}fish{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0}
|
||||
{5}sub{0} {11}fish{10}::{11}chips{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# module syntax
|
||||
{5}sub{0} {11}fish{10}::{11}chips{10}::{11}sauce{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# multiple module syntax
|
||||
{0}
|
||||
{5}sub{0} {11}fish{0} {10}::{0} {11}chips{0} {10}::{0} {11}sauce{0} {40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# added whitespace
|
||||
{0}
|
||||
{5}sub{0} {11}fish{0} {10}::{0} {2}# embedded comment
|
||||
{11}chips{0} {2}# embedded comment
|
||||
{0} {10}::{0} {11}sauce{0} {40}($){0} {10}{{0} {4}123{10};{0} {10}}{0}
|
||||
|
||||
{5}sub{0} {11}fish{0} {10}::{0} {10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# incomplete or bad syntax examples
|
||||
{5}sub{0} {11}fish{0} {10}::{0} {4}123{0} {10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0}
|
||||
{5}sub{0} {11}fish{0} {10}::{0} {11}chips{0} {4}123{0} {10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0}
|
||||
{5}sub{0} {4}123{0} {10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0}
|
||||
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# sub syntax: prototype attributes
|
||||
#--------------------------------------------------------------------------
|
||||
{0}
|
||||
{5}sub{0} {11}fish{10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0}
|
||||
{5}sub{0} {11}fish{0} {10}:{0} {5}prototype{0} {40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# added whitespace
|
||||
{0}
|
||||
{5}sub{0} {11}fish{10}:{11}salted{10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# wrong attribute example (must use 'prototype')
|
||||
{5}sub{0} {11}fish{0} {10}:{0} {4}123{10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# illegal attribute
|
||||
{5}sub{0} {11}fish{10}:{5}prototype{10}:{11}salted{10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# wrong 'prototype' position
|
||||
{5}sub{0} {11}fish{10}:{11}salted{0} {11}salt{10}:{5}prototype{10}({12}$){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# wrong attribute syntax
|
||||
{0}
|
||||
{5}sub{0} {11}fish{10}:{11}const{10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# extra attributes
|
||||
{5}sub{0} {11}fish{10}:{11}const{10}:{11}lvalue{10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0}
|
||||
{5}sub{0} {11}fish{10}:{11}const{10}:{5}prototype{40}($){10}:{11}lvalue{10}{{0} {4}123{10};{0} {10}}{0} {2}# might be legal too
|
||||
{5}sub{0} {11}fish{0} {10}:{11}const{0} {10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# extra whitespace
|
||||
{0}
|
||||
{5}sub{0} {11}fish{0} {10}:{11}const{0} {2}# embedded comment: a constant sub
|
||||
{10}:{5}prototype{0} {2}# embedded comment
|
||||
{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0}
|
||||
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# sub syntax: mixed
|
||||
#--------------------------------------------------------------------------
|
||||
{0}
|
||||
{5}sub{0} {11}fish{10}::{11}chips{10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0}
|
||||
{5}sub{0} {11}fish{10}::{11}chips{10}::{11}sauce{10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0}
|
||||
{5}sub{0} {11}fish{0} {10}::{11}chips{0} {10}::{11}sauce{0} {10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# +whitespace
|
||||
{0}
|
||||
{5}sub{0} {11}fish{10}::{11}chips{10}::{11}sauce{10}:{11}const{10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0}
|
||||
{5}sub{0} {11}fish{10}::{11}chips{10}::{11}sauce{0} {10}:{11}const{0} {10}:{5}prototype{40}($){0} {10}{{0} {4}123{10};{0} {10}}{0} {2}# +whitespace
|
||||
{0}
|
||||
{5}sub{0} {11}fish{0} {2}# embedded comment
|
||||
{10}::{11}chips{0} {10}::{11}sauce{0} {2}# embedded comment
|
||||
{0} {10}:{0} {11}const{0} {2}# embedded comment
|
||||
{0} {10}:{0} {5}prototype{0} {40}($){0} {10}{{0} {4}123{10};{0} {10}}{0}
|
||||
|
||||
{2}# wrong syntax examples, parentheses must follow ':prototype'
|
||||
{5}sub{0} {11}fish{0} {10}:{5}prototype{0} {10}:{11}const{0} {10}({12}$){0} {10}{{0} {4}123{10};}{0}
|
||||
{5}sub{0} {11}fish{0} {10}:{5}prototype{0} {10}::{11}chips{0} {10}({12}$){0} {10}{{0} {4}123{10};}{0}
|
||||
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# perl-test-5200delta.pl
|
||||
#--------------------------------------------------------------------------
|
||||
# More consistent prototype parsing
|
||||
#--------------------------------------------------------------------------
|
||||
# - whitespace now allowed, lexer now allows spaces or tabs
|
||||
{0}
|
||||
{5}sub{0} {11}foo{0} {40}( $ $ ){0} {10}{}{0}
|
||||
{5}sub{0} {11}foo{0} {40}( ){0} {10}{}{0} {2}# spaces/tabs empty
|
||||
{5}sub{0} {11}foo{0} {40}( * ){0} {10}{}{0}
|
||||
{5}sub{0} {11}foo{0} {40}(@ ){0} {10}{}{0}
|
||||
{5}sub{0} {11}foo{0} {40}( %){0} {10}{}{0}
|
||||
|
||||
{2}# untested, should probably be \[ but scanner does not check this for now
|
||||
{5}sub{0} {11}foo{0} {40}( \ [ $ @ % & * ] ){0} {10}{}{0}
|
||||
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# perl-test-5140delta.pl
|
||||
#--------------------------------------------------------------------------
|
||||
# new + prototype character, acts like (\[@%])
|
||||
#--------------------------------------------------------------------------
|
||||
{0}
|
||||
{2}# these samples work as before
|
||||
{5}sub{0} {11}mylink{0} {40}($$){0} {2}# mylink $old, $new
|
||||
{5}sub{0} {11}myvec{0} {40}($$$){0} {2}# myvec $var, $offset, 1
|
||||
{5}sub{0} {11}myindex{0} {40}($$;$){0} {2}# myindex &getstring, "substr"
|
||||
{5}sub{0} {11}mysyswrite{0} {40}($$$;$){0} {2}# mysyswrite $buf, 0, length($buf) - $off, $off
|
||||
{5}sub{0} {11}myreverse{0} {40}(@){0} {2}# myreverse $a, $b, $c
|
||||
{5}sub{0} {11}myjoin{0} {40}($@){0} {2}# myjoin ":", $a, $b, $c
|
||||
{5}sub{0} {11}myopen{0} {40}(*;$){0} {2}# myopen HANDLE, $name
|
||||
{5}sub{0} {11}mypipe{0} {40}(**){0} {2}# mypipe READHANDLE, WRITEHANDLE
|
||||
{5}sub{0} {11}mygrep{0} {40}(&@){0} {2}# mygrep { /foo/ } $a, $b, $c
|
||||
{5}sub{0} {11}myrand{0} {40}(;$){0} {2}# myrand 42
|
||||
{5}sub{0} {11}mytime{0} {40}(){0} {2}# mytime
|
||||
{0}
|
||||
{2}# backslash group notation to specify more than one allowed argument type
|
||||
{5}sub{0} {11}myref{0} {40}(\[$@%&*]){0} {10}{}{0}
|
||||
|
||||
{5}sub{0} {11}mysub{0} {40}(_){0} {2}# underscore can be optionally used FIXED 20151211
|
||||
{0}
|
||||
{2}# these uses the new '+' prototype character
|
||||
{5}sub{0} {11}mypop{0} {40}(+){0} {2}# mypop @array
|
||||
{5}sub{0} {11}mysplice{0} {40}(+$$@){0} {2}# mysplice @array, 0, 2, @pushme
|
||||
{5}sub{0} {11}mykeys{0} {40}(+){0} {2}# mykeys %{$hashref}
|
||||
{0}
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# perl-test-5200delta.pl
|
||||
#--------------------------------------------------------------------------
|
||||
# Experimental Subroutine signatures (mostly works)
|
||||
#--------------------------------------------------------------------------
|
||||
# INCLUDED FOR COMPLETENESS ONLY
|
||||
# IMPORTANT NOTE the subroutine prototypes lexing implementation has
|
||||
# no effect on subroutine signature syntax highlighting
|
||||
{0}
|
||||
{2}# subroutine signatures mostly looks fine except for the @ and % slurpy
|
||||
# notation which are highlighted as operators (all other parameters are
|
||||
# highlighted as vars of some sort), a minor aesthetic issue
|
||||
{0}
|
||||
{5}use{0} {11}feature{0} {7}'signatures'{10};{0}
|
||||
|
||||
{5}sub{0} {11}foo{0} {10}({12}$left{10},{0} {12}$right{10}){0} {10}{{0} {2}# mandatory positional parameters
|
||||
{0} {5}return{0} {12}$left{0} {10}+{0} {12}$right{10};{0}
|
||||
{10}}{0}
|
||||
{5}sub{0} {11}foo{0} {10}({12}$first{10},{0} {12}$,{0} {12}$third{10}){0} {10}{{0} {2}# ignore second argument
|
||||
{0} {5}return{0} {6}"first={43}$first{6}, third={43}$third{6}"{10};{0}
|
||||
{10}}{0}
|
||||
{5}sub{0} {11}foo{0} {10}({12}$left{10},{0} {12}$right{0} {10}={0} {4}0{10}){0} {10}{{0} {2}# optional parameter with default value
|
||||
{0} {5}return{0} {12}$left{0} {10}+{0} {12}$right{10};{0}
|
||||
{10}}{0}
|
||||
{5}my{0} {12}$auto_id{0} {10}={0} {4}0{10};{0} {2}# default value expression, evaluated if default used only
|
||||
{5}sub{0} {11}foo{0} {10}({12}$thing{10},{0} {12}$id{0} {10}={0} {12}$auto_id{10}++){0} {10}{{0}
|
||||
{5}print{0} {6}"{43}$thing{6} has ID {43}$id{6}"{10};{0}
|
||||
{10}}{0}
|
||||
{5}sub{0} {11}foo{0} {10}({12}$first_name{10},{0} {12}$surname{10},{0} {12}$nickname{0} {10}={0} {12}$first_name{10}){0} {10}{{0} {2}# 3rd parm may depend on 1st parm
|
||||
{0} {5}print{0} {6}"{43}$first_name{6} {43}$surname{6} is known as \"{43}$nickname{6}\""{10};{0}
|
||||
{10}}{0}
|
||||
{5}sub{0} {11}foo{0} {10}({12}$thing{10},{0} {12}${0} {10}={0} {4}1{10}){0} {10}{{0} {2}# nameless default parameter
|
||||
{0} {5}print{0} {12}$thing{10};{0}
|
||||
{10}}{0}
|
||||
{5}sub{0} {11}foo{0} {10}({12}$thing{10},{0} {12}$={10}){0} {10}{{0} {2}# (this does something, I'm not sure what...)
|
||||
{0} {5}print{0} {12}$thing{10};{0}
|
||||
{10}}{0}
|
||||
{5}sub{0} {11}foo{0} {10}({12}$filter{10},{0} {13}@inputs{10}){0} {10}{{0} {2}# additional arguments (slurpy parameter)
|
||||
{0} {5}print{0} {12}$filter{10}->({12}$_{10}){0} {5}foreach{0} {13}@inputs{10};{0}
|
||||
{10}}{0}
|
||||
{5}sub{0} {11}foo{0} {10}({12}$thing{10},{0} {10}@){0} {10}{{0} {2}# nameless slurpy parameter FAILS for now
|
||||
{0} {5}print{0} {12}$thing{10};{0}
|
||||
{10}}{0}
|
||||
{5}sub{0} {11}foo{0} {10}({12}$filter{10},{0} {14}%inputs{10}){0} {10}{{0} {2}# slurpy parameter, hash type
|
||||
{0} {5}print{0} {12}$filter{10}->({12}$_{10},{0} {12}$inputs{10}{{12}$_{10}}){0} {5}foreach{0} {5}sort{0} {5}keys{0} {14}%inputs{10};{0}
|
||||
{10}}{0}
|
||||
{5}sub{0} {11}foo{0} {10}({12}$thing{10},{0} {10}%){0} {10}{{0} {2}# nameless slurpy parm, hash type FAILS for now
|
||||
{0} {5}print{0} {12}$thing{10};{0}
|
||||
{10}}{0}
|
||||
{5}sub{0} {11}foo{0} {40}(){0} {10}{{0} {2}# empty signature no arguments (styled as prototype)
|
||||
{0} {5}return{0} {4}123{10};{0}
|
||||
{10}}{0}
|
||||
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# perl-test-5200delta.pl
|
||||
#--------------------------------------------------------------------------
|
||||
# subs now take a prototype attribute
|
||||
#--------------------------------------------------------------------------
|
||||
{0}
|
||||
{5}sub{0} {11}foo{0} {10}:{5}prototype{40}($){0} {10}{{0} {12}$_{10}[{4}0{10}]{0} {10}}{0}
|
||||
|
||||
{5}sub{0} {11}foo{0} {10}:{5}prototype{40}($$){0} {10}({12}$left{10},{0} {12}$right{10}){0} {10}{{0}
|
||||
{5}return{0} {12}$left{0} {10}+{0} {12}$right{10};{0}
|
||||
{10}}{0}
|
||||
|
||||
{5}sub{0} {11}foo{0} {10}:{0} {5}prototype{40}($$){10}{}{0} {2}# whitespace allowed
|
||||
{0}
|
||||
{2}# additional samples from perl-test-cases.pl with ':prototype' added:
|
||||
{5}sub{0} {11}mylink{0} {10}:{5}prototype{40}($$){0} {10}{}{0} {5}sub{0} {11}myvec{0} {10}:{5}prototype{40}($$$){0} {10}{}{0}
|
||||
{5}sub{0} {11}myindex{0} {10}:{5}prototype{40}($$;$){0} {10}{}{0} {5}sub{0} {11}mysyswrite{0} {10}:{5}prototype{40}($$$;$){0} {10}{}{0}
|
||||
{5}sub{0} {11}myreverse{0} {10}:{5}prototype{40}(@){0} {10}{}{0} {5}sub{0} {11}myjoin{0} {10}:{5}prototype{40}($@){0} {10}{}{0}
|
||||
{5}sub{0} {11}mypop{0} {10}:{5}prototype{40}(\@){0} {10}{}{0} {5}sub{0} {11}mysplice{0} {10}:{5}prototype{40}(\@$$@){0} {10}{}{0}
|
||||
{5}sub{0} {11}mykeys{0} {10}:{5}prototype{40}(\%){0} {10}{}{0} {5}sub{0} {11}myopen{0} {10}:{5}prototype{40}(*;$){0} {10}{}{0}
|
||||
{5}sub{0} {11}mypipe{0} {10}:{5}prototype{40}(**){0} {10}{}{0} {5}sub{0} {11}mygrep{0} {10}:{5}prototype{40}(&@){0} {10}{}{0}
|
||||
{5}sub{0} {11}myrand{0} {10}:{5}prototype{40}($){0} {10}{}{0} {5}sub{0} {11}mytime{0} {10}:{5}prototype{40}(){0} {10}{}{0}
|
||||
{2}# backslash group notation to specify more than one allowed argument type
|
||||
{5}sub{0} {11}myref{0} {10}:{5}prototype{40}(\[$@%&*]){0} {10}{}{0}
|
||||
|
||||
{2}# additional attributes may complicate scanning for prototype syntax,
|
||||
# for example (from https://metacpan.org/pod/perlsub):
|
||||
# Lvalue subroutines
|
||||
{0}
|
||||
{5}my{0} {12}$val{10};{0}
|
||||
{5}sub{0} {11}canmod{0} {10}:{0} {11}lvalue{0} {10}{{0}
|
||||
{12}$val{10};{0} {2}# or: return $val;
|
||||
{10}}{0}
|
||||
{11}canmod{10}(){0} {10}={0} {4}5{10};{0} {2}# assigns to $val
|
||||
{0}
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# perl-test-5220delta.pl
|
||||
#--------------------------------------------------------------------------
|
||||
# New :const subroutine attribute
|
||||
#--------------------------------------------------------------------------
|
||||
{0}
|
||||
{5}my{0} {12}$x{0} {10}={0} {4}54321{10};{0}
|
||||
{15}*INLINED{0} {10}={0} {5}sub{0} {10}:{0} {11}const{0} {10}{{0} {12}$x{0} {10}};{0}
|
||||
{12}$x{10}++;{0}
|
||||
|
||||
{2}# more examples of attributes
|
||||
# (not 5.22 stuff, but some general examples for study, useful for
|
||||
# handling subroutine signature and subroutine prototype highlighting)
|
||||
{0}
|
||||
{5}sub{0} {11}foo{0} {10}:{0} {11}lvalue{0} {10};{0}
|
||||
|
||||
{5}package{0} {11}X{10};{0}
|
||||
{5}sub{0} {11}Y{10}::{11}z{0} {10}:{0} {11}lvalue{0} {10}{{0} {4}1{0} {10}}{0}
|
||||
|
||||
{5}package{0} {11}X{10};{0}
|
||||
{5}sub{0} {11}foo{0} {10}{{0} {4}1{0} {10}}{0}
|
||||
{5}package{0} {11}Y{10};{0}
|
||||
{5}BEGIN{0} {10}{{0} {15}*bar{0} {10}={0} {10}\&{11}X{10}::{11}foo{10};{0} {10}}{0}
|
||||
{5}package{0} {11}Z{10};{0}
|
||||
{5}sub{0} {11}Y{10}::{11}bar{0} {10}:{0} {11}lvalue{0} {10};{0}
|
||||
|
||||
{2}# built-in attributes for subroutines:
|
||||
{11}lvalue{0} {11}method{0} {5}prototype{10}(..){0} {11}locked{0} {11}const{0}
|
||||
|
||||
{2}#--------------------------------------------------------------------------
|
||||
# end of test file
|
||||
#--------------------------------------------------------------------------
|
||||
5
3rdparty/lexilla540/lexilla/test/examples/perl/x.pl
vendored
Normal file
5
3rdparty/lexilla540/lexilla/test/examples/perl/x.pl
vendored
Normal file
@ -0,0 +1,5 @@
|
||||
use strict;
|
||||
while ( $r ) {
|
||||
printf ( "Example text \n" );
|
||||
sleep 1;
|
||||
}
|
||||
5
3rdparty/lexilla540/lexilla/test/examples/perl/x.pl.folded
vendored
Normal file
5
3rdparty/lexilla540/lexilla/test/examples/perl/x.pl.folded
vendored
Normal file
@ -0,0 +1,5 @@
|
||||
0 400 400 use strict;
|
||||
2 400 401 + while ( $r ) {
|
||||
0 401 401 | printf ( "Example text \n" );
|
||||
0 401 401 | sleep 1;
|
||||
0 401 0 | }
|
||||
5
3rdparty/lexilla540/lexilla/test/examples/perl/x.pl.styled
vendored
Normal file
5
3rdparty/lexilla540/lexilla/test/examples/perl/x.pl.styled
vendored
Normal file
@ -0,0 +1,5 @@
|
||||
{5}use{0} {11}strict{10};{0}
|
||||
{5}while{0} {10}({0} {12}$r{0} {10}){0} {10}{{0}
|
||||
{5}printf{0} {10}({0} {6}"Example text \n"{0} {10});{0}
|
||||
{5}sleep{0} {4}1{10};{0}
|
||||
{10}}
|
||||
Reference in New Issue
Block a user