LaravelTest

1
// CodeMirror, copyright (c) by Marijn Haverbeke and others
2
// Distributed under an MIT license: https://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 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
});
837