?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge "Make line breaks in <blockquote> behave like <div> (bug 6200)."
[mediawiki.git] / includes / libs / JavaScriptMinifier.php
blob998805ae9c77010816908f4a16011c4aca6442ca
1 <?php
2 /**
3 * JavaScript Minifier
4 *
5 * @file
6 * @author Paul Copperman <paul.copperman@gmail.com>
7 * @license Choose any of Apache, MIT, GPL, LGPL
8 */
9
10 /**
11 * This class is meant to safely minify javascript code, while leaving syntactically correct
12 * programs intact. Other libraries, such as JSMin require a certain coding style to work
13 * correctly. OTOH, libraries like jsminplus, that do parse the code correctly are rather
14 * slow, because they construct a complete parse tree before outputting the code minified.
15 * So this class is meant to allow arbitrary (but syntactically correct) input, while being
16 * fast enough to be used for on-the-fly minifying.
17 */
18 class JavaScriptMinifier {
19
20 /* Class constants */
21 /* Parsing states.
22 * The state machine is only necessary to decide whether to parse a slash as division
23 * operator or as regexp literal.
24 * States are named after the next expected item. We only distinguish states when the
25 * distinction is relevant for our purpose.
26 */
27 const STATEMENT = 0;
28 const CONDITION = 1;
29 const PROPERTY_ASSIGNMENT = 2;
30 const EXPRESSION = 3;
31 const EXPRESSION_NO_NL = 4; // only relevant for semicolon insertion
32 const EXPRESSION_OP = 5;
33 const EXPRESSION_FUNC = 6;
34 const EXPRESSION_TERNARY = 7; // used to determine the role of a colon
35 const EXPRESSION_TERNARY_OP = 8;
36 const EXPRESSION_TERNARY_FUNC = 9;
37 const PAREN_EXPRESSION = 10; // expression which is not on the top level
38 const PAREN_EXPRESSION_OP = 11;
39 const PAREN_EXPRESSION_FUNC = 12;
40 const PROPERTY_EXPRESSION = 13; // expression which is within an object literal
41 const PROPERTY_EXPRESSION_OP = 14;
42 const PROPERTY_EXPRESSION_FUNC = 15;
43
44 /* Token types */
45 const TYPE_UN_OP = 1; // unary operators
46 const TYPE_INCR_OP = 2; // ++ and --
47 const TYPE_BIN_OP = 3; // binary operators
48 const TYPE_ADD_OP = 4; // + and - which can be either unary or binary ops
49 const TYPE_HOOK = 5; // ?
50 const TYPE_COLON = 6; // :
51 const TYPE_COMMA = 7; // ,
52 const TYPE_SEMICOLON = 8; // ;
53 const TYPE_BRACE_OPEN = 9; // {
54 const TYPE_BRACE_CLOSE = 10; // }
55 const TYPE_PAREN_OPEN = 11; // ( and [
56 const TYPE_PAREN_CLOSE = 12; // ) and ]
57 const TYPE_RETURN = 13; // keywords: break, continue, return, throw
58 const TYPE_IF = 14; // keywords: catch, for, with, switch, while, if
59 const TYPE_DO = 15; // keywords: case, var, finally, else, do, try
60 const TYPE_FUNC = 16; // keywords: function
61 const TYPE_LITERAL = 17; // all literals, identifiers and unrecognised tokens
62
63 // Sanity limit to avoid excessive memory usage
64 const STACK_LIMIT = 1000;
65
66 /* Static functions */
67
68 /**
69 * Returns minified JavaScript code.
70 *
71 * NOTE: $maxLineLength isn't a strict maximum. Longer lines will be produced when
72 * literals (e.g. quoted strings) longer than $maxLineLength are encountered
73 * or when required to guard against semicolon insertion.
74 *
75 * @param string $s JavaScript code to minify
76 * @param bool $statementsOnOwnLine Whether to put each statement on its own line
77 * @param int $maxLineLength Maximum length of a single line, or -1 for no maximum.
78 * @return String Minified code
79 */
80 public static function minify( $s, $statementsOnOwnLine = false, $maxLineLength = 1000 ) {
81 // First we declare a few tables that contain our parsing rules
82
83 // $opChars : characters, which can be combined without whitespace in between them
84 $opChars = array(
85 '!' => true,
86 '"' => true,
87 '%' => true,
88 '&' => true,
89 "'" => true,
90 '(' => true,
91 ')' => true,
92 '*' => true,
93 '+' => true,
94 ',' => true,
95 '-' => true,
96 '.' => true,
97 '/' => true,
98 ':' => true,
99 ';' => true,
100 '<' => true,
101 '=' => true,
102 '>' => true,
103 '?' => true,
104 '[' => true,
105 ']' => true,
106 '^' => true,
107 '{' => true,
108 '|' => true,
109 '}' => true,
110 '~' => true
111 );
112
113 // $tokenTypes : maps keywords and operators to their corresponding token type
114 $tokenTypes = array(
115 '!' => self::TYPE_UN_OP,
116 '~' => self::TYPE_UN_OP,
117 'delete' => self::TYPE_UN_OP,
118 'new' => self::TYPE_UN_OP,
119 'typeof' => self::TYPE_UN_OP,
120 'void' => self::TYPE_UN_OP,
121 '++' => self::TYPE_INCR_OP,
122 '--' => self::TYPE_INCR_OP,
123 '!=' => self::TYPE_BIN_OP,
124 '!==' => self::TYPE_BIN_OP,
125 '%' => self::TYPE_BIN_OP,
126 '%=' => self::TYPE_BIN_OP,
127 '&' => self::TYPE_BIN_OP,
128 '&&' => self::TYPE_BIN_OP,
129 '&=' => self::TYPE_BIN_OP,
130 '*' => self::TYPE_BIN_OP,
131 '*=' => self::TYPE_BIN_OP,
132 '+=' => self::TYPE_BIN_OP,
133 '-=' => self::TYPE_BIN_OP,
134 '.' => self::TYPE_BIN_OP,
135 '/' => self::TYPE_BIN_OP,
136 '/=' => self::TYPE_BIN_OP,
137 '<' => self::TYPE_BIN_OP,
138 '<<' => self::TYPE_BIN_OP,
139 '<<=' => self::TYPE_BIN_OP,
140 '<=' => self::TYPE_BIN_OP,
141 '=' => self::TYPE_BIN_OP,
142 '==' => self::TYPE_BIN_OP,
143 '===' => self::TYPE_BIN_OP,
144 '>' => self::TYPE_BIN_OP,
145 '>=' => self::TYPE_BIN_OP,
146 '>>' => self::TYPE_BIN_OP,
147 '>>=' => self::TYPE_BIN_OP,
148 '>>>' => self::TYPE_BIN_OP,
149 '>>>=' => self::TYPE_BIN_OP,
150 '^' => self::TYPE_BIN_OP,
151 '^=' => self::TYPE_BIN_OP,
152 '|' => self::TYPE_BIN_OP,
153 '|=' => self::TYPE_BIN_OP,
154 '||' => self::TYPE_BIN_OP,
155 'in' => self::TYPE_BIN_OP,
156 'instanceof' => self::TYPE_BIN_OP,
157 '+' => self::TYPE_ADD_OP,
158 '-' => self::TYPE_ADD_OP,
159 '?' => self::TYPE_HOOK,
160 ':' => self::TYPE_COLON,
161 ',' => self::TYPE_COMMA,
162 ';' => self::TYPE_SEMICOLON,
163 '{' => self::TYPE_BRACE_OPEN,
164 '}' => self::TYPE_BRACE_CLOSE,
165 '(' => self::TYPE_PAREN_OPEN,
166 '[' => self::TYPE_PAREN_OPEN,
167 ')' => self::TYPE_PAREN_CLOSE,
168 ']' => self::TYPE_PAREN_CLOSE,
169 'break' => self::TYPE_RETURN,
170 'continue' => self::TYPE_RETURN,
171 'return' => self::TYPE_RETURN,
172 'throw' => self::TYPE_RETURN,
173 'catch' => self::TYPE_IF,
174 'for' => self::TYPE_IF,
175 'if' => self::TYPE_IF,
176 'switch' => self::TYPE_IF,
177 'while' => self::TYPE_IF,
178 'with' => self::TYPE_IF,
179 'case' => self::TYPE_DO,
180 'do' => self::TYPE_DO,
181 'else' => self::TYPE_DO,
182 'finally' => self::TYPE_DO,
183 'try' => self::TYPE_DO,
184 'var' => self::TYPE_DO,
185 'function' => self::TYPE_FUNC
186 );
187
188 // $goto : This is the main table for our state machine. For every state/token pair
189 // the following state is defined. When no rule exists for a given pair,
190 // the state is left unchanged.
191 $goto = array(
192 self::STATEMENT => array(
193 self::TYPE_UN_OP => self::EXPRESSION,
194 self::TYPE_INCR_OP => self::EXPRESSION,
195 self::TYPE_ADD_OP => self::EXPRESSION,
196 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION,
197 self::TYPE_RETURN => self::EXPRESSION_NO_NL,
198 self::TYPE_IF => self::CONDITION,
199 self::TYPE_FUNC => self::CONDITION,
200 self::TYPE_LITERAL => self::EXPRESSION_OP
201 ),
202 self::CONDITION => array(
203 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION
204 ),
205 self::PROPERTY_ASSIGNMENT => array(
206 self::TYPE_COLON => self::PROPERTY_EXPRESSION,
207 self::TYPE_BRACE_OPEN => self::STATEMENT
208 ),
209 self::EXPRESSION => array(
210 self::TYPE_SEMICOLON => self::STATEMENT,
211 self::TYPE_BRACE_OPEN => self::PROPERTY_ASSIGNMENT,
212 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION,
213 self::TYPE_FUNC => self::EXPRESSION_FUNC,
214 self::TYPE_LITERAL => self::EXPRESSION_OP
215 ),
216 self::EXPRESSION_NO_NL => array(
217 self::TYPE_SEMICOLON => self::STATEMENT,
218 self::TYPE_BRACE_OPEN => self::PROPERTY_ASSIGNMENT,
219 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION,
220 self::TYPE_FUNC => self::EXPRESSION_FUNC,
221 self::TYPE_LITERAL => self::EXPRESSION_OP
222 ),
223 self::EXPRESSION_OP => array(
224 self::TYPE_BIN_OP => self::EXPRESSION,
225 self::TYPE_ADD_OP => self::EXPRESSION,
226 self::TYPE_HOOK => self::EXPRESSION_TERNARY,
227 self::TYPE_COLON => self::STATEMENT,
228 self::TYPE_COMMA => self::EXPRESSION,
229 self::TYPE_SEMICOLON => self::STATEMENT,
230 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION
231 ),
232 self::EXPRESSION_FUNC => array(
233 self::TYPE_BRACE_OPEN => self::STATEMENT
234 ),
235 self::EXPRESSION_TERNARY => array(
236 self::TYPE_BRACE_OPEN => self::PROPERTY_ASSIGNMENT,
237 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION,
238 self::TYPE_FUNC => self::EXPRESSION_TERNARY_FUNC,
239 self::TYPE_LITERAL => self::EXPRESSION_TERNARY_OP
240 ),
241 self::EXPRESSION_TERNARY_OP => array(
242 self::TYPE_BIN_OP => self::EXPRESSION_TERNARY,
243 self::TYPE_ADD_OP => self::EXPRESSION_TERNARY,
244 self::TYPE_HOOK => self::EXPRESSION_TERNARY,
245 self::TYPE_COMMA => self::EXPRESSION_TERNARY,
246 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION
247 ),
248 self::EXPRESSION_TERNARY_FUNC => array(
249 self::TYPE_BRACE_OPEN => self::STATEMENT
250 ),
251 self::PAREN_EXPRESSION => array(
252 self::TYPE_BRACE_OPEN => self::PROPERTY_ASSIGNMENT,
253 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION,
254 self::TYPE_FUNC => self::PAREN_EXPRESSION_FUNC,
255 self::TYPE_LITERAL => self::PAREN_EXPRESSION_OP
256 ),
257 self::PAREN_EXPRESSION_OP => array(
258 self::TYPE_BIN_OP => self::PAREN_EXPRESSION,
259 self::TYPE_ADD_OP => self::PAREN_EXPRESSION,
260 self::TYPE_HOOK => self::PAREN_EXPRESSION,
261 self::TYPE_COLON => self::PAREN_EXPRESSION,
262 self::TYPE_COMMA => self::PAREN_EXPRESSION,
263 self::TYPE_SEMICOLON => self::PAREN_EXPRESSION,
264 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION
265 ),
266 self::PAREN_EXPRESSION_FUNC => array(
267 self::TYPE_BRACE_OPEN => self::STATEMENT
268 ),
269 self::PROPERTY_EXPRESSION => array(
270 self::TYPE_BRACE_OPEN => self::PROPERTY_ASSIGNMENT,
271 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION,
272 self::TYPE_FUNC => self::PROPERTY_EXPRESSION_FUNC,
273 self::TYPE_LITERAL => self::PROPERTY_EXPRESSION_OP
274 ),
275 self::PROPERTY_EXPRESSION_OP => array(
276 self::TYPE_BIN_OP => self::PROPERTY_EXPRESSION,
277 self::TYPE_ADD_OP => self::PROPERTY_EXPRESSION,
278 self::TYPE_HOOK => self::PROPERTY_EXPRESSION,
279 self::TYPE_COMMA => self::PROPERTY_ASSIGNMENT,
280 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION
281 ),
282 self::PROPERTY_EXPRESSION_FUNC => array(
283 self::TYPE_BRACE_OPEN => self::STATEMENT
284 )
285 );
286
287 // $push : This table contains the rules for when to push a state onto the stack.
288 // The pushed state is the state to return to when the corresponding
289 // closing token is found
290 $push = array(
291 self::STATEMENT => array(
292 self::TYPE_BRACE_OPEN => self::STATEMENT,
293 self::TYPE_PAREN_OPEN => self::EXPRESSION_OP
294 ),
295 self::CONDITION => array(
296 self::TYPE_PAREN_OPEN => self::STATEMENT
297 ),
298 self::PROPERTY_ASSIGNMENT => array(
299 self::TYPE_BRACE_OPEN => self::PROPERTY_ASSIGNMENT
300 ),
301 self::EXPRESSION => array(
302 self::TYPE_BRACE_OPEN => self::EXPRESSION_OP,
303 self::TYPE_PAREN_OPEN => self::EXPRESSION_OP
304 ),
305 self::EXPRESSION_NO_NL => array(
306 self::TYPE_BRACE_OPEN => self::EXPRESSION_OP,
307 self::TYPE_PAREN_OPEN => self::EXPRESSION_OP
308 ),
309 self::EXPRESSION_OP => array(
310 self::TYPE_HOOK => self::EXPRESSION,
311 self::TYPE_PAREN_OPEN => self::EXPRESSION_OP
312 ),
313 self::EXPRESSION_FUNC => array(
314 self::TYPE_BRACE_OPEN => self::EXPRESSION_OP
315 ),
316 self::EXPRESSION_TERNARY => array(
317 self::TYPE_BRACE_OPEN => self::EXPRESSION_TERNARY_OP,
318 self::TYPE_PAREN_OPEN => self::EXPRESSION_TERNARY_OP
319 ),
320 self::EXPRESSION_TERNARY_OP => array(
321 self::TYPE_HOOK => self::EXPRESSION_TERNARY,
322 self::TYPE_PAREN_OPEN => self::EXPRESSION_TERNARY_OP
323 ),
324 self::EXPRESSION_TERNARY_FUNC => array(
325 self::TYPE_BRACE_OPEN => self::EXPRESSION_TERNARY_OP
326 ),
327 self::PAREN_EXPRESSION => array(
328 self::TYPE_BRACE_OPEN => self::PAREN_EXPRESSION_OP,
329 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION_OP
330 ),
331 self::PAREN_EXPRESSION_OP => array(
332 self::TYPE_PAREN_OPEN => self::PAREN_EXPRESSION_OP
333 ),
334 self::PAREN_EXPRESSION_FUNC => array(
335 self::TYPE_BRACE_OPEN => self::PAREN_EXPRESSION_OP
336 ),
337 self::PROPERTY_EXPRESSION => array(
338 self::TYPE_BRACE_OPEN => self::PROPERTY_EXPRESSION_OP,
339 self::TYPE_PAREN_OPEN => self::PROPERTY_EXPRESSION_OP
340 ),
341 self::PROPERTY_EXPRESSION_OP => array(
342 self::TYPE_PAREN_OPEN => self::PROPERTY_EXPRESSION_OP
343 ),
344 self::PROPERTY_EXPRESSION_FUNC => array(
345 self::TYPE_BRACE_OPEN => self::PROPERTY_EXPRESSION_OP
346 )
347 );
348
349 // $pop : Rules for when to pop a state from the stack
350 $pop = array(
351 self::STATEMENT => array( self::TYPE_BRACE_CLOSE => true ),
352 self::PROPERTY_ASSIGNMENT => array( self::TYPE_BRACE_CLOSE => true ),
353 self::EXPRESSION => array( self::TYPE_BRACE_CLOSE => true ),
354 self::EXPRESSION_NO_NL => array( self::TYPE_BRACE_CLOSE => true ),
355 self::EXPRESSION_OP => array( self::TYPE_BRACE_CLOSE => true ),
356 self::EXPRESSION_TERNARY_OP => array( self::TYPE_COLON => true ),
357 self::PAREN_EXPRESSION => array( self::TYPE_PAREN_CLOSE => true ),
358 self::PAREN_EXPRESSION_OP => array( self::TYPE_PAREN_CLOSE => true ),
359 self::PROPERTY_EXPRESSION => array( self::TYPE_BRACE_CLOSE => true ),
360 self::PROPERTY_EXPRESSION_OP => array( self::TYPE_BRACE_CLOSE => true )
361 );
362
363 // $semicolon : Rules for when a semicolon insertion is appropriate
364 $semicolon = array(
365 self::EXPRESSION_NO_NL => array(
366 self::TYPE_UN_OP => true,
367 self::TYPE_INCR_OP => true,
368 self::TYPE_ADD_OP => true,
369 self::TYPE_BRACE_OPEN => true,
370 self::TYPE_PAREN_OPEN => true,
371 self::TYPE_RETURN => true,
372 self::TYPE_IF => true,
373 self::TYPE_DO => true,
374 self::TYPE_FUNC => true,
375 self::TYPE_LITERAL => true
376 ),
377 self::EXPRESSION_OP => array(
378 self::TYPE_UN_OP => true,
379 self::TYPE_INCR_OP => true,
380 self::TYPE_BRACE_OPEN => true,
381 self::TYPE_RETURN => true,
382 self::TYPE_IF => true,
383 self::TYPE_DO => true,
384 self::TYPE_FUNC => true,
385 self::TYPE_LITERAL => true
386 )
387 );
388
389 // Rules for when newlines should be inserted if
390 // $statementsOnOwnLine is enabled.
391 // $newlineBefore is checked before switching state,
392 // $newlineAfter is checked after
393 $newlineBefore = array(
394 self::STATEMENT => array(
395 self::TYPE_BRACE_CLOSE => true,
396 ),
397 );
398 $newlineAfter = array(
399 self::STATEMENT => array(
400 self::TYPE_BRACE_OPEN => true,
401 self::TYPE_PAREN_CLOSE => true,
402 self::TYPE_SEMICOLON => true,
403 ),
404 );
405
406 // $divStates : Contains all states that can be followed by a division operator
407 $divStates = array(
408 self::EXPRESSION_OP => true,
409 self::EXPRESSION_TERNARY_OP => true,
410 self::PAREN_EXPRESSION_OP => true,
411 self::PROPERTY_EXPRESSION_OP => true
412 );
413
414 // Here's where the minifying takes place: Loop through the input, looking for tokens
415 // and output them to $out, taking actions to the above defined rules when appropriate.
416 $out = '';
417 $pos = 0;
418 $length = strlen( $s );
419 $lineLength = 0;
420 $newlineFound = true;
421 $state = self::STATEMENT;
422 $stack = array();
423 $last = ';'; // Pretend that we have seen a semicolon yet
424 while( $pos < $length ) {
425 // First, skip over any whitespace and multiline comments, recording whether we
426 // found any newline character
427 $skip = strspn( $s, " \t\n\r\xb\xc", $pos );
428 if( !$skip ) {
429 $ch = $s[$pos];
430 if( $ch === '/' && substr( $s, $pos, 2 ) === '/*' ) {
431 // Multiline comment. Search for the end token or EOT.
432 $end = strpos( $s, '*/', $pos + 2 );
433 $skip = $end === false ? $length - $pos : $end - $pos + 2;
434 }
435 }
436 if( $skip ) {
437 // The semicolon insertion mechanism needs to know whether there was a newline
438 // between two tokens, so record it now.
439 if( !$newlineFound && strcspn( $s, "\r\n", $pos, $skip ) !== $skip ) {
440 $newlineFound = true;
441 }
442 $pos += $skip;
443 continue;
444 }
445 // Handle C++-style comments and html comments, which are treated as single line
446 // comments by the browser, regardless of whether the end tag is on the same line.
447 // Handle --> the same way, but only if it's at the beginning of the line
448 if( ( $ch === '/' && substr( $s, $pos, 2 ) === '//' )
449 || ( $ch === '<' && substr( $s, $pos, 4 ) === '<!--' )
450 || ( $ch === '-' && $newlineFound && substr( $s, $pos, 3 ) === '-->' )
451 ) {
452 $pos += strcspn( $s, "\r\n", $pos );
453 continue;
454 }
455
456 // Find out which kind of token we're handling. $end will point past the end of it.
457 $end = $pos + 1;
458 // Handle string literals
459 if( $ch === "'" || $ch === '"' ) {
460 // Search to the end of the string literal, skipping over backslash escapes
461 $search = $ch . '\\';
462 do{
463 $end += strcspn( $s, $search, $end ) + 2;
464 } while( $end - 2 < $length && $s[$end - 2] === '\\' );
465 $end--;
466 // We have to distinguish between regexp literals and division operators
467 // A division operator is only possible in certain states
468 } elseif( $ch === '/' && !isset( $divStates[$state] ) ) {
469 // Regexp literal, search to the end, skipping over backslash escapes and
470 // character classes
471 for( ; ; ) {
472 do{
473 $end += strcspn( $s, '/[\\', $end ) + 2;
474 } while( $end - 2 < $length && $s[$end - 2] === '\\' );
475 $end--;
476 if( $end - 1 >= $length || $s[$end - 1] === '/' ) {
477 break;
478 }
479 do{
480 $end += strcspn( $s, ']\\', $end ) + 2;
481 } while( $end - 2 < $length && $s[$end - 2] === '\\' );
482 $end--;
483 };
484 // Search past the regexp modifiers (gi)
485 while( $end < $length && ctype_alpha( $s[$end] ) ) {
486 $end++;
487 }
488 } elseif(
489 $ch === '0'
490 && ($pos + 1 < $length) && ($s[$pos + 1] === 'x' || $s[$pos + 1] === 'X' )
491 ) {
492 // Hex numeric literal
493 $end++; // x or X
494 $len = strspn( $s, '0123456789ABCDEFabcdef', $end );
495 if ( !$len ) {
496 return self::parseError($s, $pos, 'Expected a hexadecimal number but found ' . substr( $s, $pos, 5 ) . '...' );
497 }
498 $end += $len;
499 } elseif(
500 ctype_digit( $ch )
501 || ( $ch === '.' && $pos + 1 < $length && ctype_digit( $s[$pos + 1] ) )
502 ) {
503 $end += strspn( $s, '0123456789', $end );
504 $decimal = strspn( $s, '.', $end );
505 if ($decimal) {
506 if ( $decimal > 2 ) {
507 return self::parseError($s, $end, 'The number has too many decimal points' );
508 }
509 $end += strspn( $s, '0123456789', $end + 1 ) + $decimal;
510 }
511 $exponent = strspn( $s, 'eE', $end );
512 if( $exponent ) {
513 if ( $exponent > 1 ) {
514 return self::parseError($s, $end, 'Number with several E' );
515 }
516 $end++;
517
518 // + sign is optional; - sign is required.
519 $end += strspn( $s, '-+', $end );
520 $len = strspn( $s, '0123456789', $end );
521 if ( !$len ) {
522 return self::parseError($s, $pos, 'No decimal digits after e, how many zeroes should be added?' );
523 }
524 $end += $len;
525 }
526 } elseif( isset( $opChars[$ch] ) ) {
527 // Punctuation character. Search for the longest matching operator.
528 while(
529 $end < $length
530 && isset( $tokenTypes[substr( $s, $pos, $end - $pos + 1 )] )
531 ) {
532 $end++;
533 }
534 } else {
535 // Identifier or reserved word. Search for the end by excluding whitespace and
536 // punctuation.
537 $end += strcspn( $s, " \t\n.;,=<>+-{}()[]?:*/%'\"!&|^~\xb\xc\r", $end );
538 }
539
540 // Now get the token type from our type array
541 $token = substr( $s, $pos, $end - $pos ); // so $end - $pos == strlen( $token )
542 $type = isset( $tokenTypes[$token] ) ? $tokenTypes[$token] : self::TYPE_LITERAL;
543
544 if( $newlineFound && isset( $semicolon[$state][$type] ) ) {
545 // This token triggers the semicolon insertion mechanism of javascript. While we
546 // could add the ; token here ourselves, keeping the newline has a few advantages.
547 $out .= "\n";
548 $state = self::STATEMENT;
549 $lineLength = 0;
550 } elseif( $maxLineLength > 0 && $lineLength + $end - $pos > $maxLineLength &&
551 !isset( $semicolon[$state][$type] ) && $type !== self::TYPE_INCR_OP )
552 {
553 // This line would get too long if we added $token, so add a newline first.
554 // Only do this if it won't trigger semicolon insertion and if it won't
555 // put a postfix increment operator on its own line, which is illegal in js.
556 $out .= "\n";
557 $lineLength = 0;
558 // Check, whether we have to separate the token from the last one with whitespace
559 } elseif( !isset( $opChars[$last] ) && !isset( $opChars[$ch] ) ) {
560 $out .= ' ';
561 $lineLength++;
562 // Don't accidentally create ++, -- or // tokens
563 } elseif( $last === $ch && ( $ch === '+' || $ch === '-' || $ch === '/' ) ) {
564 $out .= ' ';
565 $lineLength++;
566 }
567
568 $out .= $token;
569 $lineLength += $end - $pos; // += strlen( $token )
570 $last = $s[$end - 1];
571 $pos = $end;
572 $newlineFound = false;
573
574 // Output a newline after the token if required
575 // This is checked before AND after switching state
576 $newlineAdded = false;
577 if ( $statementsOnOwnLine && !$newlineAdded && isset( $newlineBefore[$state][$type] ) ) {
578 $out .= "\n";
579 $lineLength = 0;
580 $newlineAdded = true;
581 }
582
583 // Now that we have output our token, transition into the new state.
584 if( isset( $push[$state][$type] ) && count( $stack ) < self::STACK_LIMIT ) {
585 $stack[] = $push[$state][$type];
586 }
587 if( $stack && isset( $pop[$state][$type] ) ) {
588 $state = array_pop( $stack );
589 } elseif( isset( $goto[$state][$type] ) ) {
590 $state = $goto[$state][$type];
591 }
592
593 // Check for newline insertion again
594 if ( $statementsOnOwnLine && !$newlineAdded && isset( $newlineAfter[$state][$type] ) ) {
595 $out .= "\n";
596 $lineLength = 0;
597 }
598 }
599 return $out;
600 }
601
602 static function parseError($fullJavascript, $position, $errorMsg) {
603 // TODO: Handle the error: trigger_error, throw exception, return false...
604 return false;
605 }
606 }
MediaWiki Core