MediaWiki  1.32.0
jsminplus.php
Go to the documentation of this file.
1 <?php
2 // phpcs:ignoreFile -- File external to MediaWiki. Ignore coding conventions checks.
31 /* ***** BEGIN LICENSE BLOCK *****
32  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
33  *
34  * The contents of this file are subject to the Mozilla Public License Version
35  * 1.1 (the "License"); you may not use this file except in compliance with
36  * the License. You may obtain a copy of the License at
37  * http://www.mozilla.org/MPL/
38  *
39  * Software distributed under the License is distributed on an "AS IS" basis,
40  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
41  * for the specific language governing rights and limitations under the
42  * License.
43  *
44  * The Original Code is the Narcissus JavaScript engine.
45  *
46  * The Initial Developer of the Original Code is
47  * Brendan Eich <brendan@mozilla.org>.
48  * Portions created by the Initial Developer are Copyright (C) 2004
49  * the Initial Developer. All Rights Reserved.
50  *
51  * Contributor(s): Tino Zijdel <crisp@tweakers.net>
52  * PHP port, modifications and minifier routine are (C) 2009-2011
53  *
54  * Alternatively, the contents of this file may be used under the terms of
55  * either the GNU General Public License Version 2 or later (the "GPL"), or
56  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
57  * in which case the provisions of the GPL or the LGPL are applicable instead
58  * of those above. If you wish to allow use of your version of this file only
59  * under the terms of either the GPL or the LGPL, and not to allow others to
60  * use your version of this file under the terms of the MPL, indicate your
61  * decision by deleting the provisions above and replace them with the notice
62  * and other provisions required by the GPL or the LGPL. If you do not delete
63  * the provisions above, a recipient may use your version of this file under
64  * the terms of any one of the MPL, the GPL or the LGPL.
65  *
66  * ***** END LICENSE BLOCK ***** */
67 
68 define('TOKEN_END', 1);
69 define('TOKEN_NUMBER', 2);
70 define('TOKEN_IDENTIFIER', 3);
71 define('TOKEN_STRING', 4);
72 define('TOKEN_REGEXP', 5);
73 define('TOKEN_NEWLINE', 6);
74 define('TOKEN_CONDCOMMENT_START', 7);
75 define('TOKEN_CONDCOMMENT_END', 8);
76 
77 define('JS_SCRIPT', 100);
78 define('JS_BLOCK', 101);
79 define('JS_LABEL', 102);
80 define('JS_FOR_IN', 103);
81 define('JS_CALL', 104);
82 define('JS_NEW_WITH_ARGS', 105);
83 define('JS_INDEX', 106);
84 define('JS_ARRAY_INIT', 107);
85 define('JS_OBJECT_INIT', 108);
86 define('JS_PROPERTY_INIT', 109);
87 define('JS_GETTER', 110);
88 define('JS_SETTER', 111);
89 define('JS_GROUP', 112);
90 define('JS_LIST', 113);
91 
92 define('JS_MINIFIED', 999);
93 
94 define('DECLARED_FORM', 0);
95 define('EXPRESSED_FORM', 1);
96 define('STATEMENT_FORM', 2);
97 
98 /* Operators */
99 define('OP_SEMICOLON', ';');
100 define('OP_COMMA', ',');
101 define('OP_HOOK', '?');
102 define('OP_COLON', ':');
103 define('OP_OR', '||');
104 define('OP_AND', '&&');
105 define('OP_BITWISE_OR', '|');
106 define('OP_BITWISE_XOR', '^');
107 define('OP_BITWISE_AND', '&');
108 define('OP_STRICT_EQ', '===');
109 define('OP_EQ', '==');
110 define('OP_ASSIGN', '=');
111 define('OP_STRICT_NE', '!==');
112 define('OP_NE', '!=');
113 define('OP_LSH', '<<');
114 define('OP_LE', '<=');
115 define('OP_LT', '<');
116 define('OP_URSH', '>>>');
117 define('OP_RSH', '>>');
118 define('OP_GE', '>=');
119 define('OP_GT', '>');
120 define('OP_INCREMENT', '++');
121 define('OP_DECREMENT', '--');
122 define('OP_PLUS', '+');
123 define('OP_MINUS', '-');
124 define('OP_MUL', '*');
125 define('OP_DIV', '/');
126 define('OP_MOD', '%');
127 define('OP_NOT', '!');
128 define('OP_BITWISE_NOT', '~');
129 define('OP_DOT', '.');
130 define('OP_LEFT_BRACKET', '[');
131 define('OP_RIGHT_BRACKET', ']');
132 define('OP_LEFT_CURLY', '{');
133 define('OP_RIGHT_CURLY', '}');
134 define('OP_LEFT_PAREN', '(');
135 define('OP_RIGHT_PAREN', ')');
136 define('OP_CONDCOMMENT_END', '@*/');
137 
138 define('OP_UNARY_PLUS', 'U+');
139 define('OP_UNARY_MINUS', 'U-');
140 
141 /* Keywords */
142 define('KEYWORD_BREAK', 'break');
143 define('KEYWORD_CASE', 'case');
144 define('KEYWORD_CATCH', 'catch');
145 define('KEYWORD_CONST', 'const');
146 define('KEYWORD_CONTINUE', 'continue');
147 define('KEYWORD_DEBUGGER', 'debugger');
148 define('KEYWORD_DEFAULT', 'default');
149 define('KEYWORD_DELETE', 'delete');
150 define('KEYWORD_DO', 'do');
151 define('KEYWORD_ELSE', 'else');
152 define('KEYWORD_ENUM', 'enum');
153 define('KEYWORD_FALSE', 'false');
154 define('KEYWORD_FINALLY', 'finally');
155 define('KEYWORD_FOR', 'for');
156 define('KEYWORD_FUNCTION', 'function');
157 define('KEYWORD_IF', 'if');
158 define('KEYWORD_IN', 'in');
159 define('KEYWORD_INSTANCEOF', 'instanceof');
160 define('KEYWORD_NEW', 'new');
161 define('KEYWORD_NULL', 'null');
162 define('KEYWORD_RETURN', 'return');
163 define('KEYWORD_SWITCH', 'switch');
164 define('KEYWORD_THIS', 'this');
165 define('KEYWORD_THROW', 'throw');
166 define('KEYWORD_TRUE', 'true');
167 define('KEYWORD_TRY', 'try');
168 define('KEYWORD_TYPEOF', 'typeof');
169 define('KEYWORD_VAR', 'var');
170 define('KEYWORD_VOID', 'void');
171 define('KEYWORD_WHILE', 'while');
172 define('KEYWORD_WITH', 'with');
173 
174 
175 class JSMinPlus
176 {
177  private $parser;
178  private $reserved = array(
179  'break', 'case', 'catch', 'continue', 'default', 'delete', 'do',
180  'else', 'finally', 'for', 'function', 'if', 'in', 'instanceof',
181  'new', 'return', 'switch', 'this', 'throw', 'try', 'typeof', 'var',
182  'void', 'while', 'with',
183  // Words reserved for future use
184  'abstract', 'boolean', 'byte', 'char', 'class', 'const', 'debugger',
185  'double', 'enum', 'export', 'extends', 'final', 'float', 'goto',
186  'implements', 'import', 'int', 'interface', 'long', 'native',
187  'package', 'private', 'protected', 'public', 'short', 'static',
188  'super', 'synchronized', 'throws', 'transient', 'volatile',
189  // These are not reserved, but should be taken into account
190  // in isValidIdentifier (See jslint source code)
191  'arguments', 'eval', 'true', 'false', 'Infinity', 'NaN', 'null', 'undefined'
192  );
193 
194  private function __construct()
195  {
196  $this->parser = new JSParser($this);
197  }
198 
199  public static function minify($js, $filename='')
200  {
201  static $instance;
202 
203  // this is a singleton
204  if(!$instance)
205  $instance = new JSMinPlus();
206 
207  return $instance->min($js, $filename);
208  }
209 
210  private function min($js, $filename)
211  {
212  try
213  {
214  $n = $this->parser->parse($js, $filename, 1);
215  return $this->parseTree($n);
216  }
217  catch(Exception $e)
218  {
219  echo $e->getMessage() . "\n";
220  }
221 
222  return false;
223  }
224 
225  public function parseTree($n, $noBlockGrouping = false)
226  {
227  $s = '';
228 
229  switch ($n->type)
230  {
231  case JS_MINIFIED:
232  $s = $n->value;
233  break;
234 
235  case JS_SCRIPT:
236  // we do nothing yet with funDecls or varDecls
237  $noBlockGrouping = true;
238  // FALL THROUGH
239 
240  case JS_BLOCK:
241  $childs = $n->treeNodes;
242  $lastType = 0;
243  for ($c = 0, $i = 0, $j = count($childs); $i < $j; $i++)
244  {
245  $type = $childs[$i]->type;
246  $t = $this->parseTree($childs[$i]);
247  if (strlen($t))
248  {
249  if ($c)
250  {
251  $s = rtrim($s, ';');
252 
253  if ($type == KEYWORD_FUNCTION && $childs[$i]->functionForm == DECLARED_FORM)
254  {
255  // put declared functions on a new line
256  $s .= "\n";
257  }
258  elseif ($type == KEYWORD_VAR && $type == $lastType)
259  {
260  // multiple var-statements can go into one
261  $t = ',' . substr($t, 4);
262  }
263  else
264  {
265  // add terminator
266  $s .= ';';
267  }
268  }
269 
270  $s .= $t;
271 
272  $c++;
273  $lastType = $type;
274  }
275  }
276 
277  if ($c > 1 && !$noBlockGrouping)
278  {
279  $s = '{' . $s . '}';
280  }
281  break;
282 
283  case KEYWORD_FUNCTION:
284  $s .= 'function' . ($n->name ? ' ' . $n->name : '') . '(';
285  $params = $n->params;
286  for ($i = 0, $j = count($params); $i < $j; $i++)
287  $s .= ($i ? ',' : '') . $params[$i];
288  $s .= '){' . $this->parseTree($n->body, true) . '}';
289  break;
290 
291  case KEYWORD_IF:
292  $s = 'if(' . $this->parseTree($n->condition) . ')';
293  $thenPart = $this->parseTree($n->thenPart);
294  $elsePart = $n->elsePart ? $this->parseTree($n->elsePart) : null;
295 
296  // empty if-statement
297  if ($thenPart == '')
298  $thenPart = ';';
299 
300  if ($elsePart)
301  {
302  // be careful and always make a block out of the thenPart; could be more optimized but is a lot of trouble
303  if ($thenPart != ';' && $thenPart[0] != '{')
304  $thenPart = '{' . $thenPart . '}';
305 
306  $s .= $thenPart . 'else';
307 
308  // we could check for more, but that hardly ever applies so go for performance
309  if ($elsePart[0] != '{')
310  $s .= ' ';
311 
312  $s .= $elsePart;
313  }
314  else
315  {
316  $s .= $thenPart;
317  }
318  break;
319 
320  case KEYWORD_SWITCH:
321  $s = 'switch(' . $this->parseTree($n->discriminant) . '){';
322  $cases = $n->cases;
323  for ($i = 0, $j = count($cases); $i < $j; $i++)
324  {
325  $case = $cases[$i];
326  if ($case->type == KEYWORD_CASE)
327  $s .= 'case' . ($case->caseLabel->type != TOKEN_STRING ? ' ' : '') . $this->parseTree($case->caseLabel) . ':';
328  else
329  $s .= 'default:';
330 
331  $statement = $this->parseTree($case->statements, true);
332  if ($statement)
333  {
334  $s .= $statement;
335  // no terminator for last statement
336  if ($i + 1 < $j)
337  $s .= ';';
338  }
339  }
340  $s .= '}';
341  break;
342 
343  case KEYWORD_FOR:
344  $s = 'for(' . ($n->setup ? $this->parseTree($n->setup) : '')
345  . ';' . ($n->condition ? $this->parseTree($n->condition) : '')
346  . ';' . ($n->update ? $this->parseTree($n->update) : '') . ')';
347 
348  $body = $this->parseTree($n->body);
349  if ($body == '')
350  $body = ';';
351 
352  $s .= $body;
353  break;
354 
355  case KEYWORD_WHILE:
356  $s = 'while(' . $this->parseTree($n->condition) . ')';
357 
358  $body = $this->parseTree($n->body);
359  if ($body == '')
360  $body = ';';
361 
362  $s .= $body;
363  break;
364 
365  case JS_FOR_IN:
366  $s = 'for(' . ($n->varDecl ? $this->parseTree($n->varDecl) : $this->parseTree($n->iterator)) . ' in ' . $this->parseTree($n->object) . ')';
367 
368  $body = $this->parseTree($n->body);
369  if ($body == '')
370  $body = ';';
371 
372  $s .= $body;
373  break;
374 
375  case KEYWORD_DO:
376  $s = 'do{' . $this->parseTree($n->body, true) . '}while(' . $this->parseTree($n->condition) . ')';
377  break;
378 
379  case KEYWORD_BREAK:
380  case KEYWORD_CONTINUE:
381  $s = $n->value . ($n->label ? ' ' . $n->label : '');
382  break;
383 
384  case KEYWORD_TRY:
385  $s = 'try{' . $this->parseTree($n->tryBlock, true) . '}';
386  $catchClauses = $n->catchClauses;
387  for ($i = 0, $j = count($catchClauses); $i < $j; $i++)
388  {
389  $t = $catchClauses[$i];
390  $s .= 'catch(' . $t->varName . ($t->guard ? ' if ' . $this->parseTree($t->guard) : '') . '){' . $this->parseTree($t->block, true) . '}';
391  }
392  if ($n->finallyBlock)
393  $s .= 'finally{' . $this->parseTree($n->finallyBlock, true) . '}';
394  break;
395 
396  case KEYWORD_THROW:
397  case KEYWORD_RETURN:
398  $s = $n->type;
399  if ($n->value)
400  {
401  $t = $this->parseTree($n->value);
402  if (strlen($t))
403  {
404  if ($this->isWordChar($t[0]) || $t[0] == '\\')
405  $s .= ' ';
406 
407  $s .= $t;
408  }
409  }
410  break;
411 
412  case KEYWORD_WITH:
413  $s = 'with(' . $this->parseTree($n->object) . ')' . $this->parseTree($n->body);
414  break;
415 
416  case KEYWORD_VAR:
417  case KEYWORD_CONST:
418  $s = $n->value . ' ';
419  $childs = $n->treeNodes;
420  for ($i = 0, $j = count($childs); $i < $j; $i++)
421  {
422  $t = $childs[$i];
423  $s .= ($i ? ',' : '') . $t->name;
424  $u = $t->initializer;
425  if ($u)
426  $s .= '=' . $this->parseTree($u);
427  }
428  break;
429 
430  case KEYWORD_IN:
431  case KEYWORD_INSTANCEOF:
432  $left = $this->parseTree($n->treeNodes[0]);
433  $right = $this->parseTree($n->treeNodes[1]);
434 
435  $s = $left;
436 
437  if ($this->isWordChar(substr($left, -1)))
438  $s .= ' ';
439 
440  $s .= $n->type;
441 
442  if ($this->isWordChar($right[0]) || $right[0] == '\\')
443  $s .= ' ';
444 
445  $s .= $right;
446  break;
447 
448  case KEYWORD_DELETE:
449  case KEYWORD_TYPEOF:
450  $right = $this->parseTree($n->treeNodes[0]);
451 
452  $s = $n->type;
453 
454  if ($this->isWordChar($right[0]) || $right[0] == '\\')
455  $s .= ' ';
456 
457  $s .= $right;
458  break;
459 
460  case KEYWORD_VOID:
461  $s = 'void(' . $this->parseTree($n->treeNodes[0]) . ')';
462  break;
463 
464  case KEYWORD_DEBUGGER:
465  throw new Exception('NOT IMPLEMENTED: DEBUGGER');
466  break;
467 
468  case TOKEN_CONDCOMMENT_START:
469  case TOKEN_CONDCOMMENT_END:
470  $s = $n->value . ($n->type == TOKEN_CONDCOMMENT_START ? ' ' : '');
471  $childs = $n->treeNodes;
472  for ($i = 0, $j = count($childs); $i < $j; $i++)
473  $s .= $this->parseTree($childs[$i]);
474  break;
475 
476  case OP_SEMICOLON:
477  if ($expression = $n->expression)
478  $s = $this->parseTree($expression);
479  break;
480 
481  case JS_LABEL:
482  $s = $n->label . ':' . $this->parseTree($n->statement);
483  break;
484 
485  case OP_COMMA:
486  $childs = $n->treeNodes;
487  for ($i = 0, $j = count($childs); $i < $j; $i++)
488  $s .= ($i ? ',' : '') . $this->parseTree($childs[$i]);
489  break;
490 
491  case OP_ASSIGN:
492  $s = $this->parseTree($n->treeNodes[0]) . $n->value . $this->parseTree($n->treeNodes[1]);
493  break;
494 
495  case OP_HOOK:
496  $s = $this->parseTree($n->treeNodes[0]) . '?' . $this->parseTree($n->treeNodes[1]) . ':' . $this->parseTree($n->treeNodes[2]);
497  break;
498 
499  case OP_OR: case OP_AND:
500  case OP_BITWISE_OR: case OP_BITWISE_XOR: case OP_BITWISE_AND:
501  case OP_EQ: case OP_NE: case OP_STRICT_EQ: case OP_STRICT_NE:
502  case OP_LT: case OP_LE: case OP_GE: case OP_GT:
503  case OP_LSH: case OP_RSH: case OP_URSH:
504  case OP_MUL: case OP_DIV: case OP_MOD:
505  $s = $this->parseTree($n->treeNodes[0]) . $n->type . $this->parseTree($n->treeNodes[1]);
506  break;
507 
508  case OP_PLUS:
509  case OP_MINUS:
510  $left = $this->parseTree($n->treeNodes[0]);
511  $right = $this->parseTree($n->treeNodes[1]);
512 
513  switch ($n->treeNodes[1]->type)
514  {
515  case OP_PLUS:
516  case OP_MINUS:
517  case OP_INCREMENT:
518  case OP_DECREMENT:
519  case OP_UNARY_PLUS:
520  case OP_UNARY_MINUS:
521  $s = $left . $n->type . ' ' . $right;
522  break;
523 
524  case TOKEN_STRING:
525  //combine concatenated strings with same quote style
526  if ($n->type == OP_PLUS && substr($left, -1) == $right[0])
527  {
528  $s = substr($left, 0, -1) . substr($right, 1);
529  break;
530  }
531  // FALL THROUGH
532 
533  default:
534  $s = $left . $n->type . $right;
535  }
536  break;
537 
538  case OP_NOT:
539  case OP_BITWISE_NOT:
540  case OP_UNARY_PLUS:
541  case OP_UNARY_MINUS:
542  $s = $n->value . $this->parseTree($n->treeNodes[0]);
543  break;
544 
545  case OP_INCREMENT:
546  case OP_DECREMENT:
547  if ($n->postfix)
548  $s = $this->parseTree($n->treeNodes[0]) . $n->value;
549  else
550  $s = $n->value . $this->parseTree($n->treeNodes[0]);
551  break;
552 
553  case OP_DOT:
554  $s = $this->parseTree($n->treeNodes[0]) . '.' . $this->parseTree($n->treeNodes[1]);
555  break;
556 
557  case JS_INDEX:
558  $s = $this->parseTree($n->treeNodes[0]);
559  // See if we can replace named index with a dot saving 3 bytes
560  if ( $n->treeNodes[0]->type == TOKEN_IDENTIFIER &&
561  $n->treeNodes[1]->type == TOKEN_STRING &&
562  $this->isValidIdentifier(substr($n->treeNodes[1]->value, 1, -1))
563  )
564  $s .= '.' . substr($n->treeNodes[1]->value, 1, -1);
565  else
566  $s .= '[' . $this->parseTree($n->treeNodes[1]) . ']';
567  break;
568 
569  case JS_LIST:
570  $childs = $n->treeNodes;
571  for ($i = 0, $j = count($childs); $i < $j; $i++)
572  $s .= ($i ? ',' : '') . $this->parseTree($childs[$i]);
573  break;
574 
575  case JS_CALL:
576  $s = $this->parseTree($n->treeNodes[0]) . '(' . $this->parseTree($n->treeNodes[1]) . ')';
577  break;
578 
579  case KEYWORD_NEW:
580  case JS_NEW_WITH_ARGS:
581  $s = 'new ' . $this->parseTree($n->treeNodes[0]) . '(' . ($n->type == JS_NEW_WITH_ARGS ? $this->parseTree($n->treeNodes[1]) : '') . ')';
582  break;
583 
584  case JS_ARRAY_INIT:
585  $s = '[';
586  $childs = $n->treeNodes;
587  for ($i = 0, $j = count($childs); $i < $j; $i++)
588  {
589  $s .= ($i ? ',' : '') . $this->parseTree($childs[$i]);
590  }
591  $s .= ']';
592  break;
593 
594  case JS_OBJECT_INIT:
595  $s = '{';
596  $childs = $n->treeNodes;
597  for ($i = 0, $j = count($childs); $i < $j; $i++)
598  {
599  $t = $childs[$i];
600  if ($i)
601  $s .= ',';
602  if ($t->type == JS_PROPERTY_INIT)
603  {
604  // Ditch the quotes when the index is a valid identifier
605  if ( $t->treeNodes[0]->type == TOKEN_STRING &&
606  $this->isValidIdentifier(substr($t->treeNodes[0]->value, 1, -1))
607  )
608  $s .= substr($t->treeNodes[0]->value, 1, -1);
609  else
610  $s .= $t->treeNodes[0]->value;
611 
612  $s .= ':' . $this->parseTree($t->treeNodes[1]);
613  }
614  else
615  {
616  $s .= $t->type == JS_GETTER ? 'get' : 'set';
617  $s .= ' ' . $t->name . '(';
618  $params = $t->params;
619  for ($i = 0, $j = count($params); $i < $j; $i++)
620  $s .= ($i ? ',' : '') . $params[$i];
621  $s .= '){' . $this->parseTree($t->body, true) . '}';
622  }
623  }
624  $s .= '}';
625  break;
626 
627  case TOKEN_NUMBER:
628  $s = $n->value;
629  if (preg_match('/^([1-9]+)(0{3,})$/', $s, $m))
630  $s = $m[1] . 'e' . strlen($m[2]);
631  break;
632 
633  case KEYWORD_NULL: case KEYWORD_THIS: case KEYWORD_TRUE: case KEYWORD_FALSE:
634  case TOKEN_IDENTIFIER: case TOKEN_STRING: case TOKEN_REGEXP:
635  $s = $n->value;
636  break;
637 
638  case JS_GROUP:
639  if (in_array(
640  $n->treeNodes[0]->type,
641  array(
642  JS_ARRAY_INIT, JS_OBJECT_INIT, JS_GROUP,
643  TOKEN_NUMBER, TOKEN_STRING, TOKEN_REGEXP, TOKEN_IDENTIFIER,
644  KEYWORD_NULL, KEYWORD_THIS, KEYWORD_TRUE, KEYWORD_FALSE
645  )
646  ))
647  {
648  $s = $this->parseTree($n->treeNodes[0]);
649  }
650  else
651  {
652  $s = '(' . $this->parseTree($n->treeNodes[0]) . ')';
653  }
654  break;
655 
656  default:
657  throw new Exception('UNKNOWN TOKEN TYPE: ' . $n->type);
658  }
659 
660  return $s;
661  }
662 
663  private function isValidIdentifier($string)
664  {
665  return preg_match('/^[a-zA-Z_][a-zA-Z0-9_]*$/', $string) && !in_array($string, $this->reserved);
666  }
667 
668  private function isWordChar($char)
669  {
670  return $char == '_' || $char == '$' || ctype_alnum($char);
671  }
672 }
673 
674 class JSParser
675 {
676  private $t;
677  private $minifier;
678 
679  private $opPrecedence = array(
680  ';' => 0,
681  ',' => 1,
682  '=' => 2, '?' => 2, ':' => 2,
683  // The above all have to have the same precedence, see bug 330975
684  '||' => 4,
685  '&&' => 5,
686  '|' => 6,
687  '^' => 7,
688  '&' => 8,
689  '==' => 9, '!=' => 9, '===' => 9, '!==' => 9,
690  '<' => 10, '<=' => 10, '>=' => 10, '>' => 10, 'in' => 10, 'instanceof' => 10,
691  '<<' => 11, '>>' => 11, '>>>' => 11,
692  '+' => 12, '-' => 12,
693  '*' => 13, '/' => 13, '%' => 13,
694  'delete' => 14, 'void' => 14, 'typeof' => 14,
695  '!' => 14, '~' => 14, 'U+' => 14, 'U-' => 14,
696  '++' => 15, '--' => 15,
697  'new' => 16,
698  '.' => 17,
699  JS_NEW_WITH_ARGS => 0, JS_INDEX => 0, JS_CALL => 0,
700  JS_ARRAY_INIT => 0, JS_OBJECT_INIT => 0, JS_GROUP => 0
701  );
702 
703  private $opArity = array(
704  ',' => -2,
705  '=' => 2,
706  '?' => 3,
707  '||' => 2,
708  '&&' => 2,
709  '|' => 2,
710  '^' => 2,
711  '&' => 2,
712  '==' => 2, '!=' => 2, '===' => 2, '!==' => 2,
713  '<' => 2, '<=' => 2, '>=' => 2, '>' => 2, 'in' => 2, 'instanceof' => 2,
714  '<<' => 2, '>>' => 2, '>>>' => 2,
715  '+' => 2, '-' => 2,
716  '*' => 2, '/' => 2, '%' => 2,
717  'delete' => 1, 'void' => 1, 'typeof' => 1,
718  '!' => 1, '~' => 1, 'U+' => 1, 'U-' => 1,
719  '++' => 1, '--' => 1,
720  'new' => 1,
721  '.' => 2,
722  JS_NEW_WITH_ARGS => 2, JS_INDEX => 2, JS_CALL => 2,
723  JS_ARRAY_INIT => 1, JS_OBJECT_INIT => 1, JS_GROUP => 1,
724  TOKEN_CONDCOMMENT_START => 1, TOKEN_CONDCOMMENT_END => 1
725  );
726 
727  public function __construct($minifier=null)
728  {
729  $this->minifier = $minifier;
730  $this->t = new JSTokenizer();
731  }
732 
733  public function parse($s, $f, $l)
734  {
735  // initialize tokenizer
736  $this->t->init($s, $f, $l);
737 
738  $x = new JSCompilerContext(false);
739  $n = $this->Script($x);
740  if (!$this->t->isDone())
741  throw $this->t->newSyntaxError('Syntax error');
742 
743  return $n;
744  }
745 
746  private function Script($x)
747  {
748  $n = $this->Statements($x);
749  $n->type = JS_SCRIPT;
750  $n->funDecls = $x->funDecls;
751  $n->varDecls = $x->varDecls;
752 
753  // minify by scope
754  if ($this->minifier)
755  {
756  $n->value = $this->minifier->parseTree($n);
757 
758  // clear tree from node to save memory
759  $n->treeNodes = null;
760  $n->funDecls = null;
761  $n->varDecls = null;
762 
763  $n->type = JS_MINIFIED;
764  }
765 
766  return $n;
767  }
768 
769  private function Statements($x)
770  {
771  $n = new JSNode($this->t, JS_BLOCK);
772  array_push($x->stmtStack, $n);
773 
774  while (!$this->t->isDone() && $this->t->peek() != OP_RIGHT_CURLY)
775  $n->addNode($this->Statement($x));
776 
777  array_pop($x->stmtStack);
778 
779  return $n;
780  }
781 
782  private function Block($x)
783  {
784  $this->t->mustMatch(OP_LEFT_CURLY);
785  $n = $this->Statements($x);
786  $this->t->mustMatch(OP_RIGHT_CURLY);
787 
788  return $n;
789  }
790 
791  private function Statement($x)
792  {
793  $tt = $this->t->get();
794  $n2 = null;
795 
796  // Cases for statements ending in a right curly return early, avoiding the
797  // common semicolon insertion magic after this switch.
798  switch ($tt)
799  {
800  case KEYWORD_FUNCTION:
801  return $this->FunctionDefinition(
802  $x,
803  true,
804  count($x->stmtStack) > 1 ? STATEMENT_FORM : DECLARED_FORM
805  );
806  break;
807 
808  case OP_LEFT_CURLY:
809  $n = $this->Statements($x);
810  $this->t->mustMatch(OP_RIGHT_CURLY);
811  return $n;
812 
813  case KEYWORD_IF:
814  $n = new JSNode($this->t);
815  $n->condition = $this->ParenExpression($x);
816  array_push($x->stmtStack, $n);
817  $n->thenPart = $this->Statement($x);
818  $n->elsePart = $this->t->match(KEYWORD_ELSE) ? $this->Statement($x) : null;
819  array_pop($x->stmtStack);
820  return $n;
821 
822  case KEYWORD_SWITCH:
823  $n = new JSNode($this->t);
824  $this->t->mustMatch(OP_LEFT_PAREN);
825  $n->discriminant = $this->Expression($x);
826  $this->t->mustMatch(OP_RIGHT_PAREN);
827  $n->cases = array();
828  $n->defaultIndex = -1;
829 
830  array_push($x->stmtStack, $n);
831 
832  $this->t->mustMatch(OP_LEFT_CURLY);
833 
834  while (($tt = $this->t->get()) != OP_RIGHT_CURLY)
835  {
836  switch ($tt)
837  {
838  case KEYWORD_DEFAULT:
839  if ($n->defaultIndex >= 0)
840  throw $this->t->newSyntaxError('More than one switch default');
841  // FALL THROUGH
842  case KEYWORD_CASE:
843  $n2 = new JSNode($this->t);
844  if ($tt == KEYWORD_DEFAULT)
845  $n->defaultIndex = count($n->cases);
846  else
847  $n2->caseLabel = $this->Expression($x, OP_COLON);
848  break;
849  default:
850  throw $this->t->newSyntaxError('Invalid switch case');
851  }
852 
853  $this->t->mustMatch(OP_COLON);
854  $n2->statements = new JSNode($this->t, JS_BLOCK);
855  while (($tt = $this->t->peek()) != KEYWORD_CASE && $tt != KEYWORD_DEFAULT && $tt != OP_RIGHT_CURLY)
856  $n2->statements->addNode($this->Statement($x));
857 
858  array_push($n->cases, $n2);
859  }
860 
861  array_pop($x->stmtStack);
862  return $n;
863 
864  case KEYWORD_FOR:
865  $n = new JSNode($this->t);
866  $n->isLoop = true;
867  $this->t->mustMatch(OP_LEFT_PAREN);
868 
869  if (($tt = $this->t->peek()) != OP_SEMICOLON)
870  {
871  $x->inForLoopInit = true;
872  if ($tt == KEYWORD_VAR || $tt == KEYWORD_CONST)
873  {
874  $this->t->get();
875  $n2 = $this->Variables($x);
876  }
877  else
878  {
879  $n2 = $this->Expression($x);
880  }
881  $x->inForLoopInit = false;
882  }
883 
884  if ($n2 && $this->t->match(KEYWORD_IN))
885  {
886  $n->type = JS_FOR_IN;
887  if ($n2->type == KEYWORD_VAR)
888  {
889  if (count($n2->treeNodes) != 1)
890  {
891  throw $this->t->SyntaxError(
892  'Invalid for..in left-hand side',
893  $this->t->filename,
894  $n2->lineno
895  );
896  }
897 
898  // NB: n2[0].type == IDENTIFIER and n2[0].value == n2[0].name.
899  $n->iterator = $n2->treeNodes[0];
900  $n->varDecl = $n2;
901  }
902  else
903  {
904  $n->iterator = $n2;
905  $n->varDecl = null;
906  }
907 
908  $n->object = $this->Expression($x);
909  }
910  else
911  {
912  $n->setup = $n2 ?: null;
913  $this->t->mustMatch(OP_SEMICOLON);
914  $n->condition = $this->t->peek() == OP_SEMICOLON ? null : $this->Expression($x);
915  $this->t->mustMatch(OP_SEMICOLON);
916  $n->update = $this->t->peek() == OP_RIGHT_PAREN ? null : $this->Expression($x);
917  }
918 
919  $this->t->mustMatch(OP_RIGHT_PAREN);
920  $n->body = $this->nest($x, $n);
921  return $n;
922 
923  case KEYWORD_WHILE:
924  $n = new JSNode($this->t);
925  $n->isLoop = true;
926  $n->condition = $this->ParenExpression($x);
927  $n->body = $this->nest($x, $n);
928  return $n;
929 
930  case KEYWORD_DO:
931  $n = new JSNode($this->t);
932  $n->isLoop = true;
933  $n->body = $this->nest($x, $n, KEYWORD_WHILE);
934  $n->condition = $this->ParenExpression($x);
935  if (!$x->ecmaStrictMode)
936  {
937  // <script language="JavaScript"> (without version hints) may need
938  // automatic semicolon insertion without a newline after do-while.
939  // See https://bugzilla.mozilla.org/show_bug.cgi?id=238945.
940  $this->t->match(OP_SEMICOLON);
941  return $n;
942  }
943  break;
944 
945  case KEYWORD_BREAK:
946  case KEYWORD_CONTINUE:
947  $n = new JSNode($this->t);
948 
949  if ($this->t->peekOnSameLine() == TOKEN_IDENTIFIER)
950  {
951  $this->t->get();
952  $n->label = $this->t->currentToken()->value;
953  }
954 
955  $ss = $x->stmtStack;
956  $i = count($ss);
957  $label = $n->label;
958  if ($label)
959  {
960  do
961  {
962  if (--$i < 0)
963  throw $this->t->newSyntaxError('Label not found');
964  }
965  while ($ss[$i]->label != $label);
966  }
967  else
968  {
969  do
970  {
971  if (--$i < 0)
972  throw $this->t->newSyntaxError('Invalid ' . $tt);
973  }
974  while (!$ss[$i]->isLoop && ($tt != KEYWORD_BREAK || $ss[$i]->type != KEYWORD_SWITCH));
975  }
976  break;
977 
978  case KEYWORD_TRY:
979  $n = new JSNode($this->t);
980  $n->tryBlock = $this->Block($x);
981  $n->catchClauses = array();
982 
983  while ($this->t->match(KEYWORD_CATCH))
984  {
985  $n2 = new JSNode($this->t);
986  $this->t->mustMatch(OP_LEFT_PAREN);
987  $n2->varName = $this->t->mustMatch(TOKEN_IDENTIFIER)->value;
988 
989  if ($this->t->match(KEYWORD_IF))
990  {
991  if ($x->ecmaStrictMode)
992  throw $this->t->newSyntaxError('Illegal catch guard');
993 
994  if (count($n->catchClauses) && !end($n->catchClauses)->guard)
995  throw $this->t->newSyntaxError('Guarded catch after unguarded');
996 
997  $n2->guard = $this->Expression($x);
998  }
999  else
1000  {
1001  $n2->guard = null;
1002  }
1003 
1004  $this->t->mustMatch(OP_RIGHT_PAREN);
1005  $n2->block = $this->Block($x);
1006  array_push($n->catchClauses, $n2);
1007  }
1008 
1009  if ($this->t->match(KEYWORD_FINALLY))
1010  $n->finallyBlock = $this->Block($x);
1011 
1012  if (!count($n->catchClauses) && !$n->finallyBlock)
1013  throw $this->t->newSyntaxError('Invalid try statement');
1014  return $n;
1015 
1016  case KEYWORD_CATCH:
1017  case KEYWORD_FINALLY:
1018  throw $this->t->newSyntaxError($tt . ' without preceding try');
1019 
1020  case KEYWORD_THROW:
1021  $n = new JSNode($this->t);
1022  $n->value = $this->Expression($x);
1023  break;
1024 
1025  case KEYWORD_RETURN:
1026  if (!$x->inFunction)
1027  throw $this->t->newSyntaxError('Invalid return');
1028 
1029  $n = new JSNode($this->t);
1030  $tt = $this->t->peekOnSameLine();
1031  if ($tt != TOKEN_END && $tt != TOKEN_NEWLINE && $tt != OP_SEMICOLON && $tt != OP_RIGHT_CURLY)
1032  $n->value = $this->Expression($x);
1033  else
1034  $n->value = null;
1035  break;
1036 
1037  case KEYWORD_WITH:
1038  $n = new JSNode($this->t);
1039  $n->object = $this->ParenExpression($x);
1040  $n->body = $this->nest($x, $n);
1041  return $n;
1042 
1043  case KEYWORD_VAR:
1044  case KEYWORD_CONST:
1045  $n = $this->Variables($x);
1046  break;
1047 
1048  case TOKEN_CONDCOMMENT_START:
1049  case TOKEN_CONDCOMMENT_END:
1050  $n = new JSNode($this->t);
1051  return $n;
1052 
1053  case KEYWORD_DEBUGGER:
1054  $n = new JSNode($this->t);
1055  break;
1056 
1057  case TOKEN_NEWLINE:
1058  case OP_SEMICOLON:
1059  $n = new JSNode($this->t, OP_SEMICOLON);
1060  $n->expression = null;
1061  return $n;
1062 
1063  default:
1064  if ($tt == TOKEN_IDENTIFIER)
1065  {
1066  $this->t->scanOperand = false;
1067  $tt = $this->t->peek();
1068  $this->t->scanOperand = true;
1069  if ($tt == OP_COLON)
1070  {
1071  $label = $this->t->currentToken()->value;
1072  $ss = $x->stmtStack;
1073  for ($i = count($ss) - 1; $i >= 0; --$i)
1074  {
1075  if ($ss[$i]->label == $label)
1076  throw $this->t->newSyntaxError('Duplicate label');
1077  }
1078 
1079  $this->t->get();
1080  $n = new JSNode($this->t, JS_LABEL);
1081  $n->label = $label;
1082  $n->statement = $this->nest($x, $n);
1083 
1084  return $n;
1085  }
1086  }
1087 
1088  $n = new JSNode($this->t, OP_SEMICOLON);
1089  $this->t->unget();
1090  $n->expression = $this->Expression($x);
1091  $n->end = $n->expression->end;
1092  break;
1093  }
1094 
1095  if ($this->t->lineno == $this->t->currentToken()->lineno)
1096  {
1097  $tt = $this->t->peekOnSameLine();
1098  if ($tt != TOKEN_END && $tt != TOKEN_NEWLINE && $tt != OP_SEMICOLON && $tt != OP_RIGHT_CURLY)
1099  throw $this->t->newSyntaxError('Missing ; before statement');
1100  }
1101 
1102  $this->t->match(OP_SEMICOLON);
1103 
1104  return $n;
1105  }
1106 
1107  private function FunctionDefinition($x, $requireName, $functionForm)
1108  {
1109  $f = new JSNode($this->t);
1110 
1111  if ($f->type != KEYWORD_FUNCTION)
1112  $f->type = ($f->value == 'get') ? JS_GETTER : JS_SETTER;
1113 
1114  if ($this->t->match(TOKEN_IDENTIFIER))
1115  $f->name = $this->t->currentToken()->value;
1116  elseif ($requireName)
1117  throw $this->t->newSyntaxError('Missing function identifier');
1118 
1119  $this->t->mustMatch(OP_LEFT_PAREN);
1120  $f->params = array();
1121 
1122  while (($tt = $this->t->get()) != OP_RIGHT_PAREN)
1123  {
1124  if ($tt != TOKEN_IDENTIFIER)
1125  throw $this->t->newSyntaxError('Missing formal parameter');
1126 
1127  array_push($f->params, $this->t->currentToken()->value);
1128 
1129  if ($this->t->peek() != OP_RIGHT_PAREN)
1130  $this->t->mustMatch(OP_COMMA);
1131  }
1132 
1133  $this->t->mustMatch(OP_LEFT_CURLY);
1134 
1135  $x2 = new JSCompilerContext(true);
1136  $f->body = $this->Script($x2);
1137 
1138  $this->t->mustMatch(OP_RIGHT_CURLY);
1139  $f->end = $this->t->currentToken()->end;
1140 
1141  $f->functionForm = $functionForm;
1142  if ($functionForm == DECLARED_FORM)
1143  array_push($x->funDecls, $f);
1144 
1145  return $f;
1146  }
1147 
1148  private function Variables($x)
1149  {
1150  $n = new JSNode($this->t);
1151 
1152  do
1153  {
1154  $this->t->mustMatch(TOKEN_IDENTIFIER);
1155 
1156  $n2 = new JSNode($this->t);
1157  $n2->name = $n2->value;
1158 
1159  if ($this->t->match(OP_ASSIGN))
1160  {
1161  if ($this->t->currentToken()->assignOp)
1162  throw $this->t->newSyntaxError('Invalid variable initialization');
1163 
1164  $n2->initializer = $this->Expression($x, OP_COMMA);
1165  }
1166 
1167  $n2->readOnly = $n->type == KEYWORD_CONST;
1168 
1169  $n->addNode($n2);
1170  array_push($x->varDecls, $n2);
1171  }
1172  while ($this->t->match(OP_COMMA));
1173 
1174  return $n;
1175  }
1176 
1177  private function Expression($x, $stop=false)
1178  {
1179  $operators = array();
1180  $operands = array();
1181  $n = false;
1182 
1183  $bl = $x->bracketLevel;
1184  $cl = $x->curlyLevel;
1185  $pl = $x->parenLevel;
1186  $hl = $x->hookLevel;
1187 
1188  while (($tt = $this->t->get()) != TOKEN_END)
1189  {
1190  if ($tt == $stop &&
1191  $x->bracketLevel == $bl &&
1192  $x->curlyLevel == $cl &&
1193  $x->parenLevel == $pl &&
1194  $x->hookLevel == $hl
1195  )
1196  {
1197  // Stop only if tt matches the optional stop parameter, and that
1198  // token is not quoted by some kind of bracket.
1199  break;
1200  }
1201 
1202  switch ($tt)
1203  {
1204  case OP_SEMICOLON:
1205  // NB: cannot be empty, Statement handled that.
1206  break 2;
1207 
1208  case OP_HOOK:
1209  if ($this->t->scanOperand)
1210  break 2;
1211 
1212  while ( !empty($operators) &&
1213  $this->opPrecedence[end($operators)->type] > $this->opPrecedence[$tt]
1214  )
1215  $this->reduce($operators, $operands);
1216 
1217  array_push($operators, new JSNode($this->t));
1218 
1219  ++$x->hookLevel;
1220  $this->t->scanOperand = true;
1221  $n = $this->Expression($x);
1222 
1223  if (!$this->t->match(OP_COLON))
1224  break 2;
1225 
1226  --$x->hookLevel;
1227  array_push($operands, $n);
1228  break;
1229 
1230  case OP_COLON:
1231  if ($x->hookLevel)
1232  break 2;
1233 
1234  throw $this->t->newSyntaxError('Invalid label');
1235  break;
1236 
1237  case OP_ASSIGN:
1238  if ($this->t->scanOperand)
1239  break 2;
1240 
1241  // Use >, not >=, for right-associative ASSIGN
1242  while ( !empty($operators) &&
1243  $this->opPrecedence[end($operators)->type] > $this->opPrecedence[$tt]
1244  )
1245  $this->reduce($operators, $operands);
1246 
1247  array_push($operators, new JSNode($this->t));
1248  end($operands)->assignOp = $this->t->currentToken()->assignOp;
1249  $this->t->scanOperand = true;
1250  break;
1251 
1252  case KEYWORD_IN:
1253  // An in operator should not be parsed if we're parsing the head of
1254  // a for (...) loop, unless it is in the then part of a conditional
1255  // expression, or parenthesized somehow.
1256  if ($x->inForLoopInit && !$x->hookLevel &&
1257  !$x->bracketLevel && !$x->curlyLevel &&
1258  !$x->parenLevel
1259  )
1260  break 2;
1261  // FALL THROUGH
1262  case OP_COMMA:
1263  // A comma operator should not be parsed if we're parsing the then part
1264  // of a conditional expression unless it's parenthesized somehow.
1265  if ($tt == OP_COMMA && $x->hookLevel &&
1266  !$x->bracketLevel && !$x->curlyLevel &&
1267  !$x->parenLevel
1268  )
1269  break 2;
1270  // Treat comma as left-associative so reduce can fold left-heavy
1271  // COMMA trees into a single array.
1272  // FALL THROUGH
1273  case OP_OR:
1274  case OP_AND:
1275  case OP_BITWISE_OR:
1276  case OP_BITWISE_XOR:
1277  case OP_BITWISE_AND:
1278  case OP_EQ: case OP_NE: case OP_STRICT_EQ: case OP_STRICT_NE:
1279  case OP_LT: case OP_LE: case OP_GE: case OP_GT:
1280  case KEYWORD_INSTANCEOF:
1281  case OP_LSH: case OP_RSH: case OP_URSH:
1282  case OP_PLUS: case OP_MINUS:
1283  case OP_MUL: case OP_DIV: case OP_MOD:
1284  case OP_DOT:
1285  if ($this->t->scanOperand)
1286  break 2;
1287 
1288  while ( !empty($operators) &&
1289  $this->opPrecedence[end($operators)->type] >= $this->opPrecedence[$tt]
1290  )
1291  $this->reduce($operators, $operands);
1292 
1293  if ($tt == OP_DOT)
1294  {
1295  $this->t->mustMatch(TOKEN_IDENTIFIER);
1296  array_push($operands, new JSNode($this->t, OP_DOT, array_pop($operands), new JSNode($this->t)));
1297  }
1298  else
1299  {
1300  array_push($operators, new JSNode($this->t));
1301  $this->t->scanOperand = true;
1302  }
1303  break;
1304 
1305  case KEYWORD_DELETE: case KEYWORD_VOID: case KEYWORD_TYPEOF:
1306  case OP_NOT: case OP_BITWISE_NOT: case OP_UNARY_PLUS: case OP_UNARY_MINUS:
1307  case KEYWORD_NEW:
1308  if (!$this->t->scanOperand)
1309  break 2;
1310 
1311  array_push($operators, new JSNode($this->t));
1312  break;
1313 
1314  case OP_INCREMENT: case OP_DECREMENT:
1315  if ($this->t->scanOperand)
1316  {
1317  array_push($operators, new JSNode($this->t)); // prefix increment or decrement
1318  }
1319  else
1320  {
1321  // Don't cross a line boundary for postfix {in,de}crement.
1322  $t = $this->t->tokens[($this->t->tokenIndex + $this->t->lookahead - 1) & 3];
1323  if ($t && $t->lineno != $this->t->lineno)
1324  break 2;
1325 
1326  if (!empty($operators))
1327  {
1328  // Use >, not >=, so postfix has higher precedence than prefix.
1329  while ($this->opPrecedence[end($operators)->type] > $this->opPrecedence[$tt])
1330  $this->reduce($operators, $operands);
1331  }
1332 
1333  $n = new JSNode($this->t, $tt, array_pop($operands));
1334  $n->postfix = true;
1335  array_push($operands, $n);
1336  }
1337  break;
1338 
1339  case KEYWORD_FUNCTION:
1340  if (!$this->t->scanOperand)
1341  break 2;
1342 
1343  array_push($operands, $this->FunctionDefinition($x, false, EXPRESSED_FORM));
1344  $this->t->scanOperand = false;
1345  break;
1346 
1347  case KEYWORD_NULL: case KEYWORD_THIS: case KEYWORD_TRUE: case KEYWORD_FALSE:
1348  case TOKEN_IDENTIFIER: case TOKEN_NUMBER: case TOKEN_STRING: case TOKEN_REGEXP:
1349  if (!$this->t->scanOperand)
1350  break 2;
1351 
1352  array_push($operands, new JSNode($this->t));
1353  $this->t->scanOperand = false;
1354  break;
1355 
1356  case TOKEN_CONDCOMMENT_START:
1357  case TOKEN_CONDCOMMENT_END:
1358  if ($this->t->scanOperand)
1359  array_push($operators, new JSNode($this->t));
1360  else
1361  array_push($operands, new JSNode($this->t));
1362  break;
1363 
1364  case OP_LEFT_BRACKET:
1365  if ($this->t->scanOperand)
1366  {
1367  // Array initialiser. Parse using recursive descent, as the
1368  // sub-grammar here is not an operator grammar.
1369  $n = new JSNode($this->t, JS_ARRAY_INIT);
1370  while (($tt = $this->t->peek()) != OP_RIGHT_BRACKET)
1371  {
1372  if ($tt == OP_COMMA)
1373  {
1374  $this->t->get();
1375  $n->addNode(null);
1376  continue;
1377  }
1378 
1379  $n->addNode($this->Expression($x, OP_COMMA));
1380  if (!$this->t->match(OP_COMMA))
1381  break;
1382  }
1383 
1384  $this->t->mustMatch(OP_RIGHT_BRACKET);
1385  array_push($operands, $n);
1386  $this->t->scanOperand = false;
1387  }
1388  else
1389  {
1390  // Property indexing operator.
1391  array_push($operators, new JSNode($this->t, JS_INDEX));
1392  $this->t->scanOperand = true;
1393  ++$x->bracketLevel;
1394  }
1395  break;
1396 
1397  case OP_RIGHT_BRACKET:
1398  if ($this->t->scanOperand || $x->bracketLevel == $bl)
1399  break 2;
1400 
1401  while ($this->reduce($operators, $operands)->type != JS_INDEX)
1402  continue;
1403 
1404  --$x->bracketLevel;
1405  break;
1406 
1407  case OP_LEFT_CURLY:
1408  if (!$this->t->scanOperand)
1409  break 2;
1410 
1411  // Object initialiser. As for array initialisers (see above),
1412  // parse using recursive descent.
1413  ++$x->curlyLevel;
1414  $n = new JSNode($this->t, JS_OBJECT_INIT);
1415  while (!$this->t->match(OP_RIGHT_CURLY))
1416  {
1417  do
1418  {
1419  $tt = $this->t->get();
1420  $tv = $this->t->currentToken()->value;
1421  if (($tv == 'get' || $tv == 'set') && $this->t->peek() == TOKEN_IDENTIFIER)
1422  {
1423  if ($x->ecmaStrictMode)
1424  throw $this->t->newSyntaxError('Illegal property accessor');
1425 
1426  $n->addNode($this->FunctionDefinition($x, true, EXPRESSED_FORM));
1427  }
1428  else
1429  {
1430  switch ($tt)
1431  {
1432  case TOKEN_IDENTIFIER:
1433  case TOKEN_NUMBER:
1434  case TOKEN_STRING:
1435  $id = new JSNode($this->t);
1436  break;
1437 
1438  case OP_RIGHT_CURLY:
1439  if ($x->ecmaStrictMode)
1440  throw $this->t->newSyntaxError('Illegal trailing ,');
1441  break 3;
1442 
1443  default:
1444  throw $this->t->newSyntaxError('Invalid property name');
1445  }
1446 
1447  $this->t->mustMatch(OP_COLON);
1448  $n->addNode(new JSNode($this->t, JS_PROPERTY_INIT, $id, $this->Expression($x, OP_COMMA)));
1449  }
1450  }
1451  while ($this->t->match(OP_COMMA));
1452 
1453  $this->t->mustMatch(OP_RIGHT_CURLY);
1454  break;
1455  }
1456 
1457  array_push($operands, $n);
1458  $this->t->scanOperand = false;
1459  --$x->curlyLevel;
1460  break;
1461 
1462  case OP_RIGHT_CURLY:
1463  if (!$this->t->scanOperand && $x->curlyLevel != $cl)
1464  throw new Exception('PANIC: right curly botch');
1465  break 2;
1466 
1467  case OP_LEFT_PAREN:
1468  if ($this->t->scanOperand)
1469  {
1470  array_push($operators, new JSNode($this->t, JS_GROUP));
1471  }
1472  else
1473  {
1474  while ( !empty($operators) &&
1475  $this->opPrecedence[end($operators)->type] > $this->opPrecedence[KEYWORD_NEW]
1476  )
1477  $this->reduce($operators, $operands);
1478 
1479  // Handle () now, to regularize the n-ary case for n > 0.
1480  // We must set scanOperand in case there are arguments and
1481  // the first one is a regexp or unary+/-.
1482  $n = end($operators);
1483  $this->t->scanOperand = true;
1484  if ($this->t->match(OP_RIGHT_PAREN))
1485  {
1486  if ($n && $n->type == KEYWORD_NEW)
1487  {
1488  array_pop($operators);
1489  $n->addNode(array_pop($operands));
1490  }
1491  else
1492  {
1493  $n = new JSNode($this->t, JS_CALL, array_pop($operands), new JSNode($this->t, JS_LIST));
1494  }
1495 
1496  array_push($operands, $n);
1497  $this->t->scanOperand = false;
1498  break;
1499  }
1500 
1501  if ($n && $n->type == KEYWORD_NEW)
1502  $n->type = JS_NEW_WITH_ARGS;
1503  else
1504  array_push($operators, new JSNode($this->t, JS_CALL));
1505  }
1506 
1507  ++$x->parenLevel;
1508  break;
1509 
1510  case OP_RIGHT_PAREN:
1511  if ($this->t->scanOperand || $x->parenLevel == $pl)
1512  break 2;
1513 
1514  while (($tt = $this->reduce($operators, $operands)->type) != JS_GROUP &&
1515  $tt != JS_CALL && $tt != JS_NEW_WITH_ARGS
1516  )
1517  {
1518  continue;
1519  }
1520 
1521  if ($tt != JS_GROUP)
1522  {
1523  $n = end($operands);
1524  if ($n->treeNodes[1]->type != OP_COMMA)
1525  $n->treeNodes[1] = new JSNode($this->t, JS_LIST, $n->treeNodes[1]);
1526  else
1527  $n->treeNodes[1]->type = JS_LIST;
1528  }
1529 
1530  --$x->parenLevel;
1531  break;
1532 
1533  // Automatic semicolon insertion means we may scan across a newline
1534  // and into the beginning of another statement. If so, break out of
1535  // the while loop and let the t.scanOperand logic handle errors.
1536  default:
1537  break 2;
1538  }
1539  }
1540 
1541  if ($x->hookLevel != $hl)
1542  throw $this->t->newSyntaxError('Missing : in conditional expression');
1543 
1544  if ($x->parenLevel != $pl)
1545  throw $this->t->newSyntaxError('Missing ) in parenthetical');
1546 
1547  if ($x->bracketLevel != $bl)
1548  throw $this->t->newSyntaxError('Missing ] in index expression');
1549 
1550  if ($this->t->scanOperand)
1551  throw $this->t->newSyntaxError('Missing operand');
1552 
1553  // Resume default mode, scanning for operands, not operators.
1554  $this->t->scanOperand = true;
1555  $this->t->unget();
1556 
1557  while (count($operators))
1558  $this->reduce($operators, $operands);
1559 
1560  return array_pop($operands);
1561  }
1562 
1563  private function ParenExpression($x)
1564  {
1565  $this->t->mustMatch(OP_LEFT_PAREN);
1566  $n = $this->Expression($x);
1567  $this->t->mustMatch(OP_RIGHT_PAREN);
1568 
1569  return $n;
1570  }
1571 
1572  // Statement stack and nested statement handler.
1573  private function nest($x, $node, $end = false)
1574  {
1575  array_push($x->stmtStack, $node);
1576  $n = $this->statement($x);
1577  array_pop($x->stmtStack);
1578 
1579  if ($end)
1580  $this->t->mustMatch($end);
1581 
1582  return $n;
1583  }
1584 
1585  private function reduce(&$operators, &$operands)
1586  {
1587  $n = array_pop($operators);
1588  $op = $n->type;
1589  $arity = $this->opArity[$op];
1590  $c = count($operands);
1591  if ($arity == -2)
1592  {
1593  // Flatten left-associative trees
1594  if ($c >= 2)
1595  {
1596  $left = $operands[$c - 2];
1597  if ($left->type == $op)
1598  {
1599  $right = array_pop($operands);
1600  $left->addNode($right);
1601  return $left;
1602  }
1603  }
1604  $arity = 2;
1605  }
1606 
1607  // Always use push to add operands to n, to update start and end
1608  $a = array_splice($operands, $c - $arity);
1609  for ($i = 0; $i < $arity; $i++)
1610  $n->addNode($a[$i]);
1611 
1612  // Include closing bracket or postfix operator in [start,end]
1613  $te = $this->t->currentToken()->end;
1614  if ($n->end < $te)
1615  $n->end = $te;
1616 
1617  array_push($operands, $n);
1618 
1619  return $n;
1620  }
1621 }
1622 
1623 class JSCompilerContext
1624 {
1625  public $inFunction = false;
1626  public $inForLoopInit = false;
1627  public $ecmaStrictMode = false;
1628  public $bracketLevel = 0;
1629  public $curlyLevel = 0;
1630  public $parenLevel = 0;
1631  public $hookLevel = 0;
1632 
1633  public $stmtStack = array();
1634  public $funDecls = array();
1635  public $varDecls = array();
1636 
1637  public function __construct($inFunction)
1638  {
1639  $this->inFunction = $inFunction;
1640  }
1641 }
1642 
1643 class JSNode
1644 {
1645  private $type;
1646  private $value;
1647  private $lineno;
1648  private $start;
1649  private $end;
1650 
1651  public $treeNodes = array();
1652  public $funDecls = array();
1653  public $varDecls = array();
1654 
1655  public function __construct($t, $type=0)
1656  {
1657  if ($token = $t->currentToken())
1658  {
1659  $this->type = $type ?: $token->type;
1660  $this->value = $token->value;
1661  $this->lineno = $token->lineno;
1662  $this->start = $token->start;
1663  $this->end = $token->end;
1664  }
1665  else
1666  {
1667  $this->type = $type;
1668  $this->lineno = $t->lineno;
1669  }
1670 
1671  if (($numargs = func_num_args()) > 2)
1672  {
1673  $args = func_get_args();
1674  for ($i = 2; $i < $numargs; $i++)
1675  $this->addNode($args[$i]);
1676  }
1677  }
1678 
1679  // we don't want to bloat our object with all kind of specific properties, so we use overloading
1680  public function __set($name, $value)
1681  {
1682  $this->$name = $value;
1683  }
1684 
1685  public function __get($name)
1686  {
1687  if (isset($this->$name))
1688  return $this->$name;
1689 
1690  return null;
1691  }
1692 
1693  public function addNode($node)
1694  {
1695  if ($node !== null)
1696  {
1697  if ($node->start < $this->start)
1698  $this->start = $node->start;
1699  if ($this->end < $node->end)
1700  $this->end = $node->end;
1701  }
1702 
1703  $this->treeNodes[] = $node;
1704  }
1705 }
1706 
1707 class JSTokenizer
1708 {
1709  private $cursor = 0;
1710  private $source;
1711 
1712  public $tokens = array();
1713  public $tokenIndex = 0;
1714  public $lookahead = 0;
1715  public $scanNewlines = false;
1716  public $scanOperand = true;
1717 
1718  public $filename;
1719  public $lineno;
1720 
1721  private $keywords = array(
1722  'break',
1723  'case', 'catch', 'const', 'continue',
1724  'debugger', 'default', 'delete', 'do',
1725  'else', 'enum',
1726  'false', 'finally', 'for', 'function',
1727  'if', 'in', 'instanceof',
1728  'new', 'null',
1729  'return',
1730  'switch',
1731  'this', 'throw', 'true', 'try', 'typeof',
1732  'var', 'void',
1733  'while', 'with'
1734  );
1735 
1736  private $opTypeNames = array(
1737  ';', ',', '?', ':', '||', '&&', '|', '^',
1738  '&', '===', '==', '=', '!==', '!=', '<<', '<=',
1739  '<', '>>>', '>>', '>=', '>', '++', '--', '+',
1740  '-', '*', '/', '%', '!', '~', '.', '[',
1741  ']', '{', '}', '(', ')', '@*/'
1742  );
1743 
1744  private $assignOps = array('|', '^', '&', '<<', '>>', '>>>', '+', '-', '*', '/', '%');
1745  private $opRegExp;
1746 
1747  public function __construct()
1748  {
1749  $this->opRegExp = '#^(' . implode('|', array_map('preg_quote', $this->opTypeNames)) . ')#';
1750  }
1751 
1752  public function init($source, $filename = '', $lineno = 1)
1753  {
1754  $this->source = $source;
1755  $this->filename = $filename ?: '[inline]';
1756  $this->lineno = $lineno;
1757 
1758  $this->cursor = 0;
1759  $this->tokens = array();
1760  $this->tokenIndex = 0;
1761  $this->lookahead = 0;
1762  $this->scanNewlines = false;
1763  $this->scanOperand = true;
1764  }
1765 
1766  public function getInput($chunksize)
1767  {
1768  if ($chunksize)
1769  return substr($this->source, $this->cursor, $chunksize);
1770 
1771  return substr($this->source, $this->cursor);
1772  }
1773 
1774  public function isDone()
1775  {
1776  return $this->peek() == TOKEN_END;
1777  }
1778 
1779  public function match($tt)
1780  {
1781  return $this->get() == $tt || $this->unget();
1782  }
1783 
1784  public function mustMatch($tt)
1785  {
1786  if (!$this->match($tt))
1787  throw $this->newSyntaxError('Unexpected token; token ' . $tt . ' expected');
1788 
1789  return $this->currentToken();
1790  }
1791 
1792  public function peek()
1793  {
1794  if ($this->lookahead)
1795  {
1796  $next = $this->tokens[($this->tokenIndex + $this->lookahead) & 3];
1797  if ($this->scanNewlines && $next->lineno != $this->lineno)
1798  $tt = TOKEN_NEWLINE;
1799  else
1800  $tt = $next->type;
1801  }
1802  else
1803  {
1804  $tt = $this->get();
1805  $this->unget();
1806  }
1807 
1808  return $tt;
1809  }
1810 
1811  public function peekOnSameLine()
1812  {
1813  $this->scanNewlines = true;
1814  $tt = $this->peek();
1815  $this->scanNewlines = false;
1816 
1817  return $tt;
1818  }
1819 
1820  public function currentToken()
1821  {
1822  if (!empty($this->tokens))
1823  return $this->tokens[$this->tokenIndex];
1824  }
1825 
1826  public function get($chunksize = 1000)
1827  {
1828  while($this->lookahead)
1829  {
1830  $this->lookahead--;
1831  $this->tokenIndex = ($this->tokenIndex + 1) & 3;
1832  $token = $this->tokens[$this->tokenIndex];
1833  if ($token->type != TOKEN_NEWLINE || $this->scanNewlines)
1834  return $token->type;
1835  }
1836 
1837  $conditional_comment = false;
1838 
1839  // strip whitespace and comments
1840  while(true)
1841  {
1842  $input = $this->getInput($chunksize);
1843 
1844  // whitespace handling; gobble up \r as well (effectively we don't have support for MAC newlines!)
1845  $re = $this->scanNewlines ? '/^[ \r\t]+/' : '/^\s+/';
1846  if (preg_match($re, $input, $match))
1847  {
1848  $spaces = $match[0];
1849  $spacelen = strlen($spaces);
1850  $this->cursor += $spacelen;
1851  if (!$this->scanNewlines)
1852  $this->lineno += substr_count($spaces, "\n");
1853 
1854  if ($spacelen == $chunksize)
1855  continue; // complete chunk contained whitespace
1856 
1857  $input = $this->getInput($chunksize);
1858  if ($input == '' || $input[0] != '/')
1859  break;
1860  }
1861 
1862  // Comments
1863  if (!preg_match('/^\/(?:\*(@(?:cc_on|if|elif|else|end))?.*?\*\/|\/[^\n]*)/s', $input, $match))
1864  {
1865  if (!$chunksize)
1866  break;
1867 
1868  // retry with a full chunk fetch; this also prevents breakage of long regular expressions (which will never match a comment)
1869  $chunksize = null;
1870  continue;
1871  }
1872 
1873  // check if this is a conditional (JScript) comment
1874  if (!empty($match[1]))
1875  {
1876  $match[0] = '/*' . $match[1];
1877  $conditional_comment = true;
1878  break;
1879  }
1880  else
1881  {
1882  $this->cursor += strlen($match[0]);
1883  $this->lineno += substr_count($match[0], "\n");
1884  }
1885  }
1886 
1887  if ($input == '')
1888  {
1889  $tt = TOKEN_END;
1890  $match = array('');
1891  }
1892  elseif ($conditional_comment)
1893  {
1894  $tt = TOKEN_CONDCOMMENT_START;
1895  }
1896  else
1897  {
1898  switch ($input[0])
1899  {
1900  case '0':
1901  // hexadecimal
1902  if (($input[1] == 'x' || $input[1] == 'X') && preg_match('/^0x[0-9a-f]+/i', $input, $match))
1903  {
1904  $tt = TOKEN_NUMBER;
1905  break;
1906  }
1907  // FALL THROUGH
1908 
1909  case '1': case '2': case '3': case '4': case '5':
1910  case '6': case '7': case '8': case '9':
1911  // should always match
1912  preg_match('/^\d+(?:\.\d*)?(?:[eE][-+]?\d+)?/', $input, $match);
1913  $tt = TOKEN_NUMBER;
1914  break;
1915 
1916  case "'":
1917  if (preg_match('/^\'(?:[^\\\\\'\r\n]++|\\\\(?:.|\r?\n))*\'/', $input, $match))
1918  {
1919  $tt = TOKEN_STRING;
1920  }
1921  else
1922  {
1923  if ($chunksize)
1924  return $this->get(null); // retry with a full chunk fetch
1925 
1926  throw $this->newSyntaxError('Unterminated string literal');
1927  }
1928  break;
1929 
1930  case '"':
1931  if (preg_match('/^"(?:[^\\\\"\r\n]++|\\\\(?:.|\r?\n))*"/', $input, $match))
1932  {
1933  $tt = TOKEN_STRING;
1934  }
1935  else
1936  {
1937  if ($chunksize)
1938  return $this->get(null); // retry with a full chunk fetch
1939 
1940  throw $this->newSyntaxError('Unterminated string literal');
1941  }
1942  break;
1943 
1944  case '/':
1945  if ($this->scanOperand && preg_match('/^\/((?:\\\\.|\[(?:\\\\.|[^\]])*\]|[^\/])+)\/([gimy]*)/', $input, $match))
1946  {
1947  $tt = TOKEN_REGEXP;
1948  break;
1949  }
1950  // FALL THROUGH
1951 
1952  case '|':
1953  case '^':
1954  case '&':
1955  case '<':
1956  case '>':
1957  case '+':
1958  case '-':
1959  case '*':
1960  case '%':
1961  case '=':
1962  case '!':
1963  // should always match
1964  preg_match($this->opRegExp, $input, $match);
1965  $op = $match[0];
1966  if (in_array($op, $this->assignOps) && $input[strlen($op)] == '=')
1967  {
1968  $tt = OP_ASSIGN;
1969  $match[0] .= '=';
1970  }
1971  else
1972  {
1973  $tt = $op;
1974  if ($this->scanOperand)
1975  {
1976  if ($op == OP_PLUS)
1977  $tt = OP_UNARY_PLUS;
1978  elseif ($op == OP_MINUS)
1979  $tt = OP_UNARY_MINUS;
1980  }
1981  $op = null;
1982  }
1983  break;
1984 
1985  case '.':
1986  if (preg_match('/^\.\d+(?:[eE][-+]?\d+)?/', $input, $match))
1987  {
1988  $tt = TOKEN_NUMBER;
1989  break;
1990  }
1991  // FALL THROUGH
1992 
1993  case ';':
1994  case ',':
1995  case '?':
1996  case ':':
1997  case '~':
1998  case '[':
1999  case ']':
2000  case '{':
2001  case '}':
2002  case '(':
2003  case ')':
2004  // these are all single
2005  $match = array($input[0]);
2006  $tt = $input[0];
2007  break;
2008 
2009  case '@':
2010  // check end of conditional comment
2011  if (substr($input, 0, 3) == '@*/')
2012  {
2013  $match = array('@*/');
2014  $tt = TOKEN_CONDCOMMENT_END;
2015  }
2016  else
2017  throw $this->newSyntaxError('Illegal token');
2018  break;
2019 
2020  case "\n":
2021  if ($this->scanNewlines)
2022  {
2023  $match = array("\n");
2024  $tt = TOKEN_NEWLINE;
2025  }
2026  else
2027  throw $this->newSyntaxError('Illegal token');
2028  break;
2029 
2030  default:
2031  // Fast path for identifiers: word chars followed by whitespace or various other tokens.
2032  // Note we don't need to exclude digits in the first char, as they've already been found
2033  // above.
2034  if (!preg_match('/^[$\w]+(?=[\s\/\|\^\&<>\+\-\*%=!.;,\?:~\[\]\{\}\(\)@])/', $input, $match))
2035  {
2036  // Character classes per ECMA-262 edition 5.1 section 7.6
2037  // Per spec, must accept Unicode 3.0, *may* accept later versions.
2038  // We'll take whatever PCRE understands, which should be more recent.
2039  $identifierStartChars = "\\p{L}\\p{Nl}" . # UnicodeLetter
2040  "\$" .
2041  "_";
2042  $identifierPartChars = $identifierStartChars .
2043  "\\p{Mn}\\p{Mc}" . # UnicodeCombiningMark
2044  "\\p{Nd}" . # UnicodeDigit
2045  "\\p{Pc}"; # UnicodeConnectorPunctuation
2046  $unicodeEscape = "\\\\u[0-9A-F-a-f]{4}";
2047  $identifierRegex = "/^" .
2048  "(?:[$identifierStartChars]|$unicodeEscape)" .
2049  "(?:[$identifierPartChars]|$unicodeEscape)*" .
2050  "/uS";
2051  if (preg_match($identifierRegex, $input, $match))
2052  {
2053  if (strpos($match[0], '\\') !== false) {
2054  // Per ECMA-262 edition 5.1, section 7.6 escape sequences should behave as if they were
2055  // the original chars, but only within the boundaries of the identifier.
2056  $decoded = preg_replace_callback('/\\\\u([0-9A-Fa-f]{4})/',
2057  array(__CLASS__, 'unicodeEscapeCallback'),
2058  $match[0]);
2059 
2060  // Since our original regex didn't de-escape the originals, we need to check for validity again.
2061  // No need to worry about token boundaries, as anything outside the identifier is illegal!
2062  if (!preg_match("/^[$identifierStartChars][$identifierPartChars]*$/u", $decoded)) {
2063  throw $this->newSyntaxError('Illegal token');
2064  }
2065 
2066  // Per spec it _ought_ to work to use these escapes for keywords words as well...
2067  // but IE rejects them as invalid, while Firefox and Chrome treat them as identifiers
2068  // that don't match the keyword.
2069  if (in_array($decoded, $this->keywords)) {
2070  throw $this->newSyntaxError('Illegal token');
2071  }
2072 
2073  // TODO: save the decoded form for output?
2074  }
2075  }
2076  else
2077  throw $this->newSyntaxError('Illegal token');
2078  }
2079  $tt = in_array($match[0], $this->keywords) ? $match[0] : TOKEN_IDENTIFIER;
2080  }
2081  }
2082 
2083  $this->tokenIndex = ($this->tokenIndex + 1) & 3;
2084 
2085  if (!isset($this->tokens[$this->tokenIndex]))
2086  $this->tokens[$this->tokenIndex] = new JSToken();
2087 
2088  $token = $this->tokens[$this->tokenIndex];
2089  $token->type = $tt;
2090 
2091  if ($tt == OP_ASSIGN)
2092  $token->assignOp = $op;
2093 
2094  $token->start = $this->cursor;
2095 
2096  $token->value = $match[0];
2097  $this->cursor += strlen($match[0]);
2098 
2099  $token->end = $this->cursor;
2100  $token->lineno = $this->lineno;
2101 
2102  return $tt;
2103  }
2104 
2105  public function unget()
2106  {
2107  if (++$this->lookahead == 4)
2108  throw $this->newSyntaxError('PANIC: too much lookahead!');
2109 
2110  $this->tokenIndex = ($this->tokenIndex - 1) & 3;
2111  }
2112 
2113  public function newSyntaxError($m)
2114  {
2115  return new Exception('Parse error: ' . $m . ' in file \'' . $this->filename . '\' on line ' . $this->lineno);
2116  }
2117 
2118  public static function unicodeEscapeCallback($m)
2119  {
2120  return html_entity_decode('&#x' . $m[1]. ';', ENT_QUOTES, 'UTF-8');
2121  }
2122 }
2123 
2124 class JSToken
2125 {
2126  public $type;
2127  public $value;
2128  public $start;
2129  public $end;
2130  public $lineno;
2131  public $assignOp;
2132 }
KEYWORD_CASE
const KEYWORD_CASE
Definition: jsminplus.php:143
JSTokenizer\mustMatch
mustMatch($tt)
Definition: jsminplus.php:1784
OP_STRICT_NE
const OP_STRICT_NE
Definition: jsminplus.php:111
if
if($IP===false)
Definition: cleanupArchiveUserText.php:4
JS_MINIFIED
const JS_MINIFIED
Definition: jsminplus.php:92
OP_STRICT_EQ
const OP_STRICT_EQ
Definition: jsminplus.php:108
KEYWORD_VOID
const KEYWORD_VOID
Definition: jsminplus.php:170
JSTokenizer
Definition: jsminplus.php:1707
JSParser\Statements
Statements($x)
Definition: jsminplus.php:769
KEYWORD_NEW
const KEYWORD_NEW
Definition: jsminplus.php:160
OP_NE
const OP_NE
Definition: jsminplus.php:112
source
null for the wiki Added should default to null in handler for backwards compatibility add a value to it if you want to add a cookie that have to vary cache options can modify as strings Extensions should add to this list prev or next refreshes the diff cache allow viewing deleted revs source
Definition: hooks.txt:1679
JSParser\__construct
__construct($minifier=null)
Definition: jsminplus.php:727
JSNode\__set
__set($name, $value)
Definition: jsminplus.php:1680
JSTokenizer\$tokens
$tokens
Definition: jsminplus.php:1712
OP_DIV
const OP_DIV
Definition: jsminplus.php:125
captcha-old.count
count
Definition: captcha-old.py:249
JSTokenizer\$scanOperand
$scanOperand
Definition: jsminplus.php:1716
OP_GT
const OP_GT
Definition: jsminplus.php:119
OP_MUL
const OP_MUL
Definition: jsminplus.php:124
KEYWORD_TRUE
const KEYWORD_TRUE
Definition: jsminplus.php:166
OP_LSH
const OP_LSH
Definition: jsminplus.php:113
TOKEN_NEWLINE
const TOKEN_NEWLINE
Definition: jsminplus.php:73
JS_BLOCK
const JS_BLOCK
Definition: jsminplus.php:78
JSNode\$value
$value
Definition: jsminplus.php:1646
KEYWORD_ELSE
const KEYWORD_ELSE
Definition: jsminplus.php:151
JSParser\$minifier
$minifier
Definition: jsminplus.php:677
JSCompilerContext\$curlyLevel
$curlyLevel
Definition: jsminplus.php:1629
JSTokenizer\$lookahead
$lookahead
Definition: jsminplus.php:1714
JS_LABEL
const JS_LABEL
Definition: jsminplus.php:79
JS_INDEX
const JS_INDEX
Definition: jsminplus.php:83
$params
$params
Definition: styleTest.css.php:44
KEYWORD_SWITCH
const KEYWORD_SWITCH
Definition: jsminplus.php:163
JSNode\$treeNodes
$treeNodes
Definition: jsminplus.php:1651
OP_UNARY_MINUS
const OP_UNARY_MINUS
Definition: jsminplus.php:139
OP_URSH
const OP_URSH
Definition: jsminplus.php:116
$s
$s
Definition: mergeMessageFileList.php:187
value
if( $inline) $status value
Definition: SyntaxHighlight.php:345
JS_PROPERTY_INIT
const JS_PROPERTY_INIT
Definition: jsminplus.php:86
KEYWORD_CONTINUE
const KEYWORD_CONTINUE
Definition: jsminplus.php:146
JSTokenizer\match
match($tt)
Definition: jsminplus.php:1779
OP_LEFT_BRACKET
const OP_LEFT_BRACKET
Definition: jsminplus.php:130
JSParser\$opPrecedence
$opPrecedence
Definition: jsminplus.php:679
KEYWORD_VAR
const KEYWORD_VAR
Definition: jsminplus.php:169
JSTokenizer\$lineno
$lineno
Definition: jsminplus.php:1719
JSTokenizer\peek
peek()
Definition: jsminplus.php:1792
OP_UNARY_PLUS
const OP_UNARY_PLUS
Definition: jsminplus.php:138
TOKEN_CONDCOMMENT_START
const TOKEN_CONDCOMMENT_START
Definition: jsminplus.php:74
TOKEN_END
const TOKEN_END
Definition: jsminplus.php:68
JSParser\Script
Script($x)
Definition: jsminplus.php:746
JSMinPlus\minify
static minify($js, $filename='')
Definition: jsminplus.php:199
EXPRESSED_FORM
const EXPRESSED_FORM
Definition: jsminplus.php:95
php
injection txt This is an overview of how MediaWiki makes use of dependency injection The design described here grew from the discussion of RFC T384 The term dependency this means that anything an object needs to operate should be injected from the the object itself should only know narrow no concrete implementation of the logic it relies on The requirement to inject everything typically results in an architecture that based on two main types of and essentially stateless service objects that use other service objects to operate on the value objects As of the beginning MediaWiki is only starting to use the DI approach Much of the code still relies on global state or direct resulting in a highly cyclical dependency which acts as the top level factory for services in MediaWiki which can be used to gain access to default instances of various services MediaWikiServices however also allows new services to be defined and default services to be redefined Services are defined or redefined by providing a callback the instantiator that will return a new instance of the service When it will create an instance of MediaWikiServices and populate it with the services defined in the files listed by thereby bootstrapping the DI framework Per $wgServiceWiringFiles lists includes ServiceWiring php
Definition: injection.txt:35
JSParser\Block
Block($x)
Definition: jsminplus.php:782
OP_MOD
const OP_MOD
Definition: jsminplus.php:126
KEYWORD_WITH
const KEYWORD_WITH
Definition: jsminplus.php:172
TOKEN_CONDCOMMENT_END
const TOKEN_CONDCOMMENT_END
Definition: jsminplus.php:75
JSParser\reduce
reduce(&$operators,&$operands)
Definition: jsminplus.php:1585
JS_SCRIPT
const JS_SCRIPT
Definition: jsminplus.php:77
JSNode
Definition: jsminplus.php:1643
OP_DOT
const OP_DOT
Definition: jsminplus.php:129
JSCompilerContext\$inForLoopInit
$inForLoopInit
Definition: jsminplus.php:1626
JS_SETTER
const JS_SETTER
Definition: jsminplus.php:88
JSCompilerContext\$funDecls
$funDecls
Definition: jsminplus.php:1634
JSMinPlus\__construct
__construct()
Definition: jsminplus.php:194
JSCompilerContext\$ecmaStrictMode
$ecmaStrictMode
Definition: jsminplus.php:1627
JS_LIST
const JS_LIST
Definition: jsminplus.php:90
JSTokenizer\newSyntaxError
newSyntaxError($m)
Definition: jsminplus.php:2113
KEYWORD_RETURN
const KEYWORD_RETURN
Definition: jsminplus.php:162
JSCompilerContext\$stmtStack
$stmtStack
Definition: jsminplus.php:1633
JSParser\Statement
Statement($x)
Definition: jsminplus.php:791
JSNode\$type
$type
Definition: jsminplus.php:1645
$input
if(is_array( $mode)) switch( $mode) $input
Definition: postprocess-phan.php:141
OP_BITWISE_XOR
const OP_BITWISE_XOR
Definition: jsminplus.php:106
OP_PLUS
const OP_PLUS
Definition: jsminplus.php:122
JSParser\Expression
Expression($x, $stop=false)
Definition: jsminplus.php:1177
KEYWORD_FALSE
const KEYWORD_FALSE
Definition: jsminplus.php:153
JSCompilerContext\$varDecls
$varDecls
Definition: jsminplus.php:1635
JSNode\$end
$end
Definition: jsminplus.php:1649
JSMinPlus\$reserved
$reserved
Definition: jsminplus.php:178
JSCompilerContext\$inFunction
$inFunction
Definition: jsminplus.php:1625
JSTokenizer\__construct
__construct()
Definition: jsminplus.php:1747
OP_RSH
const OP_RSH
Definition: jsminplus.php:117
KEYWORD_WHILE
const KEYWORD_WHILE
Definition: jsminplus.php:171
JSParser\FunctionDefinition
FunctionDefinition($x, $requireName, $functionForm)
Definition: jsminplus.php:1107
JSMinPlus\isValidIdentifier
isValidIdentifier($string)
Definition: jsminplus.php:663
JS_ARRAY_INIT
const JS_ARRAY_INIT
Definition: jsminplus.php:84
array
The wiki should then use memcached to cache various data To use multiple just add more items to the array To increase the weight of a make its entry a array("192.168.0.1:11211", 2))
DECLARED_FORM
const DECLARED_FORM
Definition: jsminplus.php:94
JSParser\Variables
Variables($x)
Definition: jsminplus.php:1148
OP_RIGHT_CURLY
const OP_RIGHT_CURLY
Definition: jsminplus.php:133
OP_EQ
const OP_EQ
Definition: jsminplus.php:109
KEYWORD_IF
const KEYWORD_IF
Definition: jsminplus.php:157
KEYWORD_FOR
const KEYWORD_FOR
Definition: jsminplus.php:155
KEYWORD_NULL
const KEYWORD_NULL
Definition: jsminplus.php:161
$name
Allows to change the fields on the form that will be generated $name
Definition: hooks.txt:302
OP_BITWISE_AND
const OP_BITWISE_AND
Definition: jsminplus.php:107
OP_AND
const OP_AND
Definition: jsminplus.php:104
OP_LEFT_PAREN
const OP_LEFT_PAREN
Definition: jsminplus.php:134
JSNode\$start
$start
Definition: jsminplus.php:1648
KEYWORD_TYPEOF
const KEYWORD_TYPEOF
Definition: jsminplus.php:168
OP_COMMA
const OP_COMMA
Definition: jsminplus.php:100
$e
div flags Integer display flags(NO_ACTION_LINK, NO_EXTRA_USER_LINKS) 'LogException' returning false will NOT prevent logging $e
Definition: hooks.txt:2213
KEYWORD_CONST
const KEYWORD_CONST
Definition: jsminplus.php:145
JSMinPlus
Definition: jsminplus.php:175
OP_SEMICOLON
const OP_SEMICOLON
Definition: jsminplus.php:99
KEYWORD_DELETE
const KEYWORD_DELETE
Definition: jsminplus.php:149
OP_LE
const OP_LE
Definition: jsminplus.php:114
JSCompilerContext\$hookLevel
$hookLevel
Definition: jsminplus.php:1631
JSMinPlus\$parser
$parser
Definition: jsminplus.php:177
OP_LT
const OP_LT
Definition: jsminplus.php:115
OP_RIGHT_BRACKET
const OP_RIGHT_BRACKET
Definition: jsminplus.php:131
on
Using a hook running we can avoid having all this option specific stuff in our mainline code Using the function We ve cleaned up the code here by removing clumps of infrequently used code and moving them off somewhere else It s much easier for someone working with this code to see what s _really_ going on
Definition: hooks.txt:77
JSTokenizer\$filename
$filename
Definition: jsminplus.php:1718
JSNode\$lineno
$lineno
Definition: jsminplus.php:1647
JS_GETTER
const JS_GETTER
Definition: jsminplus.php:87
OP_OR
const OP_OR
Definition: jsminplus.php:103
TOKEN_REGEXP
const TOKEN_REGEXP
Definition: jsminplus.php:72
OP_BITWISE_NOT
const OP_BITWISE_NOT
Definition: jsminplus.php:128
JS_GROUP
const JS_GROUP
Definition: jsminplus.php:89
JS_OBJECT_INIT
const JS_OBJECT_INIT
Definition: jsminplus.php:85
JSTokenizer\isDone
isDone()
Definition: jsminplus.php:1774
OP_HOOK
const OP_HOOK
Definition: jsminplus.php:101
JSParser\$opArity
$opArity
Definition: jsminplus.php:703
JS_CALL
const JS_CALL
Definition: jsminplus.php:81
JSTokenizer\$opRegExp
$opRegExp
Definition: jsminplus.php:1745
KEYWORD_INSTANCEOF
const KEYWORD_INSTANCEOF
Definition: jsminplus.php:159
OP_INCREMENT
const OP_INCREMENT
Definition: jsminplus.php:120
JSCompilerContext\__construct
__construct($inFunction)
Definition: jsminplus.php:1637
STATEMENT_FORM
const STATEMENT_FORM
Definition: jsminplus.php:96
JSTokenizer\$source
$source
Definition: jsminplus.php:1710
JSTokenizer\unget
unget()
Definition: jsminplus.php:2105
JSParser\ParenExpression
ParenExpression($x)
Definition: jsminplus.php:1563
KEYWORD_THIS
const KEYWORD_THIS
Definition: jsminplus.php:164
OP_LEFT_CURLY
const OP_LEFT_CURLY
Definition: jsminplus.php:132
JSTokenizer\$assignOps
$assignOps
Definition: jsminplus.php:1744
JSMinPlus\parseTree
parseTree($n, $noBlockGrouping=false)
Definition: jsminplus.php:225
$args
if( $line===false) $args
Definition: cdb.php:64
JSTokenizer\$cursor
$cursor
Definition: jsminplus.php:1709
KEYWORD_DEFAULT
const KEYWORD_DEFAULT
Definition: jsminplus.php:148
TOKEN_NUMBER
const TOKEN_NUMBER
Definition: jsminplus.php:69
KEYWORD_FINALLY
const KEYWORD_FINALLY
Definition: jsminplus.php:154
JSParser\nest
nest($x, $node, $end=false)
Definition: jsminplus.php:1573
JSCompilerContext\$parenLevel
$parenLevel
Definition: jsminplus.php:1630
TOKEN_STRING
const TOKEN_STRING
Definition: jsminplus.php:71
OP_ASSIGN
const OP_ASSIGN
Definition: jsminplus.php:110
JSTokenizer\$keywords
$keywords
Definition: jsminplus.php:1721
JSNode\addNode
addNode($node)
Definition: jsminplus.php:1693
JSMinPlus\min
min($js, $filename)
Definition: jsminplus.php:210
JSNode\$funDecls
$funDecls
Definition: jsminplus.php:1652
JSTokenizer\$opTypeNames
$opTypeNames
Definition: jsminplus.php:1736
OP_RIGHT_PAREN
const OP_RIGHT_PAREN
Definition: jsminplus.php:135
KEYWORD_DEBUGGER
const KEYWORD_DEBUGGER
Definition: jsminplus.php:147
JSMinPlus\isWordChar
isWordChar($char)
Definition: jsminplus.php:668
JSTokenizer\$scanNewlines
$scanNewlines
Definition: jsminplus.php:1715
JSNode\__get
__get($name)
Definition: jsminplus.php:1685
captcha-old.parser
parser
Definition: captcha-old.py:210
JSTokenizer\$tokenIndex
$tokenIndex
Definition: jsminplus.php:1713
JSParser
Definition: jsminplus.php:674
KEYWORD_BREAK
const KEYWORD_BREAK
Definition: jsminplus.php:142
JSTokenizer\getInput
getInput($chunksize)
Definition: jsminplus.php:1766
JSCompilerContext\$bracketLevel
$bracketLevel
Definition: jsminplus.php:1628
OP_GE
const OP_GE
Definition: jsminplus.php:118
TOKEN_IDENTIFIER
const TOKEN_IDENTIFIER
Definition: jsminplus.php:70
JSTokenizer\peekOnSameLine
peekOnSameLine()
Definition: jsminplus.php:1811
$t
$t
Definition: testCompression.php:69
JSToken
Definition: jsminplus.php:2124
OP_DECREMENT
const OP_DECREMENT
Definition: jsminplus.php:121
JS_FOR_IN
const JS_FOR_IN
Definition: jsminplus.php:80
JSTokenizer\init
init($source, $filename='', $lineno=1)
Definition: jsminplus.php:1752
JSParser\$t
$t
Definition: jsminplus.php:676
OP_MINUS
const OP_MINUS
Definition: jsminplus.php:123
type
This document describes the state of Postgres support in and is fairly well maintained The main code is very well while extensions are very hit and miss it is probably the most supported database after MySQL Much of the work in making MediaWiki database agnostic came about through the work of creating Postgres as and are nearing end of but without copying over all the usage comments General notes on the but these can almost always be programmed around *Although Postgres has a true BOOLEAN type
Definition: postgres.txt:22
KEYWORD_CATCH
const KEYWORD_CATCH
Definition: jsminplus.php:144
JSParser\parse
parse($s, $f, $l)
Definition: jsminplus.php:733
JS_NEW_WITH_ARGS
const JS_NEW_WITH_ARGS
Definition: jsminplus.php:82
KEYWORD_FUNCTION
const KEYWORD_FUNCTION
Definition: jsminplus.php:156
JSNode\$varDecls
$varDecls
Definition: jsminplus.php:1653
JSCompilerContext
Definition: jsminplus.php:1623
JSTokenizer\currentToken
currentToken()
Definition: jsminplus.php:1820
KEYWORD_THROW
const KEYWORD_THROW
Definition: jsminplus.php:165
OP_BITWISE_OR
const OP_BITWISE_OR
Definition: jsminplus.php:105
KEYWORD_TRY
const KEYWORD_TRY
Definition: jsminplus.php:167
KEYWORD_IN
const KEYWORD_IN
Definition: jsminplus.php:158
OP_COLON
const OP_COLON
Definition: jsminplus.php:102
KEYWORD_DO
const KEYWORD_DO
Definition: jsminplus.php:150
OP_NOT
const OP_NOT
Definition: jsminplus.php:127
JSNode\__construct
__construct($t, $type=0)
Definition: jsminplus.php:1655
$type
$type
Definition: testCompression.php:48