[ Index ]

PHP Cross Reference of Joomla 4.2.2 documentation

title

Body

[close]

/media/vendor/codemirror/mode/perl/ -> perl.js (source)

   1  // CodeMirror, copyright (c) by Marijn Haverbeke and others
   2  // Distributed under an MIT license: https://codemirror.net/5/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 ([email protected])
   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 filesystem
 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 string
 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[\d_]*)?\.\d+(e[+-]?\d+)?|\d+\.\d*)|0x[\da-fA-F_]+|0b[01_]+|\d[\d_]*(e[+-]?\d+)?)/))
 517                          return 'number';
 518                  if(stream.match(/^<<(?=[_a-zA-Z])/)){                  // NOTE: <<SOMETHING\n...\nSOMETHING\n
 519                          stream.eatWhile(/\w/);
 520                          return tokenSOMETHING(stream,state,stream.current().substr(2));}
 521                  if(stream.sol()&&stream.match(/^\=item(?!\w)/)){// NOTE: \n=item...\n=cut\n
 522                          return tokenSOMETHING(stream,state,'=cut');}
 523                  var ch=stream.next();
 524                  if(ch=='"'||ch=="'"){                           // NOTE: ' or " or <<'SOMETHING'\n...\nSOMETHING\n or <<"SOMETHING"\n...\nSOMETHING\n
 525                          if(prefix(stream, 3)=="<<"+ch){
 526                                  var p=stream.pos;
 527                                  stream.eatWhile(/\w/);
 528                                  var n=stream.current().substr(1);
 529                                  if(n&&stream.eat(ch))
 530                                          return tokenSOMETHING(stream,state,n);
 531                                  stream.pos=p;}
 532                          return tokenChain(stream,state,[ch],"string");}
 533                  if(ch=="q"){
 534                          var c=look(stream, -2);
 535                          if(!(c&&/\w/.test(c))){
 536                                  c=look(stream, 0);
 537                                  if(c=="x"){
 538                                          c=look(stream, 1);
 539                                          if(c=="("){
 540                                                  eatSuffix(stream, 2);
 541                                                  return tokenChain(stream,state,[")"],RXstyle,RXmodifiers);}
 542                                          if(c=="["){
 543                                                  eatSuffix(stream, 2);
 544                                                  return tokenChain(stream,state,["]"],RXstyle,RXmodifiers);}
 545                                          if(c=="{"){
 546                                                  eatSuffix(stream, 2);
 547                                                  return tokenChain(stream,state,["}"],RXstyle,RXmodifiers);}
 548                                          if(c=="<"){
 549                                                  eatSuffix(stream, 2);
 550                                                  return tokenChain(stream,state,[">"],RXstyle,RXmodifiers);}
 551                                          if(/[\^'"!~\/]/.test(c)){
 552                                                  eatSuffix(stream, 1);
 553                                                  return tokenChain(stream,state,[stream.eat(c)],RXstyle,RXmodifiers);}}
 554                                  else if(c=="q"){
 555                                          c=look(stream, 1);
 556                                          if(c=="("){
 557                                                  eatSuffix(stream, 2);
 558                                                  return tokenChain(stream,state,[")"],"string");}
 559                                          if(c=="["){
 560                                                  eatSuffix(stream, 2);
 561                                                  return tokenChain(stream,state,["]"],"string");}
 562                                          if(c=="{"){
 563                                                  eatSuffix(stream, 2);
 564                                                  return tokenChain(stream,state,["}"],"string");}
 565                                          if(c=="<"){
 566                                                  eatSuffix(stream, 2);
 567                                                  return tokenChain(stream,state,[">"],"string");}
 568                                          if(/[\^'"!~\/]/.test(c)){
 569                                                  eatSuffix(stream, 1);
 570                                                  return tokenChain(stream,state,[stream.eat(c)],"string");}}
 571                                  else if(c=="w"){
 572                                          c=look(stream, 1);
 573                                          if(c=="("){
 574                                                  eatSuffix(stream, 2);
 575                                                  return tokenChain(stream,state,[")"],"bracket");}
 576                                          if(c=="["){
 577                                                  eatSuffix(stream, 2);
 578                                                  return tokenChain(stream,state,["]"],"bracket");}
 579                                          if(c=="{"){
 580                                                  eatSuffix(stream, 2);
 581                                                  return tokenChain(stream,state,["}"],"bracket");}
 582                                          if(c=="<"){
 583                                                  eatSuffix(stream, 2);
 584                                                  return tokenChain(stream,state,[">"],"bracket");}
 585                                          if(/[\^'"!~\/]/.test(c)){
 586                                                  eatSuffix(stream, 1);
 587                                                  return tokenChain(stream,state,[stream.eat(c)],"bracket");}}
 588                                  else if(c=="r"){
 589                                          c=look(stream, 1);
 590                                          if(c=="("){
 591                                                  eatSuffix(stream, 2);
 592                                                  return tokenChain(stream,state,[")"],RXstyle,RXmodifiers);}
 593                                          if(c=="["){
 594                                                  eatSuffix(stream, 2);
 595                                                  return tokenChain(stream,state,["]"],RXstyle,RXmodifiers);}
 596                                          if(c=="{"){
 597                                                  eatSuffix(stream, 2);
 598                                                  return tokenChain(stream,state,["}"],RXstyle,RXmodifiers);}
 599                                          if(c=="<"){
 600                                                  eatSuffix(stream, 2);
 601                                                  return tokenChain(stream,state,[">"],RXstyle,RXmodifiers);}
 602                                          if(/[\^'"!~\/]/.test(c)){
 603                                                  eatSuffix(stream, 1);
 604                                                  return tokenChain(stream,state,[stream.eat(c)],RXstyle,RXmodifiers);}}
 605                                  else if(/[\^'"!~\/(\[{<]/.test(c)){
 606                                          if(c=="("){
 607                                                  eatSuffix(stream, 1);
 608                                                  return tokenChain(stream,state,[")"],"string");}
 609                                          if(c=="["){
 610                                                  eatSuffix(stream, 1);
 611                                                  return tokenChain(stream,state,["]"],"string");}
 612                                          if(c=="{"){
 613                                                  eatSuffix(stream, 1);
 614                                                  return tokenChain(stream,state,["}"],"string");}
 615                                          if(c=="<"){
 616                                                  eatSuffix(stream, 1);
 617                                                  return tokenChain(stream,state,[">"],"string");}
 618                                          if(/[\^'"!~\/]/.test(c)){
 619                                                  return tokenChain(stream,state,[stream.eat(c)],"string");}}}}
 620                  if(ch=="m"){
 621                          var c=look(stream, -2);
 622                          if(!(c&&/\w/.test(c))){
 623                                  c=stream.eat(/[(\[{<\^'"!~\/]/);
 624                                  if(c){
 625                                          if(/[\^'"!~\/]/.test(c)){
 626                                                  return tokenChain(stream,state,[c],RXstyle,RXmodifiers);}
 627                                          if(c=="("){
 628                                                  return tokenChain(stream,state,[")"],RXstyle,RXmodifiers);}
 629                                          if(c=="["){
 630                                                  return tokenChain(stream,state,["]"],RXstyle,RXmodifiers);}
 631                                          if(c=="{"){
 632                                                  return tokenChain(stream,state,["}"],RXstyle,RXmodifiers);}
 633                                          if(c=="<"){
 634                                                  return tokenChain(stream,state,[">"],RXstyle,RXmodifiers);}}}}
 635                  if(ch=="s"){
 636                          var c=/[\/>\]})\w]/.test(look(stream, -2));
 637                          if(!c){
 638                                  c=stream.eat(/[(\[{<\^'"!~\/]/);
 639                                  if(c){
 640                                          if(c=="[")
 641                                                  return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
 642                                          if(c=="{")
 643                                                  return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
 644                                          if(c=="<")
 645                                                  return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
 646                                          if(c=="(")
 647                                                  return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
 648                                          return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers);}}}
 649                  if(ch=="y"){
 650                          var c=/[\/>\]})\w]/.test(look(stream, -2));
 651                          if(!c){
 652                                  c=stream.eat(/[(\[{<\^'"!~\/]/);
 653                                  if(c){
 654                                          if(c=="[")
 655                                                  return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
 656                                          if(c=="{")
 657                                                  return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
 658                                          if(c=="<")
 659                                                  return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
 660                                          if(c=="(")
 661                                                  return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
 662                                          return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers);}}}
 663                  if(ch=="t"){
 664                          var c=/[\/>\]})\w]/.test(look(stream, -2));
 665                          if(!c){
 666                                  c=stream.eat("r");if(c){
 667                                  c=stream.eat(/[(\[{<\^'"!~\/]/);
 668                                  if(c){
 669                                          if(c=="[")
 670                                                  return tokenChain(stream,state,["]","]"],RXstyle,RXmodifiers);
 671                                          if(c=="{")
 672                                                  return tokenChain(stream,state,["}","}"],RXstyle,RXmodifiers);
 673                                          if(c=="<")
 674                                                  return tokenChain(stream,state,[">",">"],RXstyle,RXmodifiers);
 675                                          if(c=="(")
 676                                                  return tokenChain(stream,state,[")",")"],RXstyle,RXmodifiers);
 677                                          return tokenChain(stream,state,[c,c],RXstyle,RXmodifiers);}}}}
 678                  if(ch=="`"){
 679                          return tokenChain(stream,state,[ch],"variable-2");}
 680                  if(ch=="/"){
 681                          if(!/~\s*$/.test(prefix(stream)))
 682                                  return "operator";
 683                          else
 684                                  return tokenChain(stream,state,[ch],RXstyle,RXmodifiers);}
 685                  if(ch=="$"){
 686                          var p=stream.pos;
 687                          if(stream.eatWhile(/\d/)||stream.eat("{")&&stream.eatWhile(/\d/)&&stream.eat("}"))
 688                                  return "variable-2";
 689                          else
 690                                  stream.pos=p;}
 691                  if(/[$@%]/.test(ch)){
 692                          var p=stream.pos;
 693                          if(stream.eat("^")&&stream.eat(/[A-Z]/)||!/[@$%&]/.test(look(stream, -2))&&stream.eat(/[=|\\\-#?@;:&`~\^!\[\]*'"$+.,\/<>()]/)){
 694                                  var c=stream.current();
 695                                  if(PERL[c])
 696                                          return "variable-2";}
 697                          stream.pos=p;}
 698                  if(/[$@%&]/.test(ch)){
 699                          if(stream.eatWhile(/[\w$]/)||stream.eat("{")&&stream.eatWhile(/[\w$]/)&&stream.eat("}")){
 700                                  var c=stream.current();
 701                                  if(PERL[c])
 702                                          return "variable-2";
 703                                  else
 704                                          return "variable";}}
 705                  if(ch=="#"){
 706                          if(look(stream, -2)!="$"){
 707                                  stream.skipToEnd();
 708                                  return "comment";}}
 709                  if(/[:+\-\^*$&%@=<>!?|\/~\.]/.test(ch)){
 710                          var p=stream.pos;
 711                          stream.eatWhile(/[:+\-\^*$&%@=<>!?|\/~\.]/);
 712                          if(PERL[stream.current()])
 713                                  return "operator";
 714                          else
 715                                  stream.pos=p;}
 716                  if(ch=="_"){
 717                          if(stream.pos==1){
 718                                  if(suffix(stream, 6)=="_END__"){
 719                                          return tokenChain(stream,state,['\0'],"comment");}
 720                                  else if(suffix(stream, 7)=="_DATA__"){
 721                                          return tokenChain(stream,state,['\0'],"variable-2");}
 722                                  else if(suffix(stream, 7)=="_C__"){
 723                                          return tokenChain(stream,state,['\0'],"string");}}}
 724                  if(/\w/.test(ch)){
 725                          var p=stream.pos;
 726                          if(look(stream, -2)=="{"&&(look(stream, 0)=="}"||stream.eatWhile(/\w/)&&look(stream, 0)=="}"))
 727                                  return "string";
 728                          else
 729                                  stream.pos=p;}
 730                  if(/[A-Z]/.test(ch)){
 731                          var l=look(stream, -2);
 732                          var p=stream.pos;
 733                          stream.eatWhile(/[A-Z_]/);
 734                          if(/[\da-z]/.test(look(stream, 0))){
 735                                  stream.pos=p;}
 736                          else{
 737                                  var c=PERL[stream.current()];
 738                                  if(!c)
 739                                          return "meta";
 740                                  if(c[1])
 741                                          c=c[0];
 742                                  if(l!=":"){
 743                                          if(c==1)
 744                                                  return "keyword";
 745                                          else if(c==2)
 746                                                  return "def";
 747                                          else if(c==3)
 748                                                  return "atom";
 749                                          else if(c==4)
 750                                                  return "operator";
 751                                          else if(c==5)
 752                                                  return "variable-2";
 753                                          else
 754                                                  return "meta";}
 755                                  else
 756                                          return "meta";}}
 757                  if(/[a-zA-Z_]/.test(ch)){
 758                          var l=look(stream, -2);
 759                          stream.eatWhile(/\w/);
 760                          var c=PERL[stream.current()];
 761                          if(!c)
 762                                  return "meta";
 763                          if(c[1])
 764                                  c=c[0];
 765                          if(l!=":"){
 766                                  if(c==1)
 767                                          return "keyword";
 768                                  else if(c==2)
 769                                          return "def";
 770                                  else if(c==3)
 771                                          return "atom";
 772                                  else if(c==4)
 773                                          return "operator";
 774                                  else if(c==5)
 775                                          return "variable-2";
 776                                  else
 777                                          return "meta";}
 778                          else
 779                                  return "meta";}
 780                  return null;}
 781  
 782          return {
 783              startState: function() {
 784                  return {
 785                      tokenize: tokenPerl,
 786                      chain: null,
 787                      style: null,
 788                      tail: null
 789                  };
 790              },
 791              token: function(stream, state) {
 792                  return (state.tokenize || tokenPerl)(stream, state);
 793              },
 794              lineComment: '#'
 795          };
 796  });
 797  
 798  CodeMirror.registerHelper("wordChars", "perl", /[\w$]/);
 799  
 800  CodeMirror.defineMIME("text/x-perl", "perl");
 801  
 802  // it's like "peek", but need for look-ahead or look-behind if index < 0
 803  function look(stream, c){
 804    return stream.string.charAt(stream.pos+(c||0));
 805  }
 806  
 807  // return a part of prefix of current stream from current position
 808  function prefix(stream, c){
 809    if(c){
 810      var x=stream.pos-c;
 811      return stream.string.substr((x>=0?x:0),c);}
 812    else{
 813      return stream.string.substr(0,stream.pos-1);
 814    }
 815  }
 816  
 817  // return a part of suffix of current stream from current position
 818  function suffix(stream, c){
 819    var y=stream.string.length;
 820    var x=y-stream.pos+1;
 821    return stream.string.substr(stream.pos,(c&&c<y?c:x));
 822  }
 823  
 824  // eating and vomiting a part of stream from current position
 825  function eatSuffix(stream, c){
 826    var x=stream.pos+c;
 827    var y;
 828    if(x<=0)
 829      stream.pos=0;
 830    else if(x>=(y=stream.string.length-1))
 831      stream.pos=y;
 832    else
 833      stream.pos=x;
 834  }
 835  
 836  });


Generated: Wed Sep 7 05:41:13 2022 Chilli.vc Blog - For Webmaster,Blog-Writer,System Admin and Domainer