openrat-cms

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs | README

perl.js (56135B)


      1 // CodeMirror, copyright (c) by Marijn Haverbeke and others
      2 // Distributed under an MIT license: http://codemirror.net/LICENSE
      3 
      4 // CodeMirror2 mode/perl/perl.js (text/x-perl) beta 0.10 (2011-11-08)
      5 // This is a part of CodeMirror from https://github.com/sabaca/CodeMirror_mode_perl (mail@sabaca.com)
      6 
      7 (function(mod) {
      8   if (typeof exports == "object" && typeof module == "object") // CommonJS
      9     mod(require("../../lib/codemirror"));
     10   else if (typeof define == "function" && define.amd) // AMD
     11     define(["../../lib/codemirror"], mod);
     12   else // Plain browser env
     13     mod(CodeMirror);
     14 })(function(CodeMirror) {
     15 "use strict";
     16 
     17 CodeMirror.defineMode("perl",function(){
     18         // http://perldoc.perl.org
     19         var PERL={                                      //   null - magic touch
     20                                                         //   1 - keyword
     21                                                         //   2 - def
     22                                                         //   3 - atom
     23                                                         //   4 - operator
     24                                                         //   5 - variable-2 (predefined)
     25                                                         //   [x,y] - x=1,2,3; y=must be defined if x{...}
     26                                                 //      PERL operators
     27                 '->'                            :   4,
     28                 '++'                            :   4,
     29                 '--'                            :   4,
     30                 '**'                            :   4,
     31                                                         //   ! ~ \ and unary + and -
     32                 '=~'                            :   4,
     33                 '!~'                            :   4,
     34                 '*'                             :   4,
     35                 '/'                             :   4,
     36                 '%'                             :   4,
     37                 'x'                             :   4,
     38                 '+'                             :   4,
     39                 '-'                             :   4,
     40                 '.'                             :   4,
     41                 '<<'                            :   4,
     42                 '>>'                            :   4,
     43                                                         //   named unary operators
     44                 '<'                             :   4,
     45                 '>'                             :   4,
     46                 '<='                            :   4,
     47                 '>='                            :   4,
     48                 'lt'                            :   4,
     49                 'gt'                            :   4,
     50                 'le'                            :   4,
     51                 'ge'                            :   4,
     52                 '=='                            :   4,
     53                 '!='                            :   4,
     54                 '<=>'                           :   4,
     55                 'eq'                            :   4,
     56                 'ne'                            :   4,
     57                 'cmp'                           :   4,
     58                 '~~'                            :   4,
     59                 '&'                             :   4,
     60                 '|'                             :   4,
     61                 '^'                             :   4,
     62                 '&&'                            :   4,
     63                 '||'                            :   4,
     64                 '//'                            :   4,
     65                 '..'                            :   4,
     66                 '...'                           :   4,
     67                 '?'                             :   4,
     68                 ':'                             :   4,
     69                 '='                             :   4,
     70                 '+='                            :   4,
     71                 '-='                            :   4,
     72                 '*='                            :   4,  //   etc. ???
     73                 ','                             :   4,
     74                 '=>'                            :   4,
     75                 '::'                            :   4,
     76                                                         //   list operators (rightward)
     77                 'not'                           :   4,
     78                 'and'                           :   4,
     79                 'or'                            :   4,
     80                 'xor'                           :   4,
     81                                                 //      PERL predefined variables (I know, what this is a paranoid idea, but may be needed for people, who learn PERL, and for me as well, ...and may be for you?;)
     82                 'BEGIN'                         :   [5,1],
     83                 'END'                           :   [5,1],
     84                 'PRINT'                         :   [5,1],
     85                 'PRINTF'                        :   [5,1],
     86                 'GETC'                          :   [5,1],
     87                 'READ'                          :   [5,1],
     88                 'READLINE'                      :   [5,1],
     89                 'DESTROY'                       :   [5,1],
     90                 'TIE'                           :   [5,1],
     91                 'TIEHANDLE'                     :   [5,1],
     92                 'UNTIE'                         :   [5,1],
     93                 'STDIN'                         :    5,
     94                 'STDIN_TOP'                     :    5,
     95                 'STDOUT'                        :    5,
     96                 'STDOUT_TOP'                    :    5,
     97                 'STDERR'                        :    5,
     98                 'STDERR_TOP'                    :    5,
     99                 '$ARG'                          :    5,
    100                 '$_'                            :    5,
    101                 '@ARG'                          :    5,
    102                 '@_'                            :    5,
    103                 '$LIST_SEPARATOR'               :    5,
    104                 '$"'                            :    5,
    105                 '$PROCESS_ID'                   :    5,
    106                 '$PID'                          :    5,
    107                 '$$'                            :    5,
    108                 '$REAL_GROUP_ID'                :    5,
    109                 '$GID'                          :    5,
    110                 '$('                            :    5,
    111                 '$EFFECTIVE_GROUP_ID'           :    5,
    112                 '$EGID'                         :    5,
    113                 '$)'                            :    5,
    114                 '$PROGRAM_NAME'                 :    5,
    115                 '$0'                            :    5,
    116                 '$SUBSCRIPT_SEPARATOR'          :    5,
    117                 '$SUBSEP'                       :    5,
    118                 '$;'                            :    5,
    119                 '$REAL_USER_ID'                 :    5,
    120                 '$UID'                          :    5,
    121                 '$<'                            :    5,
    122                 '$EFFECTIVE_USER_ID'            :    5,
    123                 '$EUID'                         :    5,
    124                 '$>'                            :    5,
    125                 '$a'                            :    5,
    126                 '$b'                            :    5,
    127                 '$COMPILING'                    :    5,
    128                 '$^C'                           :    5,
    129                 '$DEBUGGING'                    :    5,
    130                 '$^D'                           :    5,
    131                 '${^ENCODING}'                  :    5,
    132                 '$ENV'                          :    5,
    133                 '%ENV'                          :    5,
    134                 '$SYSTEM_FD_MAX'                :    5,
    135                 '$^F'                           :    5,
    136                 '@F'                            :    5,
    137                 '${^GLOBAL_PHASE}'              :    5,
    138                 '$^H'                           :    5,
    139                 '%^H'                           :    5,
    140                 '@INC'                          :    5,
    141                 '%INC'                          :    5,
    142                 '$INPLACE_EDIT'                 :    5,
    143                 '$^I'                           :    5,
    144                 '$^M'                           :    5,
    145                 '$OSNAME'                       :    5,
    146                 '$^O'                           :    5,
    147                 '${^OPEN}'                      :    5,
    148                 '$PERLDB'                       :    5,
    149                 '$^P'                           :    5,
    150                 '$SIG'                          :    5,
    151                 '%SIG'                          :    5,
    152                 '$BASETIME'                     :    5,
    153                 '$^T'                           :    5,
    154                 '${^TAINT}'                     :    5,
    155                 '${^UNICODE}'                   :    5,
    156                 '${^UTF8CACHE}'                 :    5,
    157                 '${^UTF8LOCALE}'                :    5,
    158                 '$PERL_VERSION'                 :    5,
    159                 '$^V'                           :    5,
    160                 '${^WIN32_SLOPPY_STAT}'         :    5,
    161                 '$EXECUTABLE_NAME'              :    5,
    162                 '$^X'                           :    5,
    163                 '$1'                            :    5, // - regexp $1, $2...
    164                 '$MATCH'                        :    5,
    165                 '$&'                            :    5,
    166                 '${^MATCH}'                     :    5,
    167                 '$PREMATCH'                     :    5,
    168                 '$`'                            :    5,
    169                 '${^PREMATCH}'                  :    5,
    170                 '$POSTMATCH'                    :    5,
    171                 "$'"                            :    5,
    172                 '${^POSTMATCH}'                 :    5,
    173                 '$LAST_PAREN_MATCH'             :    5,
    174                 '$+'                            :    5,
    175                 '$LAST_SUBMATCH_RESULT'         :    5,
    176                 '$^N'                           :    5,
    177                 '@LAST_MATCH_END'               :    5,
    178                 '@+'                            :    5,
    179                 '%LAST_PAREN_MATCH'             :    5,
    180                 '%+'                            :    5,
    181                 '@LAST_MATCH_START'             :    5,
    182                 '@-'                            :    5,
    183                 '%LAST_MATCH_START'             :    5,
    184                 '%-'                            :    5,
    185                 '$LAST_REGEXP_CODE_RESULT'      :    5,
    186                 '$^R'                           :    5,
    187                 '${^RE_DEBUG_FLAGS}'            :    5,
    188                 '${^RE_TRIE_MAXBUF}'            :    5,
    189                 '$ARGV'                         :    5,
    190                 '@ARGV'                         :    5,
    191                 'ARGV'                          :    5,
    192                 'ARGVOUT'                       :    5,
    193                 '$OUTPUT_FIELD_SEPARATOR'       :    5,
    194                 '$OFS'                          :    5,
    195                 '$,'                            :    5,
    196                 '$INPUT_LINE_NUMBER'            :    5,
    197                 '$NR'                           :    5,
    198                 '$.'                            :    5,
    199                 '$INPUT_RECORD_SEPARATOR'       :    5,
    200                 '$RS'                           :    5,
    201                 '$/'                            :    5,
    202                 '$OUTPUT_RECORD_SEPARATOR'      :    5,
    203                 '$ORS'                          :    5,
    204                 '$\\'                           :    5,
    205                 '$OUTPUT_AUTOFLUSH'             :    5,
    206                 '$|'                            :    5,
    207                 '$ACCUMULATOR'                  :    5,
    208                 '$^A'                           :    5,
    209                 '$FORMAT_FORMFEED'              :    5,
    210                 '$^L'                           :    5,
    211                 '$FORMAT_PAGE_NUMBER'           :    5,
    212                 '$%'                            :    5,
    213                 '$FORMAT_LINES_LEFT'            :    5,
    214                 '$-'                            :    5,
    215                 '$FORMAT_LINE_BREAK_CHARACTERS' :    5,
    216                 '$:'                            :    5,
    217                 '$FORMAT_LINES_PER_PAGE'        :    5,
    218                 '$='                            :    5,
    219                 '$FORMAT_TOP_NAME'              :    5,
    220                 '$^'                            :    5,
    221                 '$FORMAT_NAME'                  :    5,
    222                 '$~'                            :    5,
    223                 '${^CHILD_ERROR_NATIVE}'        :    5,
    224                 '$EXTENDED_OS_ERROR'            :    5,
    225                 '$^E'                           :    5,
    226                 '$EXCEPTIONS_BEING_CAUGHT'      :    5,
    227                 '$^S'                           :    5,
    228                 '$WARNING'                      :    5,
    229                 '$^W'                           :    5,
    230                 '${^WARNING_BITS}'              :    5,
    231                 '$OS_ERROR'                     :    5,
    232                 '$ERRNO'                        :    5,
    233                 '$!'                            :    5,
    234                 '%OS_ERROR'                     :    5,
    235                 '%ERRNO'                        :    5,
    236                 '%!'                            :    5,
    237                 '$CHILD_ERROR'                  :    5,
    238                 '$?'                            :    5,
    239                 '$EVAL_ERROR'                   :    5,
    240                 '$@'                            :    5,
    241                 '$OFMT'                         :    5,
    242                 '$#'                            :    5,
    243                 '$*'                            :    5,
    244                 '$ARRAY_BASE'                   :    5,
    245                 '$['                            :    5,
    246                 '$OLD_PERL_VERSION'             :    5,
    247                 '$]'                            :    5,
    248                                                 //      PERL blocks
    249                 'if'                            :[1,1],
    250                 elsif                           :[1,1],
    251                 'else'                          :[1,1],
    252                 'while'                         :[1,1],
    253                 unless                          :[1,1],
    254                 'for'                           :[1,1],
    255                 foreach                         :[1,1],
    256                                                 //      PERL functions
    257                 'abs'                           :1,     // - absolute value function
    258                 accept                          :1,     // - accept an incoming socket connect
    259                 alarm                           :1,     // - schedule a SIGALRM
    260                 'atan2'                         :1,     // - arctangent of Y/X in the range -PI to PI
    261                 bind                            :1,     // - binds an address to a socket
    262                 binmode                         :1,     // - prepare binary files for I/O
    263                 bless                           :1,     // - create an object
    264                 bootstrap                       :1,     //
    265                 'break'                         :1,     // - break out of a "given" block
    266                 caller                          :1,     // - get context of the current subroutine call
    267                 chdir                           :1,     // - change your current working directory
    268                 chmod                           :1,     // - changes the permissions on a list of files
    269                 chomp                           :1,     // - remove a trailing record separator from a string
    270                 chop                            :1,     // - remove the last character from a string
    271                 chown                           :1,     // - change the ownership on a list of files
    272                 chr                             :1,     // - get character this number represents
    273                 chroot                          :1,     // - make directory new root for path lookups
    274                 close                           :1,     // - close file (or pipe or socket) handle
    275                 closedir                        :1,     // - close directory handle
    276                 connect                         :1,     // - connect to a remote socket
    277                 'continue'                      :[1,1], // - optional trailing block in a while or foreach
    278                 'cos'                           :1,     // - cosine function
    279                 crypt                           :1,     // - one-way passwd-style encryption
    280                 dbmclose                        :1,     // - breaks binding on a tied dbm file
    281                 dbmopen                         :1,     // - create binding on a tied dbm file
    282                 'default'                       :1,     //
    283                 defined                         :1,     // - test whether a value, variable, or function is defined
    284                 'delete'                        :1,     // - deletes a value from a hash
    285                 die                             :1,     // - raise an exception or bail out
    286                 'do'                            :1,     // - turn a BLOCK into a TERM
    287                 dump                            :1,     // - create an immediate core dump
    288                 each                            :1,     // - retrieve the next key/value pair from a hash
    289                 endgrent                        :1,     // - be done using group file
    290                 endhostent                      :1,     // - be done using hosts file
    291                 endnetent                       :1,     // - be done using networks file
    292                 endprotoent                     :1,     // - be done using protocols file
    293                 endpwent                        :1,     // - be done using passwd file
    294                 endservent                      :1,     // - be done using services file
    295                 eof                             :1,     // - test a filehandle for its end
    296                 'eval'                          :1,     // - catch exceptions or compile and run code
    297                 'exec'                          :1,     // - abandon this program to run another
    298                 exists                          :1,     // - test whether a hash key is present
    299                 exit                            :1,     // - terminate this program
    300                 'exp'                           :1,     // - raise I to a power
    301                 fcntl                           :1,     // - file control system call
    302                 fileno                          :1,     // - return file descriptor from filehandle
    303                 flock                           :1,     // - lock an entire file with an advisory lock
    304                 fork                            :1,     // - create a new process just like this one
    305                 format                          :1,     // - declare a picture format with use by the write() function
    306                 formline                        :1,     // - internal function used for formats
    307                 getc                            :1,     // - get the next character from the filehandle
    308                 getgrent                        :1,     // - get next group record
    309                 getgrgid                        :1,     // - get group record given group user ID
    310                 getgrnam                        :1,     // - get group record given group name
    311                 gethostbyaddr                   :1,     // - get host record given its address
    312                 gethostbyname                   :1,     // - get host record given name
    313                 gethostent                      :1,     // - get next hosts record
    314                 getlogin                        :1,     // - return who logged in at this tty
    315                 getnetbyaddr                    :1,     // - get network record given its address
    316                 getnetbyname                    :1,     // - get networks record given name
    317                 getnetent                       :1,     // - get next networks record
    318                 getpeername                     :1,     // - find the other end of a socket connection
    319                 getpgrp                         :1,     // - get process group
    320                 getppid                         :1,     // - get parent process ID
    321                 getpriority                     :1,     // - get current nice value
    322                 getprotobyname                  :1,     // - get protocol record given name
    323                 getprotobynumber                :1,     // - get protocol record numeric protocol
    324                 getprotoent                     :1,     // - get next protocols record
    325                 getpwent                        :1,     // - get next passwd record
    326                 getpwnam                        :1,     // - get passwd record given user login name
    327                 getpwuid                        :1,     // - get passwd record given user ID
    328                 getservbyname                   :1,     // - get services record given its name
    329                 getservbyport                   :1,     // - get services record given numeric port
    330                 getservent                      :1,     // - get next services record
    331                 getsockname                     :1,     // - retrieve the sockaddr for a given socket
    332                 getsockopt                      :1,     // - get socket options on a given socket
    333                 given                           :1,     //
    334                 glob                            :1,     // - expand filenames using wildcards
    335                 gmtime                          :1,     // - convert UNIX time into record or string using Greenwich time
    336                 'goto'                          :1,     // - create spaghetti code
    337                 grep                            :1,     // - locate elements in a list test true against a given criterion
    338                 hex                             :1,     // - convert a string to a hexadecimal number
    339                 'import'                        :1,     // - patch a module's namespace into your own
    340                 index                           :1,     // - find a substring within a string
    341                 'int'                           :1,     // - get the integer portion of a number
    342                 ioctl                           :1,     // - system-dependent device control system call
    343                 'join'                          :1,     // - join a list into a string using a separator
    344                 keys                            :1,     // - retrieve list of indices from a hash
    345                 kill                            :1,     // - send a signal to a process or process group
    346                 last                            :1,     // - exit a block prematurely
    347                 lc                              :1,     // - return lower-case version of a string
    348                 lcfirst                         :1,     // - return a string with just the next letter in lower case
    349                 length                          :1,     // - return the number of bytes in a string
    350                 'link'                          :1,     // - create a hard link in the filesytem
    351                 listen                          :1,     // - register your socket as a server
    352                 local                           : 2,    // - create a temporary value for a global variable (dynamic scoping)
    353                 localtime                       :1,     // - convert UNIX time into record or string using local time
    354                 lock                            :1,     // - get a thread lock on a variable, subroutine, or method
    355                 'log'                           :1,     // - retrieve the natural logarithm for a number
    356                 lstat                           :1,     // - stat a symbolic link
    357                 m                               :null,  // - match a string with a regular expression pattern
    358                 map                             :1,     // - apply a change to a list to get back a new list with the changes
    359                 mkdir                           :1,     // - create a directory
    360                 msgctl                          :1,     // - SysV IPC message control operations
    361                 msgget                          :1,     // - get SysV IPC message queue
    362                 msgrcv                          :1,     // - receive a SysV IPC message from a message queue
    363                 msgsnd                          :1,     // - send a SysV IPC message to a message queue
    364                 my                              : 2,    // - declare and assign a local variable (lexical scoping)
    365                 'new'                           :1,     //
    366                 next                            :1,     // - iterate a block prematurely
    367                 no                              :1,     // - unimport some module symbols or semantics at compile time
    368                 oct                             :1,     // - convert a string to an octal number
    369                 open                            :1,     // - open a file, pipe, or descriptor
    370                 opendir                         :1,     // - open a directory
    371                 ord                             :1,     // - find a character's numeric representation
    372                 our                             : 2,    // - declare and assign a package variable (lexical scoping)
    373                 pack                            :1,     // - convert a list into a binary representation
    374                 'package'                       :1,     // - declare a separate global namespace
    375                 pipe                            :1,     // - open a pair of connected filehandles
    376                 pop                             :1,     // - remove the last element from an array and return it
    377                 pos                             :1,     // - find or set the offset for the last/next m//g search
    378                 print                           :1,     // - output a list to a filehandle
    379                 printf                          :1,     // - output a formatted list to a filehandle
    380                 prototype                       :1,     // - get the prototype (if any) of a subroutine
    381                 push                            :1,     // - append one or more elements to an array
    382                 q                               :null,  // - singly quote a string
    383                 qq                              :null,  // - doubly quote a string
    384                 qr                              :null,  // - Compile pattern
    385                 quotemeta                       :null,  // - quote regular expression magic characters
    386                 qw                              :null,  // - quote a list of words
    387                 qx                              :null,  // - backquote quote a string
    388                 rand                            :1,     // - retrieve the next pseudorandom number
    389                 read                            :1,     // - fixed-length buffered input from a filehandle
    390                 readdir                         :1,     // - get a directory from a directory handle
    391                 readline                        :1,     // - fetch a record from a file
    392                 readlink                        :1,     // - determine where a symbolic link is pointing
    393                 readpipe                        :1,     // - execute a system command and collect standard output
    394                 recv                            :1,     // - receive a message over a Socket
    395                 redo                            :1,     // - start this loop iteration over again
    396                 ref                             :1,     // - find out the type of thing being referenced
    397                 rename                          :1,     // - change a filename
    398                 require                         :1,     // - load in external functions from a library at runtime
    399                 reset                           :1,     // - clear all variables of a given name
    400                 'return'                        :1,     // - get out of a function early
    401                 reverse                         :1,     // - flip a string or a list
    402                 rewinddir                       :1,     // - reset directory handle
    403                 rindex                          :1,     // - right-to-left substring search
    404                 rmdir                           :1,     // - remove a directory
    405                 s                               :null,  // - replace a pattern with a string
    406                 say                             :1,     // - print with newline
    407                 scalar                          :1,     // - force a scalar context
    408                 seek                            :1,     // - reposition file pointer for random-access I/O
    409                 seekdir                         :1,     // - reposition directory pointer
    410                 select                          :1,     // - reset default output or do I/O multiplexing
    411                 semctl                          :1,     // - SysV semaphore control operations
    412                 semget                          :1,     // - get set of SysV semaphores
    413                 semop                           :1,     // - SysV semaphore operations
    414                 send                            :1,     // - send a message over a socket
    415                 setgrent                        :1,     // - prepare group file for use
    416                 sethostent                      :1,     // - prepare hosts file for use
    417                 setnetent                       :1,     // - prepare networks file for use
    418                 setpgrp                         :1,     // - set the process group of a process
    419                 setpriority                     :1,     // - set a process's nice value
    420                 setprotoent                     :1,     // - prepare protocols file for use
    421                 setpwent                        :1,     // - prepare passwd file for use
    422                 setservent                      :1,     // - prepare services file for use
    423                 setsockopt                      :1,     // - set some socket options
    424                 shift                           :1,     // - remove the first element of an array, and return it
    425                 shmctl                          :1,     // - SysV shared memory operations
    426                 shmget                          :1,     // - get SysV shared memory segment identifier
    427                 shmread                         :1,     // - read SysV shared memory
    428                 shmwrite                        :1,     // - write SysV shared memory
    429                 shutdown                        :1,     // - close down just half of a socket connection
    430                 'sin'                           :1,     // - return the sine of a number
    431                 sleep                           :1,     // - block for some number of seconds
    432                 socket                          :1,     // - create a socket
    433                 socketpair                      :1,     // - create a pair of sockets
    434                 'sort'                          :1,     // - sort a list of values
    435                 splice                          :1,     // - add or remove elements anywhere in an array
    436                 'split'                         :1,     // - split up a string using a regexp delimiter
    437                 sprintf                         :1,     // - formatted print into a string
    438                 'sqrt'                          :1,     // - square root function
    439                 srand                           :1,     // - seed the random number generator
    440                 stat                            :1,     // - get a file's status information
    441                 state                           :1,     // - declare and assign a state variable (persistent lexical scoping)
    442                 study                           :1,     // - optimize input data for repeated searches
    443                 'sub'                           :1,     // - declare a subroutine, possibly anonymously
    444                 'substr'                        :1,     // - get or alter a portion of a stirng
    445                 symlink                         :1,     // - create a symbolic link to a file
    446                 syscall                         :1,     // - execute an arbitrary system call
    447                 sysopen                         :1,     // - open a file, pipe, or descriptor
    448                 sysread                         :1,     // - fixed-length unbuffered input from a filehandle
    449                 sysseek                         :1,     // - position I/O pointer on handle used with sysread and syswrite
    450                 system                          :1,     // - run a separate program
    451                 syswrite                        :1,     // - fixed-length unbuffered output to a filehandle
    452                 tell                            :1,     // - get current seekpointer on a filehandle
    453                 telldir                         :1,     // - get current seekpointer on a directory handle
    454                 tie                             :1,     // - bind a variable to an object class
    455                 tied                            :1,     // - get a reference to the object underlying a tied variable
    456                 time                            :1,     // - return number of seconds since 1970
    457                 times                           :1,     // - return elapsed time for self and child processes
    458                 tr                              :null,  // - transliterate a string
    459                 truncate                        :1,     // - shorten a file
    460                 uc                              :1,     // - return upper-case version of a string
    461                 ucfirst                         :1,     // - return a string with just the next letter in upper case
    462                 umask                           :1,     // - set file creation mode mask
    463                 undef                           :1,     // - remove a variable or function definition
    464                 unlink                          :1,     // - remove one link to a file
    465                 unpack                          :1,     // - convert binary structure into normal perl variables
    466                 unshift                         :1,     // - prepend more elements to the beginning of a list
    467                 untie                           :1,     // - break a tie binding to a variable
    468                 use                             :1,     // - load in a module at compile time
    469                 utime                           :1,     // - set a file's last access and modify times
    470                 values                          :1,     // - return a list of the values in a hash
    471                 vec                             :1,     // - test or set particular bits in a string
    472                 wait                            :1,     // - wait for any child process to die
    473                 waitpid                         :1,     // - wait for a particular child process to die
    474                 wantarray                       :1,     // - get void vs scalar vs list context of current subroutine call
    475                 warn                            :1,     // - print debugging info
    476                 when                            :1,     //
    477                 write                           :1,     // - print a picture record
    478                 y                               :null}; // - transliterate a string
    479 
    480         var RXstyle="string-2";
    481         var RXmodifiers=/[goseximacplud]/;              // NOTE: "m", "s", "y" and "tr" need to correct real modifiers for each regexp type
    482 
    483         function tokenChain(stream,state,chain,style,tail){     // NOTE: chain.length > 2 is not working now (it's for s[...][...]geos;)
    484                 state.chain=null;                               //                                                          12   3tail
    485                 state.style=null;
    486                 state.tail=null;
    487                 state.tokenize=function(stream,state){
    488                         var e=false,c,i=0;
    489                         while(c=stream.next()){
    490                                 if(c===chain[i]&&!e){
    491                                         if(chain[++i]!==undefined){
    492                                                 state.chain=chain[i];
    493                                                 state.style=style;
    494                                                 state.tail=tail;}
    495                                         else if(tail)
    496                                                 stream.eatWhile(tail);
    497                                         state.tokenize=tokenPerl;
    498                                         return style;}
    499                                 e=!e&&c=="\\";}
    500                         return style;};
    501                 return state.tokenize(stream,state);}
    502 
    503         function tokenSOMETHING(stream,state,string){
    504                 state.tokenize=function(stream,state){
    505                         if(stream.string==string)
    506                                 state.tokenize=tokenPerl;
    507                         stream.skipToEnd();
    508                         return "string";};
    509                 return state.tokenize(stream,state);}
    510 
    511         function tokenPerl(stream,state){
    512                 if(stream.eatSpace())
    513                         return null;
    514                 if(state.chain)
    515                         return tokenChain(stream,state,state.chain,state.style,state.tail);
    516                 if(stream.match(/^\-?[\d\.]/,false))
    517                         if(stream.match(/^(\-?(\d*\.\d+(e[+-]?\d+)?|\d+\.\d*)|0x[\da-fA-F]+|0b[01]+|\d+(e[+-]?\d+)?)/))
    518                                 return 'number';
    519                 if(stream.match(/^<<(?=\w)/)){                  // NOTE: <<SOMETHING\n...\nSOMETHING\n
    520                         stream.eatWhile(/\w/);
    521                         return tokenSOMETHING(stream,state,stream.current().substr(2));}
    522                 if(stream.sol()&&stream.match(/^\=item(?!\w)/)){// NOTE: \n=item...\n=cut\n
    523                         return tokenSOMETHING(stream,state,'=cut');}
    524                 var ch=stream.next();
    525                 if(ch=='"'||ch=="'"){                           // NOTE: ' or " or <<'SOMETHING'\n...\nSOMETHING\n or <<"SOMETHING"\n...\nSOMETHING\n
    526                         if(prefix(stream, 3)=="<<"+ch){
    527                                 var p=stream.pos;
    528                                 stream.eatWhile(/\w/);
    529                                 var n=stream.current().substr(1);
    530                                 if(n&&stream.eat(ch))
    531                                         return tokenSOMETHING(stream,state,n);
    532                                 stream.pos=p;}
    533                         return tokenChain(stream,state,[ch],"string");}
    534                 if(ch=="q"){
    535                         var c=look(stream, -2);
    536                         if(!(c&&/\w/.test(c))){
    537                                 c=look(stream, 0);
    538                                 if(c=="x"){
    539                                         c=look(stream, 1);
    540                                         if(c=="("){
    541                                                 eatSuffix(stream, 2);
    542                                                 return tokenChain(stream,state,[")"],RXstyle,RXmodifiers);}
    543                                         if(c=="["){
    544                                                 eatSuffix(stream, 2);
    545                                                 return tokenChain(stream,state,["]"],RXstyle,RXmodifiers);}
    546                                         if(c=="{"){
    547                                                 eatSuffix(stream, 2);
    548                                                 return tokenChain(stream,state,["}"],RXstyle,RXmodifiers);}
    549                                         if(c=="<"){
    550                                                 eatSuffix(stream, 2);
    551                                                 return tokenChain(stream,state,[">"],RXstyle,RXmodifiers);}
    552                                         if(/[\^'"!~\/]/.test(c)){
    553                                                 eatSuffix(stream, 1);
    554                                                 return tokenChain(stream,state,[stream.eat(c)],RXstyle,RXmodifiers);}}
    555                                 else if(c=="q"){
    556                                         c=look(stream, 1);
    557                                         if(c=="("){
    558                                                 eatSuffix(stream, 2);
    559                                                 return tokenChain(stream,state,[")"],"string");}
    560                                         if(c=="["){
    561                                                 eatSuffix(stream, 2);
    562                                                 return tokenChain(stream,state,["]"],"string");}
    563                                         if(c=="{"){
    564                                                 eatSuffix(stream, 2);
    565                                                 return tokenChain(stream,state,["}"],"string");}
    566                                         if(c=="<"){
    567                                                 eatSuffix(stream, 2);
    568                                                 return tokenChain(stream,state,[">"],"string");}
    569                                         if(/[\^'"!~\/]/.test(c)){
    570                                                 eatSuffix(stream, 1);
    571                                                 return tokenChain(stream,state,[stream.eat(c)],"string");}}
    572                                 else if(c=="w"){
    573                                         c=look(stream, 1);
    574                                         if(c=="("){
    575                                                 eatSuffix(stream, 2);
    576                                                 return tokenChain(stream,state,[")"],"bracket");}
    577                                         if(c=="["){
    578                                                 eatSuffix(stream, 2);
    579                                                 return tokenChain(stream,state,["]"],"bracket");}
    580                                         if(c=="{"){
    581                                                 eatSuffix(stream, 2);
    582                                                 return tokenChain(stream,state,["}"],"bracket");}
    583                                         if(c=="<"){
    584                                                 eatSuffix(stream, 2);
    585                                                 return tokenChain(stream,state,[">"],"bracket");}
    586                                         if(/[\^'"!~\/]/.test(c)){
    587                                                 eatSuffix(stream, 1);
    588                                                 return tokenChain(stream,state,[stream.eat(c)],"bracket");}}
    589                                 else if(c=="r"){
    590                                         c=look(stream, 1);
    591                                         if(c=="("){
    592                                                 eatSuffix(stream, 2);
    593                                                 return tokenChain(stream,state,[")"],RXstyle,RXmodifiers);}
    594                                         if(c=="["){
    595                                                 eatSuffix(stream, 2);
    596                                                 return tokenChain(stream,state,["]"],RXstyle,RXmodifiers);}
    597                                         if(c=="{"){
    598                                                 eatSuffix(stream, 2);
    599                                                 return tokenChain(stream,state,["}"],RXstyle,RXmodifiers);}
    600                                         if(c=="<"){
    601                                                 eatSuffix(stream, 2);
    602                                                 return tokenChain(stream,state,[">"],RXstyle,RXmodifiers);}
    603                                         if(/[\^'"!~\/]/.test(c)){
    604                                                 eatSuffix(stream, 1);
    605                                                 return tokenChain(stream,state,[stream.eat(c)],RXstyle,RXmodifiers);}}
    606                                 else if(/[\^'"!~\/(\[{<]/.test(c)){
    607                                         if(c=="("){
    608                                                 eatSuffix(stream, 1);
    609                                                 return tokenChain(stream,state,[")"],"string");}
    610                                         if(c=="["){
    611                                                 eatSuffix(stream, 1);
    612                                                 return tokenChain(stream,state,["]"],"string");}
    613                                         if(c=="{"){
    614                                                 eatSuffix(stream, 1);
    615                                                 return tokenChain(stream,state,["}"],"string");}
    616                                         if(c=="<"){
    617                                                 eatSuffix(stream, 1);
    618                                                 return tokenChain(stream,state,[">"],"string");}
    619                                         if(/[\^'"!~\/]/.test(c)){
    620                                                 return tokenChain(stream,state,[stream.eat(c)],"string");}}}}
    621                 if(ch=="m"){
    622                         var c=look(stream, -2);
    623                         if(!(c&&/\w/.test(c))){
    624                                 c=stream.eat(/[(\[{<\^'"!~\/]/);
    625                                 if(c){
    626                                         if(/[\^'"!~\/]/.test(c)){
    627                                                 return tokenChain(stream,state,[c],RXstyle,RXmodifiers);}
    628                                         if(c=="("){
    629                                                 return tokenChain(stream,state,[")"],RXstyle,RXmodifiers);}
    630                                         if(c=="["){
    631                                                 return tokenChain(stream,state,["]"],RXstyle,RXmodifiers);}
    632                                         if(c=="{"){
    633                                                 return tokenChain(stream,state,["}"],RXstyle,RXmodifiers);}
    634                                         if(c=="<"){
    635                                                 return tokenChain(stream,state,[">"],RXstyle,RXmodifiers);}}}}
    636                 if(ch=="s"){
    637                         var c=/[\/>\]})\w]/.test(look(stream, -2));
    638                         if(!c){
    639                                 c=stream.eat(/[(\[{<\^'"!~\/]/);
    640                                 if(c){
    641                                         if(c=="[")
    642                                                 return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
    643                                         if(c=="{")
    644                                                 return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
    645                                         if(c=="<")
    646                                                 return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
    647                                         if(c=="(")
    648                                                 return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
    649                                         return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers);}}}
    650                 if(ch=="y"){
    651                         var c=/[\/>\]})\w]/.test(look(stream, -2));
    652                         if(!c){
    653                                 c=stream.eat(/[(\[{<\^'"!~\/]/);
    654                                 if(c){
    655                                         if(c=="[")
    656                                                 return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
    657                                         if(c=="{")
    658                                                 return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
    659                                         if(c=="<")
    660                                                 return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
    661                                         if(c=="(")
    662                                                 return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
    663                                         return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers);}}}
    664                 if(ch=="t"){
    665                         var c=/[\/>\]})\w]/.test(look(stream, -2));
    666                         if(!c){
    667                                 c=stream.eat("r");if(c){
    668                                 c=stream.eat(/[(\[{<\^'"!~\/]/);
    669                                 if(c){
    670                                         if(c=="[")
    671                                                 return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
    672                                         if(c=="{")
    673                                                 return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
    674                                         if(c=="<")
    675                                                 return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
    676                                         if(c=="(")
    677                                                 return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
    678                                         return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers);}}}}
    679                 if(ch=="`"){
    680                         return tokenChain(stream,state,[ch],"variable-2");}
    681                 if(ch=="/"){
    682                         if(!/~\s*$/.test(prefix(stream)))
    683                                 return "operator";
    684                         else
    685                                 return tokenChain(stream,state,[ch],RXstyle,RXmodifiers);}
    686                 if(ch=="$"){
    687                         var p=stream.pos;
    688                         if(stream.eatWhile(/\d/)||stream.eat("{")&&stream.eatWhile(/\d/)&&stream.eat("}"))
    689                                 return "variable-2";
    690                         else
    691                                 stream.pos=p;}
    692                 if(/[$@%]/.test(ch)){
    693                         var p=stream.pos;
    694                         if(stream.eat("^")&&stream.eat(/[A-Z]/)||!/[@$%&]/.test(look(stream, -2))&&stream.eat(/[=|\\\-#?@;:&`~\^!\[\]*'"$+.,\/<>()]/)){
    695                                 var c=stream.current();
    696                                 if(PERL[c])
    697                                         return "variable-2";}
    698                         stream.pos=p;}
    699                 if(/[$@%&]/.test(ch)){
    700                         if(stream.eatWhile(/[\w$\[\]]/)||stream.eat("{")&&stream.eatWhile(/[\w$\[\]]/)&&stream.eat("}")){
    701                                 var c=stream.current();
    702                                 if(PERL[c])
    703                                         return "variable-2";
    704                                 else
    705                                         return "variable";}}
    706                 if(ch=="#"){
    707                         if(look(stream, -2)!="$"){
    708                                 stream.skipToEnd();
    709                                 return "comment";}}
    710                 if(/[:+\-\^*$&%@=<>!?|\/~\.]/.test(ch)){
    711                         var p=stream.pos;
    712                         stream.eatWhile(/[:+\-\^*$&%@=<>!?|\/~\.]/);
    713                         if(PERL[stream.current()])
    714                                 return "operator";
    715                         else
    716                                 stream.pos=p;}
    717                 if(ch=="_"){
    718                         if(stream.pos==1){
    719                                 if(suffix(stream, 6)=="_END__"){
    720                                         return tokenChain(stream,state,['\0'],"comment");}
    721                                 else if(suffix(stream, 7)=="_DATA__"){
    722                                         return tokenChain(stream,state,['\0'],"variable-2");}
    723                                 else if(suffix(stream, 7)=="_C__"){
    724                                         return tokenChain(stream,state,['\0'],"string");}}}
    725                 if(/\w/.test(ch)){
    726                         var p=stream.pos;
    727                         if(look(stream, -2)=="{"&&(look(stream, 0)=="}"||stream.eatWhile(/\w/)&&look(stream, 0)=="}"))
    728                                 return "string";
    729                         else
    730                                 stream.pos=p;}
    731                 if(/[A-Z]/.test(ch)){
    732                         var l=look(stream, -2);
    733                         var p=stream.pos;
    734                         stream.eatWhile(/[A-Z_]/);
    735                         if(/[\da-z]/.test(look(stream, 0))){
    736                                 stream.pos=p;}
    737                         else{
    738                                 var c=PERL[stream.current()];
    739                                 if(!c)
    740                                         return "meta";
    741                                 if(c[1])
    742                                         c=c[0];
    743                                 if(l!=":"){
    744                                         if(c==1)
    745                                                 return "keyword";
    746                                         else if(c==2)
    747                                                 return "def";
    748                                         else if(c==3)
    749                                                 return "atom";
    750                                         else if(c==4)
    751                                                 return "operator";
    752                                         else if(c==5)
    753                                                 return "variable-2";
    754                                         else
    755                                                 return "meta";}
    756                                 else
    757                                         return "meta";}}
    758                 if(/[a-zA-Z_]/.test(ch)){
    759                         var l=look(stream, -2);
    760                         stream.eatWhile(/\w/);
    761                         var c=PERL[stream.current()];
    762                         if(!c)
    763                                 return "meta";
    764                         if(c[1])
    765                                 c=c[0];
    766                         if(l!=":"){
    767                                 if(c==1)
    768                                         return "keyword";
    769                                 else if(c==2)
    770                                         return "def";
    771                                 else if(c==3)
    772                                         return "atom";
    773                                 else if(c==4)
    774                                         return "operator";
    775                                 else if(c==5)
    776                                         return "variable-2";
    777                                 else
    778                                         return "meta";}
    779                         else
    780                                 return "meta";}
    781                 return null;}
    782 
    783         return {
    784             startState: function() {
    785                 return {
    786                     tokenize: tokenPerl,
    787                     chain: null,
    788                     style: null,
    789                     tail: null
    790                 };
    791             },
    792             token: function(stream, state) {
    793                 return (state.tokenize || tokenPerl)(stream, state);
    794             },
    795             lineComment: '#'
    796         };
    797 });
    798 
    799 CodeMirror.registerHelper("wordChars", "perl", /[\w$]/);
    800 
    801 CodeMirror.defineMIME("text/x-perl", "perl");
    802 
    803 // it's like "peek", but need for look-ahead or look-behind if index < 0
    804 function look(stream, c){
    805   return stream.string.charAt(stream.pos+(c||0));
    806 }
    807 
    808 // return a part of prefix of current stream from current position
    809 function prefix(stream, c){
    810   if(c){
    811     var x=stream.pos-c;
    812     return stream.string.substr((x>=0?x:0),c);}
    813   else{
    814     return stream.string.substr(0,stream.pos-1);
    815   }
    816 }
    817 
    818 // return a part of suffix of current stream from current position
    819 function suffix(stream, c){
    820   var y=stream.string.length;
    821   var x=y-stream.pos+1;
    822   return stream.string.substr(stream.pos,(c&&c<y?c:x));
    823 }
    824 
    825 // eating and vomiting a part of stream from current position
    826 function eatSuffix(stream, c){
    827   var x=stream.pos+c;
    828   var y;
    829   if(x<=0)
    830     stream.pos=0;
    831   else if(x>=(y=stream.string.length-1))
    832     stream.pos=y;
    833   else
    834     stream.pos=x;
    835 }
    836 
    837 });