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