forked from a64f7bb4-7358-4778-9fbe-3b882c34cc1d/v1
2327 lines
62 KiB
PHP
2327 lines
62 KiB
PHP
<?php
|
|
// @codingStandardsIgnoreFile
|
|
// @ignore comment_docblock_file:file
|
|
// @ignore style_curly_braces:file
|
|
// @ignore style_string_spacing:file
|
|
// @ignore style_else_spacing:file
|
|
// @ignore comment_comment_docblock_missing:file
|
|
// @ignore comment_comment_eg:file
|
|
// @ignore production_code:file
|
|
// @ignore druplart_unary:file
|
|
// @ignore style_uppercase_constants:file
|
|
// @ignore comment_comment_space:file
|
|
// @ignore druplart_conditional_assignment:file
|
|
// @ignore style_paren_spacing:file
|
|
// @ignore style_no_tabs:file
|
|
// @ignore :file
|
|
|
|
/**
|
|
* JSMinPlus version 1.4
|
|
*
|
|
* Minifies a javascript file using a javascript parser
|
|
*
|
|
* This implements a PHP port of Brendan Eich's Narcissus open source javascript engine (in javascript)
|
|
* References: http://en.wikipedia.org/wiki/Narcissus_(JavaScript_engine)
|
|
* Narcissus sourcecode: http://mxr.mozilla.org/mozilla/source/js/narcissus/
|
|
* JSMinPlus weblog: http://crisp.tweakblogs.net/blog/cat/716
|
|
*
|
|
* Tino Zijdel <crisp@tweakers.net>
|
|
*
|
|
* Usage: $minified = JSMinPlus::minify($script [, $filename])
|
|
*
|
|
* Versionlog (see also changelog.txt):
|
|
* 23-07-2011 - remove dynamic creation of OP_* and KEYWORD_* defines and declare them on top
|
|
* reduce memory footprint by minifying by block-scope
|
|
* some small byte-saving and performance improvements
|
|
* 12-05-2009 - fixed hook:colon precedence, fixed empty body in loop and if-constructs
|
|
* 18-04-2009 - fixed crashbug in PHP 5.2.9 and several other bugfixes
|
|
* 12-04-2009 - some small bugfixes and performance improvements
|
|
* 09-04-2009 - initial open sourced version 1.0
|
|
*
|
|
* Latest version of this script: http://files.tweakers.net/jsminplus/jsminplus.zip
|
|
*
|
|
* @file
|
|
*/
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is the Narcissus JavaScript engine.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Brendan Eich <brendan@mozilla.org>.
|
|
* Portions created by the Initial Developer are Copyright (C) 2004
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s): Tino Zijdel <crisp@tweakers.net>
|
|
* PHP port, modifications and minifier routine are (C) 2009-2011
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
define('TOKEN_END', 1);
|
|
define('TOKEN_NUMBER', 2);
|
|
define('TOKEN_IDENTIFIER', 3);
|
|
define('TOKEN_STRING', 4);
|
|
define('TOKEN_REGEXP', 5);
|
|
define('TOKEN_NEWLINE', 6);
|
|
define('TOKEN_CONDCOMMENT_START', 7);
|
|
define('TOKEN_CONDCOMMENT_END', 8);
|
|
|
|
define('JS_SCRIPT', 100);
|
|
define('JS_BLOCK', 101);
|
|
define('JS_LABEL', 102);
|
|
define('JS_FOR_IN', 103);
|
|
define('JS_CALL', 104);
|
|
define('JS_NEW_WITH_ARGS', 105);
|
|
define('JS_INDEX', 106);
|
|
define('JS_ARRAY_INIT', 107);
|
|
define('JS_OBJECT_INIT', 108);
|
|
define('JS_PROPERTY_INIT', 109);
|
|
define('JS_GETTER', 110);
|
|
define('JS_SETTER', 111);
|
|
define('JS_GROUP', 112);
|
|
define('JS_LIST', 113);
|
|
|
|
define('JS_MINIFIED', 999);
|
|
|
|
define('DECLARED_FORM', 0);
|
|
define('EXPRESSED_FORM', 1);
|
|
define('STATEMENT_FORM', 2);
|
|
|
|
/* Operators */
|
|
define('OP_SEMICOLON', ';');
|
|
define('OP_COMMA', ',');
|
|
define('OP_HOOK', '?');
|
|
define('OP_COLON', ':');
|
|
define('OP_OR', '||');
|
|
define('OP_AND', '&&');
|
|
define('OP_BITWISE_OR', '|');
|
|
define('OP_BITWISE_XOR', '^');
|
|
define('OP_BITWISE_AND', '&');
|
|
define('OP_STRICT_EQ', '===');
|
|
define('OP_EQ', '==');
|
|
define('OP_ASSIGN', '=');
|
|
define('OP_STRICT_NE', '!==');
|
|
define('OP_NE', '!=');
|
|
define('OP_LSH', '<<');
|
|
define('OP_LE', '<=');
|
|
define('OP_LT', '<');
|
|
define('OP_URSH', '>>>');
|
|
define('OP_RSH', '>>');
|
|
define('OP_GE', '>=');
|
|
define('OP_GT', '>');
|
|
define('OP_INCREMENT', '++');
|
|
define('OP_DECREMENT', '--');
|
|
define('OP_PLUS', '+');
|
|
define('OP_MINUS', '-');
|
|
define('OP_MUL', '*');
|
|
define('OP_DIV', '/');
|
|
define('OP_MOD', '%');
|
|
define('OP_NOT', '!');
|
|
define('OP_BITWISE_NOT', '~');
|
|
define('OP_DOT', '.');
|
|
define('OP_LEFT_BRACKET', '[');
|
|
define('OP_RIGHT_BRACKET', ']');
|
|
define('OP_LEFT_CURLY', '{');
|
|
define('OP_RIGHT_CURLY', '}');
|
|
define('OP_LEFT_PAREN', '(');
|
|
define('OP_RIGHT_PAREN', ')');
|
|
define('OP_CONDCOMMENT_END', '@*/');
|
|
|
|
define('OP_UNARY_PLUS', 'U+');
|
|
define('OP_UNARY_MINUS', 'U-');
|
|
|
|
/* Keywords */
|
|
define('KEYWORD_BREAK', 'break');
|
|
define('KEYWORD_CASE', 'case');
|
|
define('KEYWORD_CATCH', 'catch');
|
|
define('KEYWORD_CONST', 'const');
|
|
define('KEYWORD_CONTINUE', 'continue');
|
|
define('KEYWORD_DEBUGGER', 'debugger');
|
|
define('KEYWORD_DEFAULT', 'default');
|
|
define('KEYWORD_DELETE', 'delete');
|
|
define('KEYWORD_DO', 'do');
|
|
define('KEYWORD_ELSE', 'else');
|
|
define('KEYWORD_ENUM', 'enum');
|
|
define('KEYWORD_FALSE', 'false');
|
|
define('KEYWORD_FINALLY', 'finally');
|
|
define('KEYWORD_FOR', 'for');
|
|
define('KEYWORD_FUNCTION', 'function');
|
|
define('KEYWORD_IF', 'if');
|
|
define('KEYWORD_IN', 'in');
|
|
define('KEYWORD_INSTANCEOF', 'instanceof');
|
|
define('KEYWORD_NEW', 'new');
|
|
define('KEYWORD_NULL', 'null');
|
|
define('KEYWORD_RETURN', 'return');
|
|
define('KEYWORD_SWITCH', 'switch');
|
|
define('KEYWORD_THIS', 'this');
|
|
define('KEYWORD_THROW', 'throw');
|
|
define('KEYWORD_TRUE', 'true');
|
|
define('KEYWORD_TRY', 'try');
|
|
define('KEYWORD_TYPEOF', 'typeof');
|
|
define('KEYWORD_VAR', 'var');
|
|
define('KEYWORD_VOID', 'void');
|
|
define('KEYWORD_WHILE', 'while');
|
|
define('KEYWORD_WITH', 'with');
|
|
|
|
|
|
class JSMinPlus {
|
|
private $parser;
|
|
private $reserved = array(
|
|
'break',
|
|
'case',
|
|
'catch',
|
|
'continue',
|
|
'default',
|
|
'delete',
|
|
'do',
|
|
'else',
|
|
'finally',
|
|
'for',
|
|
'function',
|
|
'if',
|
|
'in',
|
|
'instanceof',
|
|
'new',
|
|
'return',
|
|
'switch',
|
|
'this',
|
|
'throw',
|
|
'try',
|
|
'typeof',
|
|
'var',
|
|
'void',
|
|
'while',
|
|
'with',
|
|
// Words reserved for future use
|
|
'abstract',
|
|
'boolean',
|
|
'byte',
|
|
'char',
|
|
'class',
|
|
'const',
|
|
'debugger',
|
|
'double',
|
|
'enum',
|
|
'export',
|
|
'extends',
|
|
'final',
|
|
'float',
|
|
'goto',
|
|
'implements',
|
|
'import',
|
|
'int',
|
|
'interface',
|
|
'long',
|
|
'native',
|
|
'package',
|
|
'private',
|
|
'protected',
|
|
'public',
|
|
'short',
|
|
'static',
|
|
'super',
|
|
'synchronized',
|
|
'throws',
|
|
'transient',
|
|
'volatile',
|
|
// These are not reserved, but should be taken into account
|
|
// in isValidIdentifier (See jslint source code)
|
|
'arguments',
|
|
'eval',
|
|
'true',
|
|
'false',
|
|
'Infinity',
|
|
'NaN',
|
|
'null',
|
|
'undefined',
|
|
);
|
|
|
|
private function __construct() {
|
|
$this->parser = new JSParser($this);
|
|
}
|
|
|
|
public static function minify($js, $filename = '') {
|
|
static $instance;
|
|
|
|
// this is a singleton
|
|
if (!$instance) {
|
|
$instance = new JSMinPlus();
|
|
}
|
|
|
|
return $instance->min($js, $filename);
|
|
}
|
|
|
|
private function min($js, $filename) {
|
|
try {
|
|
$n = $this->parser->parse($js, $filename, 1);
|
|
return $this->parseTree($n);
|
|
}
|
|
catch (Exception $e) {
|
|
echo $e->getMessage() . "\n";
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public function parseTree($n, $noBlockGrouping = false) {
|
|
$s = '';
|
|
|
|
switch ($n->type) {
|
|
case JS_MINIFIED:
|
|
$s = $n->value;
|
|
break;
|
|
|
|
case JS_SCRIPT:
|
|
// we do nothing yet with funDecls or varDecls
|
|
$noBlockGrouping = true;
|
|
// FALL THROUGH
|
|
|
|
case JS_BLOCK:
|
|
$childs = $n->treeNodes;
|
|
$lastType = 0;
|
|
for ($c = 0, $i = 0, $j = count($childs); $i < $j; $i++) {
|
|
$type = $childs[$i]->type;
|
|
$t = $this->parseTree($childs[$i]);
|
|
if (strlen($t)) {
|
|
if ($c) {
|
|
$s = rtrim($s, ';');
|
|
|
|
if ($type == KEYWORD_FUNCTION && $childs[$i]->functionForm == DECLARED_FORM) {
|
|
// put declared functions on a new line
|
|
$s .= "\n";
|
|
}
|
|
elseif ($type == KEYWORD_VAR && $type == $lastType) {
|
|
// multiple var-statements can go into one
|
|
$t = ',' . substr($t, 4);
|
|
}
|
|
else {
|
|
// add terminator
|
|
$s .= ';';
|
|
}
|
|
}
|
|
|
|
$s .= $t;
|
|
|
|
$c++;
|
|
$lastType = $type;
|
|
}
|
|
}
|
|
|
|
if ($c > 1 && !$noBlockGrouping) {
|
|
$s = '{' . $s . '}';
|
|
}
|
|
break;
|
|
|
|
case KEYWORD_FUNCTION:
|
|
$s .= 'function' . ($n->name ? ' ' . $n->name : '') . '(';
|
|
$params = $n->params;
|
|
for ($i = 0, $j = count($params); $i < $j; $i++) {
|
|
$s .= ($i ? ',' : '') . $params[$i];
|
|
}
|
|
$s .= '){' . $this->parseTree($n->body, true) . '}';
|
|
break;
|
|
|
|
case KEYWORD_IF:
|
|
$s = 'if(' . $this->parseTree($n->condition) . ')';
|
|
$thenPart = $this->parseTree($n->thenPart);
|
|
$elsePart = $n->elsePart ? $this->parseTree($n->elsePart) : null;
|
|
|
|
// empty if-statement
|
|
if ($thenPart == '') {
|
|
$thenPart = ';';
|
|
}
|
|
|
|
if ($elsePart) {
|
|
// be careful and always make a block out of the thenPart; could be more optimized but is a lot of trouble
|
|
if ($thenPart != ';' && $thenPart[0] != '{') {
|
|
$thenPart = '{' . $thenPart . '}';
|
|
}
|
|
|
|
$s .= $thenPart . 'else';
|
|
|
|
// we could check for more, but that hardly ever applies so go for performance
|
|
if ($elsePart[0] != '{') {
|
|
$s .= ' ';
|
|
}
|
|
|
|
$s .= $elsePart;
|
|
}
|
|
else {
|
|
$s .= $thenPart;
|
|
}
|
|
break;
|
|
|
|
case KEYWORD_SWITCH:
|
|
$s = 'switch(' . $this->parseTree($n->discriminant) . '){';
|
|
$cases = $n->cases;
|
|
for ($i = 0, $j = count($cases); $i < $j; $i++) {
|
|
$case = $cases[$i];
|
|
if ($case->type == KEYWORD_CASE) {
|
|
$s .= 'case' . ($case->caseLabel->type != TOKEN_STRING ? ' ' : '') . $this->parseTree($case->caseLabel) . ':';
|
|
}
|
|
else {
|
|
$s .= 'default:';
|
|
}
|
|
|
|
$statement = $this->parseTree($case->statements, true);
|
|
if ($statement) {
|
|
$s .= $statement;
|
|
// no terminator for last statement
|
|
if ($i + 1 < $j) {
|
|
$s .= ';';
|
|
}
|
|
}
|
|
}
|
|
$s .= '}';
|
|
break;
|
|
|
|
case KEYWORD_FOR:
|
|
$s = 'for(' . ($n->setup ? $this->parseTree($n->setup) : '')
|
|
. ';' . ($n->condition ? $this->parseTree($n->condition) : '')
|
|
. ';' . ($n->update ? $this->parseTree($n->update) : '') . ')';
|
|
|
|
$body = $this->parseTree($n->body);
|
|
if ($body == '') {
|
|
$body = ';';
|
|
}
|
|
|
|
$s .= $body;
|
|
break;
|
|
|
|
case KEYWORD_WHILE:
|
|
$s = 'while(' . $this->parseTree($n->condition) . ')';
|
|
|
|
$body = $this->parseTree($n->body);
|
|
if ($body == '') {
|
|
$body = ';';
|
|
}
|
|
|
|
$s .= $body;
|
|
break;
|
|
|
|
case JS_FOR_IN:
|
|
$s = 'for(' . ($n->varDecl ? $this->parseTree($n->varDecl) : $this->parseTree($n->iterator)) . ' in ' . $this->parseTree($n->object) . ')';
|
|
|
|
$body = $this->parseTree($n->body);
|
|
if ($body == '') {
|
|
$body = ';';
|
|
}
|
|
|
|
$s .= $body;
|
|
break;
|
|
|
|
case KEYWORD_DO:
|
|
$s = 'do{' . $this->parseTree($n->body, true) . '}while(' . $this->parseTree($n->condition) . ')';
|
|
break;
|
|
|
|
case KEYWORD_BREAK:
|
|
case KEYWORD_CONTINUE:
|
|
$s = $n->value . ($n->label ? ' ' . $n->label : '');
|
|
break;
|
|
|
|
case KEYWORD_TRY:
|
|
$s = 'try{' . $this->parseTree($n->tryBlock, true) . '}';
|
|
$catchClauses = $n->catchClauses;
|
|
for ($i = 0, $j = count($catchClauses); $i < $j; $i++) {
|
|
$t = $catchClauses[$i];
|
|
$s .= 'catch(' . $t->varName . ($t->guard ? ' if ' . $this->parseTree($t->guard) : '') . '){' . $this->parseTree($t->block, true) . '}';
|
|
}
|
|
if ($n->finallyBlock) {
|
|
$s .= 'finally{' . $this->parseTree($n->finallyBlock, true) . '}';
|
|
}
|
|
break;
|
|
|
|
case KEYWORD_THROW:
|
|
case KEYWORD_RETURN:
|
|
$s = $n->type;
|
|
if ($n->value) {
|
|
$t = $this->parseTree($n->value);
|
|
if (strlen($t)) {
|
|
if ($this->isWordChar($t[0]) || $t[0] == '\\') {
|
|
$s .= ' ';
|
|
}
|
|
|
|
$s .= $t;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case KEYWORD_WITH:
|
|
$s = 'with(' . $this->parseTree($n->object) . ')' . $this->parseTree($n->body);
|
|
break;
|
|
|
|
case KEYWORD_VAR:
|
|
case KEYWORD_CONST:
|
|
$s = $n->value . ' ';
|
|
$childs = $n->treeNodes;
|
|
for ($i = 0, $j = count($childs); $i < $j; $i++) {
|
|
$t = $childs[$i];
|
|
$s .= ($i ? ',' : '') . $t->name;
|
|
$u = $t->initializer;
|
|
if ($u) {
|
|
$s .= '=' . $this->parseTree($u);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case KEYWORD_IN:
|
|
case KEYWORD_INSTANCEOF:
|
|
$left = $this->parseTree($n->treeNodes[0]);
|
|
$right = $this->parseTree($n->treeNodes[1]);
|
|
|
|
$s = $left;
|
|
|
|
if ($this->isWordChar(substr($left, -1))) {
|
|
$s .= ' ';
|
|
}
|
|
|
|
$s .= $n->type;
|
|
|
|
if ($this->isWordChar($right[0]) || $right[0] == '\\') {
|
|
$s .= ' ';
|
|
}
|
|
|
|
$s .= $right;
|
|
break;
|
|
|
|
case KEYWORD_DELETE:
|
|
case KEYWORD_TYPEOF:
|
|
$right = $this->parseTree($n->treeNodes[0]);
|
|
|
|
$s = $n->type;
|
|
|
|
if ($this->isWordChar($right[0]) || $right[0] == '\\') {
|
|
$s .= ' ';
|
|
}
|
|
|
|
$s .= $right;
|
|
break;
|
|
|
|
case KEYWORD_VOID:
|
|
$s = 'void(' . $this->parseTree($n->treeNodes[0]) . ')';
|
|
break;
|
|
|
|
case KEYWORD_DEBUGGER:
|
|
throw new Exception('NOT IMPLEMENTED: DEBUGGER');
|
|
break;
|
|
|
|
case TOKEN_CONDCOMMENT_START:
|
|
case TOKEN_CONDCOMMENT_END:
|
|
$s = $n->value . ($n->type == TOKEN_CONDCOMMENT_START ? ' ' : '');
|
|
$childs = $n->treeNodes;
|
|
for ($i = 0, $j = count($childs); $i < $j; $i++) {
|
|
$s .= $this->parseTree($childs[$i]);
|
|
}
|
|
break;
|
|
|
|
case OP_SEMICOLON:
|
|
if ($expression = $n->expression) {
|
|
$s = $this->parseTree($expression);
|
|
}
|
|
break;
|
|
|
|
case JS_LABEL:
|
|
$s = $n->label . ':' . $this->parseTree($n->statement);
|
|
break;
|
|
|
|
case OP_COMMA:
|
|
$childs = $n->treeNodes;
|
|
for ($i = 0, $j = count($childs); $i < $j; $i++) {
|
|
$s .= ($i ? ',' : '') . $this->parseTree($childs[$i]);
|
|
}
|
|
break;
|
|
|
|
case OP_ASSIGN:
|
|
$s = $this->parseTree($n->treeNodes[0]) . $n->value . $this->parseTree($n->treeNodes[1]);
|
|
break;
|
|
|
|
case OP_HOOK:
|
|
$s = $this->parseTree($n->treeNodes[0]) . '?' . $this->parseTree($n->treeNodes[1]) . ':' . $this->parseTree($n->treeNodes[2]);
|
|
break;
|
|
|
|
case OP_OR:
|
|
case OP_AND:
|
|
case OP_BITWISE_OR:
|
|
case OP_BITWISE_XOR:
|
|
case OP_BITWISE_AND:
|
|
case OP_EQ:
|
|
case OP_NE:
|
|
case OP_STRICT_EQ:
|
|
case OP_STRICT_NE:
|
|
case OP_LT:
|
|
case OP_LE:
|
|
case OP_GE:
|
|
case OP_GT:
|
|
case OP_LSH:
|
|
case OP_RSH:
|
|
case OP_URSH:
|
|
case OP_MUL:
|
|
case OP_DIV:
|
|
case OP_MOD:
|
|
$s = $this->parseTree($n->treeNodes[0]) . $n->type . $this->parseTree($n->treeNodes[1]);
|
|
break;
|
|
|
|
case OP_PLUS:
|
|
case OP_MINUS:
|
|
$left = $this->parseTree($n->treeNodes[0]);
|
|
$right = $this->parseTree($n->treeNodes[1]);
|
|
|
|
switch ($n->treeNodes[1]->type) {
|
|
case OP_PLUS:
|
|
case OP_MINUS:
|
|
case OP_INCREMENT:
|
|
case OP_DECREMENT:
|
|
case OP_UNARY_PLUS:
|
|
case OP_UNARY_MINUS:
|
|
$s = $left . $n->type . ' ' . $right;
|
|
break;
|
|
|
|
case TOKEN_STRING:
|
|
//combine concatenated strings with same quote style
|
|
if ($n->type == OP_PLUS && substr($left, -1) == $right[0]) {
|
|
$s = substr($left, 0, -1) . substr($right, 1);
|
|
break;
|
|
}
|
|
// FALL THROUGH
|
|
|
|
default:
|
|
$s = $left . $n->type . $right;
|
|
}
|
|
break;
|
|
|
|
case OP_NOT:
|
|
case OP_BITWISE_NOT:
|
|
case OP_UNARY_PLUS:
|
|
case OP_UNARY_MINUS:
|
|
$s = $n->value . $this->parseTree($n->treeNodes[0]);
|
|
break;
|
|
|
|
case OP_INCREMENT:
|
|
case OP_DECREMENT:
|
|
if ($n->postfix) {
|
|
$s = $this->parseTree($n->treeNodes[0]) . $n->value;
|
|
}
|
|
else {
|
|
$s = $n->value . $this->parseTree($n->treeNodes[0]);
|
|
}
|
|
break;
|
|
|
|
case OP_DOT:
|
|
$s = $this->parseTree($n->treeNodes[0]) . '.' . $this->parseTree($n->treeNodes[1]);
|
|
break;
|
|
|
|
case JS_INDEX:
|
|
$s = $this->parseTree($n->treeNodes[0]);
|
|
// See if we can replace named index with a dot saving 3 bytes
|
|
if ( $n->treeNodes[0]->type == TOKEN_IDENTIFIER &&
|
|
$n->treeNodes[1]->type == TOKEN_STRING &&
|
|
$this->isValidIdentifier(substr($n->treeNodes[1]->value, 1, -1))
|
|
) {
|
|
$s .= '.' . substr($n->treeNodes[1]->value, 1, -1);
|
|
}
|
|
else {
|
|
$s .= '[' . $this->parseTree($n->treeNodes[1]) . ']';
|
|
}
|
|
break;
|
|
|
|
case JS_LIST:
|
|
$childs = $n->treeNodes;
|
|
for ($i = 0, $j = count($childs); $i < $j; $i++) {
|
|
$s .= ($i ? ',' : '') . $this->parseTree($childs[$i]);
|
|
}
|
|
break;
|
|
|
|
case JS_CALL:
|
|
$s = $this->parseTree($n->treeNodes[0]) . '(' . $this->parseTree($n->treeNodes[1]) . ')';
|
|
break;
|
|
|
|
case KEYWORD_NEW:
|
|
case JS_NEW_WITH_ARGS:
|
|
$s = 'new ' . $this->parseTree($n->treeNodes[0]) . '(' . ($n->type == JS_NEW_WITH_ARGS ? $this->parseTree($n->treeNodes[1]) : '') . ')';
|
|
break;
|
|
|
|
case JS_ARRAY_INIT:
|
|
$s = '[';
|
|
$childs = $n->treeNodes;
|
|
for ($i = 0, $j = count($childs); $i < $j; $i++) {
|
|
$s .= ($i ? ',' : '') . $this->parseTree($childs[$i]);
|
|
}
|
|
$s .= ']';
|
|
break;
|
|
|
|
case JS_OBJECT_INIT:
|
|
$s = '{';
|
|
$childs = $n->treeNodes;
|
|
for ($i = 0, $j = count($childs); $i < $j; $i++) {
|
|
$t = $childs[$i];
|
|
if ($i) {
|
|
$s .= ',';
|
|
}
|
|
if ($t->type == JS_PROPERTY_INIT) {
|
|
// Ditch the quotes when the index is a valid identifier
|
|
if ( $t->treeNodes[0]->type == TOKEN_STRING &&
|
|
$this->isValidIdentifier(substr($t->treeNodes[0]->value, 1, -1))
|
|
) {
|
|
$s .= substr($t->treeNodes[0]->value, 1, -1);
|
|
}
|
|
else {
|
|
$s .= $t->treeNodes[0]->value;
|
|
}
|
|
|
|
$s .= ':' . $this->parseTree($t->treeNodes[1]);
|
|
}
|
|
else {
|
|
$s .= $t->type == JS_GETTER ? 'get' : 'set';
|
|
$s .= ' ' . $t->name . '(';
|
|
$params = $t->params;
|
|
for ($i = 0, $j = count($params); $i < $j; $i++) {
|
|
$s .= ($i ? ',' : '') . $params[$i];
|
|
}
|
|
$s .= '){' . $this->parseTree($t->body, true) . '}';
|
|
}
|
|
}
|
|
$s .= '}';
|
|
break;
|
|
|
|
case TOKEN_NUMBER:
|
|
$s = $n->value;
|
|
if (preg_match('/^([1-9]+)(0{3,})$/', $s, $m)) {
|
|
$s = $m[1] . 'e' . strlen($m[2]);
|
|
}
|
|
break;
|
|
|
|
case KEYWORD_NULL:
|
|
case KEYWORD_THIS:
|
|
case KEYWORD_TRUE:
|
|
case KEYWORD_FALSE:
|
|
case TOKEN_IDENTIFIER:
|
|
case TOKEN_STRING:
|
|
case TOKEN_REGEXP:
|
|
$s = $n->value;
|
|
break;
|
|
|
|
case JS_GROUP:
|
|
if (in_array(
|
|
$n->treeNodes[0]->type,
|
|
array(
|
|
JS_ARRAY_INIT,
|
|
JS_OBJECT_INIT,
|
|
JS_GROUP,
|
|
TOKEN_NUMBER,
|
|
TOKEN_STRING,
|
|
TOKEN_REGEXP,
|
|
TOKEN_IDENTIFIER,
|
|
KEYWORD_NULL,
|
|
KEYWORD_THIS,
|
|
KEYWORD_TRUE,
|
|
KEYWORD_FALSE,
|
|
)
|
|
)) {
|
|
$s = $this->parseTree($n->treeNodes[0]);
|
|
}
|
|
else {
|
|
$s = '(' . $this->parseTree($n->treeNodes[0]) . ')';
|
|
}
|
|
break;
|
|
|
|
default:
|
|
throw new Exception('UNKNOWN TOKEN TYPE: ' . $n->type);
|
|
}
|
|
|
|
return $s;
|
|
}
|
|
|
|
private function isValidIdentifier($string) {
|
|
return preg_match('/^[a-zA-Z_][a-zA-Z0-9_]*$/', $string) && !in_array($string, $this->reserved);
|
|
}
|
|
|
|
private function isWordChar($char) {
|
|
return $char == '_' || $char == '$' || ctype_alnum($char);
|
|
}
|
|
}
|
|
|
|
class JSParser {
|
|
private $t;
|
|
private $minifier;
|
|
|
|
private $opPrecedence = array(
|
|
';' => 0,
|
|
',' => 1,
|
|
'=' => 2,
|
|
'?' => 2,
|
|
':' => 2,
|
|
// The above all have to have the same precedence, see bug 330975
|
|
'||' => 4,
|
|
'&&' => 5,
|
|
'|' => 6,
|
|
'^' => 7,
|
|
'&' => 8,
|
|
'==' => 9,
|
|
'!=' => 9,
|
|
'===' => 9,
|
|
'!==' => 9,
|
|
'<' => 10,
|
|
'<=' => 10,
|
|
'>=' => 10,
|
|
'>' => 10,
|
|
'in' => 10,
|
|
'instanceof' => 10,
|
|
'<<' => 11,
|
|
'>>' => 11,
|
|
'>>>' => 11,
|
|
'+' => 12,
|
|
'-' => 12,
|
|
'*' => 13,
|
|
'/' => 13,
|
|
'%' => 13,
|
|
'delete' => 14,
|
|
'void' => 14,
|
|
'typeof' => 14,
|
|
'!' => 14,
|
|
'~' => 14,
|
|
'U+' => 14,
|
|
'U-' => 14,
|
|
'++' => 15,
|
|
'--' => 15,
|
|
'new' => 16,
|
|
'.' => 17,
|
|
JS_NEW_WITH_ARGS => 0,
|
|
JS_INDEX => 0,
|
|
JS_CALL => 0,
|
|
JS_ARRAY_INIT => 0,
|
|
JS_OBJECT_INIT => 0,
|
|
JS_GROUP => 0,
|
|
);
|
|
|
|
private $opArity = array(
|
|
',' => -2,
|
|
'=' => 2,
|
|
'?' => 3,
|
|
'||' => 2,
|
|
'&&' => 2,
|
|
'|' => 2,
|
|
'^' => 2,
|
|
'&' => 2,
|
|
'==' => 2,
|
|
'!=' => 2,
|
|
'===' => 2,
|
|
'!==' => 2,
|
|
'<' => 2,
|
|
'<=' => 2,
|
|
'>=' => 2,
|
|
'>' => 2,
|
|
'in' => 2,
|
|
'instanceof' => 2,
|
|
'<<' => 2,
|
|
'>>' => 2,
|
|
'>>>' => 2,
|
|
'+' => 2,
|
|
'-' => 2,
|
|
'*' => 2,
|
|
'/' => 2,
|
|
'%' => 2,
|
|
'delete' => 1,
|
|
'void' => 1,
|
|
'typeof' => 1,
|
|
'!' => 1,
|
|
'~' => 1,
|
|
'U+' => 1,
|
|
'U-' => 1,
|
|
'++' => 1,
|
|
'--' => 1,
|
|
'new' => 1,
|
|
'.' => 2,
|
|
JS_NEW_WITH_ARGS => 2,
|
|
JS_INDEX => 2,
|
|
JS_CALL => 2,
|
|
JS_ARRAY_INIT => 1,
|
|
JS_OBJECT_INIT => 1,
|
|
JS_GROUP => 1,
|
|
TOKEN_CONDCOMMENT_START => 1,
|
|
TOKEN_CONDCOMMENT_END => 1,
|
|
);
|
|
|
|
public function __construct($minifier = null) {
|
|
$this->minifier = $minifier;
|
|
$this->t = new JSTokenizer();
|
|
}
|
|
|
|
public function parse($s, $f, $l) {
|
|
// initialize tokenizer
|
|
$this->t->init($s, $f, $l);
|
|
|
|
$x = new JSCompilerContext(false);
|
|
$n = $this->Script($x);
|
|
if (!$this->t->isDone()) {
|
|
throw $this->t->newSyntaxError('Syntax error');
|
|
}
|
|
|
|
return $n;
|
|
}
|
|
|
|
private function Script($x) {
|
|
$n = $this->Statements($x);
|
|
$n->type = JS_SCRIPT;
|
|
$n->funDecls = $x->funDecls;
|
|
$n->varDecls = $x->varDecls;
|
|
|
|
// minify by scope
|
|
if ($this->minifier) {
|
|
$n->value = $this->minifier->parseTree($n);
|
|
|
|
// clear tree from node to save memory
|
|
$n->treeNodes = null;
|
|
$n->funDecls = null;
|
|
$n->varDecls = null;
|
|
|
|
$n->type = JS_MINIFIED;
|
|
}
|
|
|
|
return $n;
|
|
}
|
|
|
|
private function Statements($x) {
|
|
$n = new JSNode($this->t, JS_BLOCK);
|
|
array_push($x->stmtStack, $n);
|
|
|
|
while (!$this->t->isDone() && $this->t->peek() != OP_RIGHT_CURLY) {
|
|
$n->addNode($this->Statement($x));
|
|
}
|
|
|
|
array_pop($x->stmtStack);
|
|
|
|
return $n;
|
|
}
|
|
|
|
private function Block($x) {
|
|
$this->t->mustMatch(OP_LEFT_CURLY);
|
|
$n = $this->Statements($x);
|
|
$this->t->mustMatch(OP_RIGHT_CURLY);
|
|
|
|
return $n;
|
|
}
|
|
|
|
private function Statement($x) {
|
|
$tt = $this->t->get();
|
|
$n2 = null;
|
|
|
|
// Cases for statements ending in a right curly return early, avoiding the
|
|
// common semicolon insertion magic after this switch.
|
|
switch ($tt) {
|
|
case KEYWORD_FUNCTION:
|
|
return $this->FunctionDefinition(
|
|
$x,
|
|
true,
|
|
count($x->stmtStack) > 1 ? STATEMENT_FORM : DECLARED_FORM
|
|
);
|
|
break;
|
|
|
|
case OP_LEFT_CURLY:
|
|
$n = $this->Statements($x);
|
|
$this->t->mustMatch(OP_RIGHT_CURLY);
|
|
return $n;
|
|
|
|
case KEYWORD_IF:
|
|
$n = new JSNode($this->t);
|
|
$n->condition = $this->ParenExpression($x);
|
|
array_push($x->stmtStack, $n);
|
|
$n->thenPart = $this->Statement($x);
|
|
$n->elsePart = $this->t->match(KEYWORD_ELSE) ? $this->Statement($x) : null;
|
|
array_pop($x->stmtStack);
|
|
return $n;
|
|
|
|
case KEYWORD_SWITCH:
|
|
$n = new JSNode($this->t);
|
|
$this->t->mustMatch(OP_LEFT_PAREN);
|
|
$n->discriminant = $this->Expression($x);
|
|
$this->t->mustMatch(OP_RIGHT_PAREN);
|
|
$n->cases = array();
|
|
$n->defaultIndex = -1;
|
|
|
|
array_push($x->stmtStack, $n);
|
|
|
|
$this->t->mustMatch(OP_LEFT_CURLY);
|
|
|
|
while (($tt = $this->t->get()) != OP_RIGHT_CURLY) {
|
|
switch ($tt) {
|
|
case KEYWORD_DEFAULT:
|
|
if ($n->defaultIndex >= 0) {
|
|
throw $this->t->newSyntaxError('More than one switch default');
|
|
}
|
|
// FALL THROUGH
|
|
case KEYWORD_CASE:
|
|
$n2 = new JSNode($this->t);
|
|
if ($tt == KEYWORD_DEFAULT) {
|
|
$n->defaultIndex = count($n->cases);
|
|
}
|
|
else {
|
|
$n2->caseLabel = $this->Expression($x, OP_COLON);
|
|
}
|
|
break;
|
|
default:
|
|
throw $this->t->newSyntaxError('Invalid switch case');
|
|
}
|
|
|
|
$this->t->mustMatch(OP_COLON);
|
|
$n2->statements = new JSNode($this->t, JS_BLOCK);
|
|
while (($tt = $this->t->peek()) != KEYWORD_CASE && $tt != KEYWORD_DEFAULT && $tt != OP_RIGHT_CURLY) {
|
|
$n2->statements->addNode($this->Statement($x));
|
|
}
|
|
|
|
array_push($n->cases, $n2);
|
|
}
|
|
|
|
array_pop($x->stmtStack);
|
|
return $n;
|
|
|
|
case KEYWORD_FOR:
|
|
$n = new JSNode($this->t);
|
|
$n->isLoop = true;
|
|
$this->t->mustMatch(OP_LEFT_PAREN);
|
|
|
|
if (($tt = $this->t->peek()) != OP_SEMICOLON) {
|
|
$x->inForLoopInit = true;
|
|
if ($tt == KEYWORD_VAR || $tt == KEYWORD_CONST) {
|
|
$this->t->get();
|
|
$n2 = $this->Variables($x);
|
|
}
|
|
else {
|
|
$n2 = $this->Expression($x);
|
|
}
|
|
$x->inForLoopInit = false;
|
|
}
|
|
|
|
if ($n2 && $this->t->match(KEYWORD_IN)) {
|
|
$n->type = JS_FOR_IN;
|
|
if ($n2->type == KEYWORD_VAR) {
|
|
if (count($n2->treeNodes) != 1) {
|
|
throw $this->t->SyntaxError(
|
|
'Invalid for..in left-hand side',
|
|
$this->t->filename,
|
|
$n2->lineno
|
|
);
|
|
}
|
|
|
|
// NB: n2[0].type == IDENTIFIER and n2[0].value == n2[0].name.
|
|
$n->iterator = $n2->treeNodes[0];
|
|
$n->varDecl = $n2;
|
|
}
|
|
else {
|
|
$n->iterator = $n2;
|
|
$n->varDecl = null;
|
|
}
|
|
|
|
$n->object = $this->Expression($x);
|
|
}
|
|
else {
|
|
$n->setup = $n2 ? $n2 : null;
|
|
$this->t->mustMatch(OP_SEMICOLON);
|
|
$n->condition = $this->t->peek() == OP_SEMICOLON ? null : $this->Expression($x);
|
|
$this->t->mustMatch(OP_SEMICOLON);
|
|
$n->update = $this->t->peek() == OP_RIGHT_PAREN ? null : $this->Expression($x);
|
|
}
|
|
|
|
$this->t->mustMatch(OP_RIGHT_PAREN);
|
|
$n->body = $this->nest($x, $n);
|
|
return $n;
|
|
|
|
case KEYWORD_WHILE:
|
|
$n = new JSNode($this->t);
|
|
$n->isLoop = true;
|
|
$n->condition = $this->ParenExpression($x);
|
|
$n->body = $this->nest($x, $n);
|
|
return $n;
|
|
|
|
case KEYWORD_DO:
|
|
$n = new JSNode($this->t);
|
|
$n->isLoop = true;
|
|
$n->body = $this->nest($x, $n, KEYWORD_WHILE);
|
|
$n->condition = $this->ParenExpression($x);
|
|
if (!$x->ecmaStrictMode) {
|
|
// <script language="JavaScript"> (without version hints) may need
|
|
// automatic semicolon insertion without a newline after do-while.
|
|
// See http://bugzilla.mozilla.org/show_bug.cgi?id=238945.
|
|
$this->t->match(OP_SEMICOLON);
|
|
return $n;
|
|
}
|
|
break;
|
|
|
|
case KEYWORD_BREAK:
|
|
case KEYWORD_CONTINUE:
|
|
$n = new JSNode($this->t);
|
|
|
|
if ($this->t->peekOnSameLine() == TOKEN_IDENTIFIER) {
|
|
$this->t->get();
|
|
$n->label = $this->t->currentToken()->value;
|
|
}
|
|
|
|
$ss = $x->stmtStack;
|
|
$i = count($ss);
|
|
$label = $n->label;
|
|
if ($label) {
|
|
do {
|
|
if (--$i < 0) {
|
|
throw $this->t->newSyntaxError('Label not found');
|
|
}
|
|
} while ($ss[$i]->label != $label);
|
|
}
|
|
else {
|
|
do {
|
|
if (--$i < 0) {
|
|
throw $this->t->newSyntaxError('Invalid ' . $tt);
|
|
}
|
|
} while (!$ss[$i]->isLoop && ($tt != KEYWORD_BREAK || $ss[$i]->type != KEYWORD_SWITCH));
|
|
}
|
|
|
|
$n->target = $ss[$i];
|
|
break;
|
|
|
|
case KEYWORD_TRY:
|
|
$n = new JSNode($this->t);
|
|
$n->tryBlock = $this->Block($x);
|
|
$n->catchClauses = array();
|
|
|
|
while ($this->t->match(KEYWORD_CATCH)) {
|
|
$n2 = new JSNode($this->t);
|
|
$this->t->mustMatch(OP_LEFT_PAREN);
|
|
$n2->varName = $this->t->mustMatch(TOKEN_IDENTIFIER)->value;
|
|
|
|
if ($this->t->match(KEYWORD_IF)) {
|
|
if ($x->ecmaStrictMode) {
|
|
throw $this->t->newSyntaxError('Illegal catch guard');
|
|
}
|
|
|
|
if (count($n->catchClauses) && !end($n->catchClauses)->guard) {
|
|
throw $this->t->newSyntaxError('Guarded catch after unguarded');
|
|
}
|
|
|
|
$n2->guard = $this->Expression($x);
|
|
}
|
|
else {
|
|
$n2->guard = null;
|
|
}
|
|
|
|
$this->t->mustMatch(OP_RIGHT_PAREN);
|
|
$n2->block = $this->Block($x);
|
|
array_push($n->catchClauses, $n2);
|
|
}
|
|
|
|
if ($this->t->match(KEYWORD_FINALLY)) {
|
|
$n->finallyBlock = $this->Block($x);
|
|
}
|
|
|
|
if (!count($n->catchClauses) && !$n->finallyBlock) {
|
|
throw $this->t->newSyntaxError('Invalid try statement');
|
|
}
|
|
return $n;
|
|
|
|
case KEYWORD_CATCH:
|
|
case KEYWORD_FINALLY:
|
|
throw $this->t->newSyntaxError($tt . ' without preceding try');
|
|
|
|
case KEYWORD_THROW:
|
|
$n = new JSNode($this->t);
|
|
$n->value = $this->Expression($x);
|
|
break;
|
|
|
|
case KEYWORD_RETURN:
|
|
if (!$x->inFunction) {
|
|
throw $this->t->newSyntaxError('Invalid return');
|
|
}
|
|
|
|
$n = new JSNode($this->t);
|
|
$tt = $this->t->peekOnSameLine();
|
|
if ($tt != TOKEN_END && $tt != TOKEN_NEWLINE && $tt != OP_SEMICOLON && $tt != OP_RIGHT_CURLY) {
|
|
$n->value = $this->Expression($x);
|
|
}
|
|
else {
|
|
$n->value = null;
|
|
}
|
|
break;
|
|
|
|
case KEYWORD_WITH:
|
|
$n = new JSNode($this->t);
|
|
$n->object = $this->ParenExpression($x);
|
|
$n->body = $this->nest($x, $n);
|
|
return $n;
|
|
|
|
case KEYWORD_VAR:
|
|
case KEYWORD_CONST:
|
|
$n = $this->Variables($x);
|
|
break;
|
|
|
|
case TOKEN_CONDCOMMENT_START:
|
|
case TOKEN_CONDCOMMENT_END:
|
|
$n = new JSNode($this->t);
|
|
return $n;
|
|
|
|
case KEYWORD_DEBUGGER:
|
|
$n = new JSNode($this->t);
|
|
break;
|
|
|
|
case TOKEN_NEWLINE:
|
|
case OP_SEMICOLON:
|
|
$n = new JSNode($this->t, OP_SEMICOLON);
|
|
$n->expression = null;
|
|
return $n;
|
|
|
|
default:
|
|
if ($tt == TOKEN_IDENTIFIER) {
|
|
$this->t->scanOperand = false;
|
|
$tt = $this->t->peek();
|
|
$this->t->scanOperand = true;
|
|
if ($tt == OP_COLON) {
|
|
$label = $this->t->currentToken()->value;
|
|
$ss = $x->stmtStack;
|
|
for ($i = count($ss) - 1; $i >= 0; --$i) {
|
|
if ($ss[$i]->label == $label) {
|
|
throw $this->t->newSyntaxError('Duplicate label');
|
|
}
|
|
}
|
|
|
|
$this->t->get();
|
|
$n = new JSNode($this->t, JS_LABEL);
|
|
$n->label = $label;
|
|
$n->statement = $this->nest($x, $n);
|
|
|
|
return $n;
|
|
}
|
|
}
|
|
|
|
$n = new JSNode($this->t, OP_SEMICOLON);
|
|
$this->t->unget();
|
|
$n->expression = $this->Expression($x);
|
|
$n->end = $n->expression->end;
|
|
break;
|
|
}
|
|
|
|
if ($this->t->lineno == $this->t->currentToken()->lineno) {
|
|
$tt = $this->t->peekOnSameLine();
|
|
if ($tt != TOKEN_END && $tt != TOKEN_NEWLINE && $tt != OP_SEMICOLON && $tt != OP_RIGHT_CURLY) {
|
|
throw $this->t->newSyntaxError('Missing ; before statement');
|
|
}
|
|
}
|
|
|
|
$this->t->match(OP_SEMICOLON);
|
|
|
|
return $n;
|
|
}
|
|
|
|
private function FunctionDefinition($x, $requireName, $functionForm) {
|
|
$f = new JSNode($this->t);
|
|
|
|
if ($f->type != KEYWORD_FUNCTION) {
|
|
$f->type = ($f->value == 'get') ? JS_GETTER : JS_SETTER;
|
|
}
|
|
|
|
if ($this->t->match(TOKEN_IDENTIFIER)) {
|
|
$f->name = $this->t->currentToken()->value;
|
|
}
|
|
elseif ($requireName) {
|
|
throw $this->t->newSyntaxError('Missing function identifier');
|
|
}
|
|
|
|
$this->t->mustMatch(OP_LEFT_PAREN);
|
|
$f->params = array();
|
|
|
|
while (($tt = $this->t->get()) != OP_RIGHT_PAREN) {
|
|
if ($tt != TOKEN_IDENTIFIER) {
|
|
throw $this->t->newSyntaxError('Missing formal parameter');
|
|
}
|
|
|
|
array_push($f->params, $this->t->currentToken()->value);
|
|
|
|
if ($this->t->peek() != OP_RIGHT_PAREN) {
|
|
$this->t->mustMatch(OP_COMMA);
|
|
}
|
|
}
|
|
|
|
$this->t->mustMatch(OP_LEFT_CURLY);
|
|
|
|
$x2 = new JSCompilerContext(true);
|
|
$f->body = $this->Script($x2);
|
|
|
|
$this->t->mustMatch(OP_RIGHT_CURLY);
|
|
$f->end = $this->t->currentToken()->end;
|
|
|
|
$f->functionForm = $functionForm;
|
|
if ($functionForm == DECLARED_FORM) {
|
|
array_push($x->funDecls, $f);
|
|
}
|
|
|
|
return $f;
|
|
}
|
|
|
|
private function Variables($x) {
|
|
$n = new JSNode($this->t);
|
|
|
|
do {
|
|
$this->t->mustMatch(TOKEN_IDENTIFIER);
|
|
|
|
$n2 = new JSNode($this->t);
|
|
$n2->name = $n2->value;
|
|
|
|
if ($this->t->match(OP_ASSIGN)) {
|
|
if ($this->t->currentToken()->assignOp) {
|
|
throw $this->t->newSyntaxError('Invalid variable initialization');
|
|
}
|
|
|
|
$n2->initializer = $this->Expression($x, OP_COMMA);
|
|
}
|
|
|
|
$n2->readOnly = $n->type == KEYWORD_CONST;
|
|
|
|
$n->addNode($n2);
|
|
array_push($x->varDecls, $n2);
|
|
} while ($this->t->match(OP_COMMA));
|
|
|
|
return $n;
|
|
}
|
|
|
|
private function Expression($x, $stop = false) {
|
|
$operators = array();
|
|
$operands = array();
|
|
$n = false;
|
|
|
|
$bl = $x->bracketLevel;
|
|
$cl = $x->curlyLevel;
|
|
$pl = $x->parenLevel;
|
|
$hl = $x->hookLevel;
|
|
|
|
while (($tt = $this->t->get()) != TOKEN_END) {
|
|
if ($tt == $stop &&
|
|
$x->bracketLevel == $bl &&
|
|
$x->curlyLevel == $cl &&
|
|
$x->parenLevel == $pl &&
|
|
$x->hookLevel == $hl
|
|
) {
|
|
// Stop only if tt matches the optional stop parameter, and that
|
|
// token is not quoted by some kind of bracket.
|
|
break;
|
|
}
|
|
|
|
switch ($tt) {
|
|
case OP_SEMICOLON:
|
|
// NB: cannot be empty, Statement handled that.
|
|
break 2;
|
|
|
|
case OP_HOOK:
|
|
if ($this->t->scanOperand) {
|
|
break 2;
|
|
}
|
|
|
|
while ( !empty($operators) &&
|
|
$this->opPrecedence[end($operators)->type] > $this->opPrecedence[$tt]
|
|
) {
|
|
$this->reduce($operators, $operands);
|
|
}
|
|
|
|
array_push($operators, new JSNode($this->t));
|
|
|
|
++$x->hookLevel;
|
|
$this->t->scanOperand = true;
|
|
$n = $this->Expression($x);
|
|
|
|
if (!$this->t->match(OP_COLON)) {
|
|
break 2;
|
|
}
|
|
|
|
--$x->hookLevel;
|
|
array_push($operands, $n);
|
|
break;
|
|
|
|
case OP_COLON:
|
|
if ($x->hookLevel) {
|
|
break 2;
|
|
}
|
|
|
|
throw $this->t->newSyntaxError('Invalid label');
|
|
break;
|
|
|
|
case OP_ASSIGN:
|
|
if ($this->t->scanOperand) {
|
|
break 2;
|
|
}
|
|
|
|
// Use >, not >=, for right-associative ASSIGN
|
|
while ( !empty($operators) &&
|
|
$this->opPrecedence[end($operators)->type] > $this->opPrecedence[$tt]
|
|
) {
|
|
$this->reduce($operators, $operands);
|
|
}
|
|
|
|
array_push($operators, new JSNode($this->t));
|
|
end($operands)->assignOp = $this->t->currentToken()->assignOp;
|
|
$this->t->scanOperand = true;
|
|
break;
|
|
|
|
case KEYWORD_IN:
|
|
// An in operator should not be parsed if we're parsing the head of
|
|
// a for (...) loop, unless it is in the then part of a conditional
|
|
// expression, or parenthesized somehow.
|
|
if ($x->inForLoopInit && !$x->hookLevel &&
|
|
!$x->bracketLevel && !$x->curlyLevel &&
|
|
!$x->parenLevel
|
|
) {
|
|
break 2;
|
|
}
|
|
// FALL THROUGH
|
|
case OP_COMMA:
|
|
// A comma operator should not be parsed if we're parsing the then part
|
|
// of a conditional expression unless it's parenthesized somehow.
|
|
if ($tt == OP_COMMA && $x->hookLevel &&
|
|
!$x->bracketLevel && !$x->curlyLevel &&
|
|
!$x->parenLevel
|
|
) {
|
|
break 2;
|
|
}
|
|
// Treat comma as left-associative so reduce can fold left-heavy
|
|
// COMMA trees into a single array.
|
|
// FALL THROUGH
|
|
case OP_OR:
|
|
case OP_AND:
|
|
case OP_BITWISE_OR:
|
|
case OP_BITWISE_XOR:
|
|
case OP_BITWISE_AND:
|
|
case OP_EQ:
|
|
case OP_NE:
|
|
case OP_STRICT_EQ:
|
|
case OP_STRICT_NE:
|
|
case OP_LT:
|
|
case OP_LE:
|
|
case OP_GE:
|
|
case OP_GT:
|
|
case KEYWORD_INSTANCEOF:
|
|
case OP_LSH:
|
|
case OP_RSH:
|
|
case OP_URSH:
|
|
case OP_PLUS:
|
|
case OP_MINUS:
|
|
case OP_MUL:
|
|
case OP_DIV:
|
|
case OP_MOD:
|
|
case OP_DOT:
|
|
if ($this->t->scanOperand) {
|
|
break 2;
|
|
}
|
|
|
|
while ( !empty($operators) &&
|
|
$this->opPrecedence[end($operators)->type] >= $this->opPrecedence[$tt]
|
|
) {
|
|
$this->reduce($operators, $operands);
|
|
}
|
|
|
|
if ($tt == OP_DOT) {
|
|
$this->t->mustMatch(TOKEN_IDENTIFIER, true);
|
|
array_push($operands, new JSNode($this->t, OP_DOT, array_pop($operands), new JSNode($this->t)));
|
|
}
|
|
else {
|
|
array_push($operators, new JSNode($this->t));
|
|
$this->t->scanOperand = true;
|
|
}
|
|
break;
|
|
|
|
case KEYWORD_DELETE:
|
|
case KEYWORD_VOID:
|
|
case KEYWORD_TYPEOF:
|
|
case OP_NOT:
|
|
case OP_BITWISE_NOT:
|
|
case OP_UNARY_PLUS:
|
|
case OP_UNARY_MINUS:
|
|
case KEYWORD_NEW:
|
|
if (!$this->t->scanOperand) {
|
|
break 2;
|
|
}
|
|
|
|
array_push($operators, new JSNode($this->t));
|
|
break;
|
|
|
|
case OP_INCREMENT:
|
|
case OP_DECREMENT:
|
|
if ($this->t->scanOperand) {
|
|
array_push($operators, new JSNode($this->t)); // prefix increment or decrement
|
|
}
|
|
else {
|
|
// Don't cross a line boundary for postfix {in,de}crement.
|
|
$t = $this->t->tokens[($this->t->tokenIndex + $this->t->lookahead - 1) & 3];
|
|
if ($t && $t->lineno != $this->t->lineno) {
|
|
break 2;
|
|
}
|
|
|
|
if (!empty($operators)) {
|
|
// Use >, not >=, so postfix has higher precedence than prefix.
|
|
while ($this->opPrecedence[end($operators)->type] > $this->opPrecedence[$tt]) {
|
|
$this->reduce($operators, $operands);
|
|
}
|
|
}
|
|
|
|
$n = new JSNode($this->t, $tt, array_pop($operands));
|
|
$n->postfix = true;
|
|
array_push($operands, $n);
|
|
}
|
|
break;
|
|
|
|
case KEYWORD_FUNCTION:
|
|
if (!$this->t->scanOperand) {
|
|
break 2;
|
|
}
|
|
|
|
array_push($operands, $this->FunctionDefinition($x, false, EXPRESSED_FORM));
|
|
$this->t->scanOperand = false;
|
|
break;
|
|
|
|
case KEYWORD_NULL:
|
|
case KEYWORD_THIS:
|
|
case KEYWORD_TRUE:
|
|
case KEYWORD_FALSE:
|
|
case TOKEN_IDENTIFIER:
|
|
case TOKEN_NUMBER:
|
|
case TOKEN_STRING:
|
|
case TOKEN_REGEXP:
|
|
if (!$this->t->scanOperand) {
|
|
break 2;
|
|
}
|
|
|
|
array_push($operands, new JSNode($this->t));
|
|
$this->t->scanOperand = false;
|
|
break;
|
|
|
|
case TOKEN_CONDCOMMENT_START:
|
|
case TOKEN_CONDCOMMENT_END:
|
|
if ($this->t->scanOperand) {
|
|
array_push($operators, new JSNode($this->t));
|
|
}
|
|
else {
|
|
array_push($operands, new JSNode($this->t));
|
|
}
|
|
break;
|
|
|
|
case OP_LEFT_BRACKET:
|
|
if ($this->t->scanOperand) {
|
|
// Array initialiser. Parse using recursive descent, as the
|
|
// sub-grammar here is not an operator grammar.
|
|
$n = new JSNode($this->t, JS_ARRAY_INIT);
|
|
while (($tt = $this->t->peek()) != OP_RIGHT_BRACKET) {
|
|
if ($tt == OP_COMMA) {
|
|
$this->t->get();
|
|
$n->addNode(null);
|
|
continue;
|
|
}
|
|
|
|
$n->addNode($this->Expression($x, OP_COMMA));
|
|
if (!$this->t->match(OP_COMMA)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
$this->t->mustMatch(OP_RIGHT_BRACKET);
|
|
array_push($operands, $n);
|
|
$this->t->scanOperand = false;
|
|
}
|
|
else {
|
|
// Property indexing operator.
|
|
array_push($operators, new JSNode($this->t, JS_INDEX));
|
|
$this->t->scanOperand = true;
|
|
++$x->bracketLevel;
|
|
}
|
|
break;
|
|
|
|
case OP_RIGHT_BRACKET:
|
|
if ($this->t->scanOperand || $x->bracketLevel == $bl) {
|
|
break 2;
|
|
}
|
|
|
|
while ($this->reduce($operators, $operands)->type != JS_INDEX) {
|
|
continue;
|
|
}
|
|
|
|
--$x->bracketLevel;
|
|
break;
|
|
|
|
case OP_LEFT_CURLY:
|
|
if (!$this->t->scanOperand) {
|
|
break 2;
|
|
}
|
|
|
|
// Object initialiser. As for array initialisers (see above),
|
|
// parse using recursive descent.
|
|
++$x->curlyLevel;
|
|
$n = new JSNode($this->t, JS_OBJECT_INIT);
|
|
while (!$this->t->match(OP_RIGHT_CURLY)) {
|
|
do {
|
|
$tt = $this->t->get();
|
|
$tv = $this->t->currentToken()->value;
|
|
if (($tv == 'get' || $tv == 'set') && $this->t->peek() == TOKEN_IDENTIFIER) {
|
|
if ($x->ecmaStrictMode) {
|
|
throw $this->t->newSyntaxError('Illegal property accessor');
|
|
}
|
|
|
|
$n->addNode($this->FunctionDefinition($x, true, EXPRESSED_FORM));
|
|
}
|
|
else {
|
|
switch ($tt) {
|
|
case TOKEN_IDENTIFIER:
|
|
case TOKEN_NUMBER:
|
|
case TOKEN_STRING:
|
|
$id = new JSNode($this->t);
|
|
break;
|
|
|
|
case OP_RIGHT_CURLY:
|
|
if ($x->ecmaStrictMode) {
|
|
throw $this->t->newSyntaxError('Illegal trailing ,');
|
|
}
|
|
break 3;
|
|
|
|
default:
|
|
throw $this->t->newSyntaxError('Invalid property name');
|
|
}
|
|
|
|
$this->t->mustMatch(OP_COLON);
|
|
$n->addNode(new JSNode($this->t, JS_PROPERTY_INIT, $id, $this->Expression($x, OP_COMMA)));
|
|
}
|
|
} while ($this->t->match(OP_COMMA));
|
|
|
|
$this->t->mustMatch(OP_RIGHT_CURLY);
|
|
break;
|
|
}
|
|
|
|
array_push($operands, $n);
|
|
$this->t->scanOperand = false;
|
|
--$x->curlyLevel;
|
|
break;
|
|
|
|
case OP_RIGHT_CURLY:
|
|
if (!$this->t->scanOperand && $x->curlyLevel != $cl) {
|
|
throw new Exception('PANIC: right curly botch');
|
|
}
|
|
break 2;
|
|
|
|
case OP_LEFT_PAREN:
|
|
if ($this->t->scanOperand) {
|
|
array_push($operators, new JSNode($this->t, JS_GROUP));
|
|
}
|
|
else {
|
|
while ( !empty($operators) &&
|
|
$this->opPrecedence[end($operators)->type] > $this->opPrecedence[KEYWORD_NEW]
|
|
) {
|
|
$this->reduce($operators, $operands);
|
|
}
|
|
|
|
// Handle () now, to regularize the n-ary case for n > 0.
|
|
// We must set scanOperand in case there are arguments and
|
|
// the first one is a regexp or unary+/-.
|
|
$n = end($operators);
|
|
$this->t->scanOperand = true;
|
|
if ($this->t->match(OP_RIGHT_PAREN)) {
|
|
if ($n && $n->type == KEYWORD_NEW) {
|
|
array_pop($operators);
|
|
$n->addNode(array_pop($operands));
|
|
}
|
|
else {
|
|
$n = new JSNode($this->t, JS_CALL, array_pop($operands), new JSNode($this->t, JS_LIST));
|
|
}
|
|
|
|
array_push($operands, $n);
|
|
$this->t->scanOperand = false;
|
|
break;
|
|
}
|
|
|
|
if ($n && $n->type == KEYWORD_NEW) {
|
|
$n->type = JS_NEW_WITH_ARGS;
|
|
}
|
|
else {
|
|
array_push($operators, new JSNode($this->t, JS_CALL));
|
|
}
|
|
}
|
|
|
|
++$x->parenLevel;
|
|
break;
|
|
|
|
case OP_RIGHT_PAREN:
|
|
if ($this->t->scanOperand || $x->parenLevel == $pl) {
|
|
break 2;
|
|
}
|
|
|
|
while (($tt = $this->reduce($operators, $operands)->type) != JS_GROUP &&
|
|
$tt != JS_CALL && $tt != JS_NEW_WITH_ARGS
|
|
) {
|
|
continue;
|
|
}
|
|
|
|
if ($tt != JS_GROUP) {
|
|
$n = end($operands);
|
|
if ($n->treeNodes[1]->type != OP_COMMA) {
|
|
$n->treeNodes[1] = new JSNode($this->t, JS_LIST, $n->treeNodes[1]);
|
|
}
|
|
else {
|
|
$n->treeNodes[1]->type = JS_LIST;
|
|
}
|
|
}
|
|
|
|
--$x->parenLevel;
|
|
break;
|
|
|
|
// Automatic semicolon insertion means we may scan across a newline
|
|
// and into the beginning of another statement. If so, break out of
|
|
// the while loop and let the t.scanOperand logic handle errors.
|
|
default:
|
|
break 2;
|
|
}
|
|
}
|
|
|
|
if ($x->hookLevel != $hl) {
|
|
throw $this->t->newSyntaxError('Missing : in conditional expression');
|
|
}
|
|
|
|
if ($x->parenLevel != $pl) {
|
|
throw $this->t->newSyntaxError('Missing ) in parenthetical');
|
|
}
|
|
|
|
if ($x->bracketLevel != $bl) {
|
|
throw $this->t->newSyntaxError('Missing ] in index expression');
|
|
}
|
|
|
|
if ($this->t->scanOperand) {
|
|
throw $this->t->newSyntaxError('Missing operand');
|
|
}
|
|
|
|
// Resume default mode, scanning for operands, not operators.
|
|
$this->t->scanOperand = true;
|
|
$this->t->unget();
|
|
|
|
while (count($operators)) {
|
|
$this->reduce($operators, $operands);
|
|
}
|
|
|
|
return array_pop($operands);
|
|
}
|
|
|
|
private function ParenExpression($x) {
|
|
$this->t->mustMatch(OP_LEFT_PAREN);
|
|
$n = $this->Expression($x);
|
|
$this->t->mustMatch(OP_RIGHT_PAREN);
|
|
|
|
return $n;
|
|
}
|
|
|
|
// Statement stack and nested statement handler.
|
|
private function nest($x, $node, $end = false) {
|
|
array_push($x->stmtStack, $node);
|
|
$n = $this->statement($x);
|
|
array_pop($x->stmtStack);
|
|
|
|
if ($end) {
|
|
$this->t->mustMatch($end);
|
|
}
|
|
|
|
return $n;
|
|
}
|
|
|
|
private function reduce(&$operators, &$operands) {
|
|
$n = array_pop($operators);
|
|
$op = $n->type;
|
|
$arity = $this->opArity[$op];
|
|
$c = count($operands);
|
|
if ($arity == -2) {
|
|
// Flatten left-associative trees
|
|
if ($c >= 2) {
|
|
$left = $operands[$c - 2];
|
|
if ($left->type == $op) {
|
|
$right = array_pop($operands);
|
|
$left->addNode($right);
|
|
return $left;
|
|
}
|
|
}
|
|
$arity = 2;
|
|
}
|
|
|
|
// Always use push to add operands to n, to update start and end
|
|
$a = array_splice($operands, $c - $arity);
|
|
for ($i = 0; $i < $arity; $i++) {
|
|
$n->addNode($a[$i]);
|
|
}
|
|
|
|
// Include closing bracket or postfix operator in [start,end]
|
|
$te = $this->t->currentToken()->end;
|
|
if ($n->end < $te) {
|
|
$n->end = $te;
|
|
}
|
|
|
|
array_push($operands, $n);
|
|
|
|
return $n;
|
|
}
|
|
}
|
|
|
|
class JSCompilerContext {
|
|
public $inFunction = false;
|
|
public $inForLoopInit = false;
|
|
public $ecmaStrictMode = false;
|
|
public $bracketLevel = 0;
|
|
public $curlyLevel = 0;
|
|
public $parenLevel = 0;
|
|
public $hookLevel = 0;
|
|
|
|
public $stmtStack = array();
|
|
public $funDecls = array();
|
|
public $varDecls = array();
|
|
|
|
public function __construct($inFunction) {
|
|
$this->inFunction = $inFunction;
|
|
}
|
|
}
|
|
|
|
class JSNode {
|
|
private $type;
|
|
private $value;
|
|
private $lineno;
|
|
private $start;
|
|
private $end;
|
|
|
|
public $treeNodes = array();
|
|
public $funDecls = array();
|
|
public $varDecls = array();
|
|
|
|
public function __construct($t, $type = 0) {
|
|
if ($token = $t->currentToken()) {
|
|
$this->type = $type ? $type : $token->type;
|
|
$this->value = $token->value;
|
|
$this->lineno = $token->lineno;
|
|
$this->start = $token->start;
|
|
$this->end = $token->end;
|
|
}
|
|
else {
|
|
$this->type = $type;
|
|
$this->lineno = $t->lineno;
|
|
}
|
|
|
|
if (($numargs = func_num_args()) > 2) {
|
|
$args = func_get_args();
|
|
for ($i = 2; $i < $numargs; $i++) {
|
|
$this->addNode($args[$i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// we don't want to bloat our object with all kind of specific properties, so we use overloading
|
|
public function __set($name, $value) {
|
|
$this->$name = $value;
|
|
}
|
|
|
|
public function __get($name) {
|
|
if (isset($this->$name)) {
|
|
return $this->$name;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public function addNode($node) {
|
|
if ($node !== null) {
|
|
if ($node->start < $this->start) {
|
|
$this->start = $node->start;
|
|
}
|
|
if ($this->end < $node->end) {
|
|
$this->end = $node->end;
|
|
}
|
|
}
|
|
|
|
$this->treeNodes[] = $node;
|
|
}
|
|
}
|
|
|
|
class JSTokenizer {
|
|
private $cursor = 0;
|
|
private $source;
|
|
|
|
public $tokens = array();
|
|
public $tokenIndex = 0;
|
|
public $lookahead = 0;
|
|
public $scanNewlines = false;
|
|
public $scanOperand = true;
|
|
|
|
public $filename;
|
|
public $lineno;
|
|
|
|
private $keywords = array(
|
|
'break',
|
|
'case',
|
|
'catch',
|
|
'const',
|
|
'continue',
|
|
'debugger',
|
|
'default',
|
|
'delete',
|
|
'do',
|
|
'else',
|
|
'enum',
|
|
'false',
|
|
'finally',
|
|
'for',
|
|
'function',
|
|
'if',
|
|
'in',
|
|
'instanceof',
|
|
'new',
|
|
'null',
|
|
'return',
|
|
'switch',
|
|
'this',
|
|
'throw',
|
|
'true',
|
|
'try',
|
|
'typeof',
|
|
'var',
|
|
'void',
|
|
'while',
|
|
'with',
|
|
);
|
|
|
|
private $opTypeNames = array(
|
|
';',
|
|
',',
|
|
'?',
|
|
':',
|
|
'||',
|
|
'&&',
|
|
'|',
|
|
'^',
|
|
'&',
|
|
'===',
|
|
'==',
|
|
'=',
|
|
'!==',
|
|
'!=',
|
|
'<<',
|
|
'<=',
|
|
'<',
|
|
'>>>',
|
|
'>>',
|
|
'>=',
|
|
'>',
|
|
'++',
|
|
'--',
|
|
'+',
|
|
'-',
|
|
'*',
|
|
'/',
|
|
'%',
|
|
'!',
|
|
'~',
|
|
'.',
|
|
'[',
|
|
']',
|
|
'{',
|
|
'}',
|
|
'(',
|
|
')',
|
|
'@*/',
|
|
);
|
|
|
|
private $assignOps = array('|', '^', '&', '<<', '>>', '>>>', '+', '-', '*', '/', '%');
|
|
private $opRegExp;
|
|
|
|
public function __construct() {
|
|
$this->opRegExp = '#^(' . implode('|', array_map('preg_quote', $this->opTypeNames)) . ')#';
|
|
}
|
|
|
|
public function init($source, $filename = '', $lineno = 1) {
|
|
$this->source = $source;
|
|
$this->filename = $filename ? $filename : '[inline]';
|
|
$this->lineno = $lineno;
|
|
|
|
$this->cursor = 0;
|
|
$this->tokens = array();
|
|
$this->tokenIndex = 0;
|
|
$this->lookahead = 0;
|
|
$this->scanNewlines = false;
|
|
$this->scanOperand = true;
|
|
}
|
|
|
|
public function getInput($chunksize) {
|
|
if ($chunksize) {
|
|
return substr($this->source, $this->cursor, $chunksize);
|
|
}
|
|
|
|
return substr($this->source, $this->cursor);
|
|
}
|
|
|
|
public function isDone() {
|
|
return $this->peek() == TOKEN_END;
|
|
}
|
|
|
|
public function match($tt, $op_dot = false) {
|
|
return $this->get(1000, $op_dot) == $tt || $this->unget();
|
|
}
|
|
|
|
public function mustMatch($tt, $op_dot = false) {
|
|
if (!$this->match($tt, $op_dot)) {
|
|
throw $this->newSyntaxError('Unexpected token; token ' . $tt . ' expected');
|
|
}
|
|
|
|
return $this->currentToken();
|
|
}
|
|
|
|
public function peek() {
|
|
if ($this->lookahead) {
|
|
$next = $this->tokens[($this->tokenIndex + $this->lookahead) & 3];
|
|
if ($this->scanNewlines && $next->lineno != $this->lineno) {
|
|
$tt = TOKEN_NEWLINE;
|
|
}
|
|
else {
|
|
$tt = $next->type;
|
|
}
|
|
}
|
|
else {
|
|
$tt = $this->get();
|
|
$this->unget();
|
|
}
|
|
|
|
return $tt;
|
|
}
|
|
|
|
public function peekOnSameLine() {
|
|
$this->scanNewlines = true;
|
|
$tt = $this->peek();
|
|
$this->scanNewlines = false;
|
|
|
|
return $tt;
|
|
}
|
|
|
|
public function currentToken() {
|
|
if (!empty($this->tokens)) {
|
|
return $this->tokens[$this->tokenIndex];
|
|
}
|
|
}
|
|
|
|
public function get($chunksize = 1000, $op_dot = false) {
|
|
while ($this->lookahead) {
|
|
$this->lookahead--;
|
|
$this->tokenIndex = ($this->tokenIndex + 1) & 3;
|
|
$token = $this->tokens[$this->tokenIndex];
|
|
if ($token->type != TOKEN_NEWLINE || $this->scanNewlines) {
|
|
return $token->type;
|
|
}
|
|
}
|
|
|
|
$conditional_comment = false;
|
|
|
|
// strip whitespace and comments
|
|
while (true) {
|
|
$input = $this->getInput($chunksize);
|
|
|
|
// whitespace handling; gobble up \r as well (effectively we don't have support for MAC newlines!)
|
|
$re = $this->scanNewlines ? '/^[ \r\t]+/' : '/^\s+/';
|
|
if (preg_match($re, $input, $match)) {
|
|
$spaces = $match[0];
|
|
$spacelen = strlen($spaces);
|
|
$this->cursor += $spacelen;
|
|
if (!$this->scanNewlines) {
|
|
$this->lineno += substr_count($spaces, "\n");
|
|
}
|
|
|
|
if ($spacelen == $chunksize) {
|
|
continue; // complete chunk contained whitespace
|
|
}
|
|
|
|
$input = $this->getInput($chunksize);
|
|
if ($input == '' || $input[0] != '/') {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Comments
|
|
if (!preg_match('/^\/(?:\*(@(?:cc_on|if|elif|else|end))?.*?\*\/|\/[^\n]*)/s', $input, $match)) {
|
|
if (!$chunksize) {
|
|
break;
|
|
}
|
|
|
|
// retry with a full chunk fetch; this also prevents breakage of long regular expressions (which will never match a comment)
|
|
$chunksize = null;
|
|
continue;
|
|
}
|
|
|
|
// check if this is a conditional (JScript) comment
|
|
if (!empty($match[1])) {
|
|
$match[0] = '/*' . $match[1];
|
|
$conditional_comment = true;
|
|
break;
|
|
}
|
|
else {
|
|
$this->cursor += strlen($match[0]);
|
|
$this->lineno += substr_count($match[0], "\n");
|
|
}
|
|
}
|
|
|
|
if ($input == '') {
|
|
$tt = TOKEN_END;
|
|
$match = array('');
|
|
}
|
|
elseif ($conditional_comment) {
|
|
$tt = TOKEN_CONDCOMMENT_START;
|
|
}
|
|
else {
|
|
switch ($input[0]) {
|
|
case '0':
|
|
// hexadecimal
|
|
if (($input[1] == 'x' || $input[1] == 'X') && preg_match('/^0x[0-9a-f]+/i', $input, $match)) {
|
|
$tt = TOKEN_NUMBER;
|
|
break;
|
|
}
|
|
// FALL THROUGH
|
|
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
// should always match
|
|
preg_match('/^\d+(?:\.\d*)?(?:[eE][-+]?\d+)?/', $input, $match);
|
|
$tt = TOKEN_NUMBER;
|
|
break;
|
|
|
|
case "'":
|
|
if (preg_match('/^\'(?:[^\\\\\'\r\n]++|\\\\(?:.|\r?\n))*\'/', $input, $match)) {
|
|
$tt = TOKEN_STRING;
|
|
}
|
|
else {
|
|
if ($chunksize) {
|
|
return $this->get(null); // retry with a full chunk fetch
|
|
}
|
|
|
|
throw $this->newSyntaxError('Unterminated string literal');
|
|
}
|
|
break;
|
|
|
|
case '"':
|
|
if (preg_match('/^"(?:[^\\\\"\r\n]++|\\\\(?:.|\r?\n))*"/', $input, $match)) {
|
|
$tt = TOKEN_STRING;
|
|
}
|
|
else {
|
|
if ($chunksize) {
|
|
return $this->get(null); // retry with a full chunk fetch
|
|
}
|
|
|
|
throw $this->newSyntaxError('Unterminated string literal');
|
|
}
|
|
break;
|
|
|
|
case '/':
|
|
if ($this->scanOperand && preg_match('/^\/((?:\\\\.|\[(?:\\\\.|[^\]])*\]|[^\/])+)\/([gimy]*)/', $input, $match)) {
|
|
$tt = TOKEN_REGEXP;
|
|
break;
|
|
}
|
|
// FALL THROUGH
|
|
|
|
case '|':
|
|
case '^':
|
|
case '&':
|
|
case '<':
|
|
case '>':
|
|
case '+':
|
|
case '-':
|
|
case '*':
|
|
case '%':
|
|
case '=':
|
|
case '!':
|
|
// should always match
|
|
preg_match($this->opRegExp, $input, $match);
|
|
$op = $match[0];
|
|
if (in_array($op, $this->assignOps) && $input[strlen($op)] == '=') {
|
|
$tt = OP_ASSIGN;
|
|
$match[0] .= '=';
|
|
}
|
|
else {
|
|
$tt = $op;
|
|
if ($this->scanOperand) {
|
|
if ($op == OP_PLUS) {
|
|
$tt = OP_UNARY_PLUS;
|
|
}
|
|
elseif ($op == OP_MINUS) {
|
|
$tt = OP_UNARY_MINUS;
|
|
}
|
|
}
|
|
$op = null;
|
|
}
|
|
break;
|
|
|
|
case '.':
|
|
if (preg_match('/^\.\d+(?:[eE][-+]?\d+)?/', $input, $match)) {
|
|
$tt = TOKEN_NUMBER;
|
|
break;
|
|
}
|
|
// FALL THROUGH
|
|
|
|
case ';':
|
|
case ',':
|
|
case '?':
|
|
case ':':
|
|
case '~':
|
|
case '[':
|
|
case ']':
|
|
case '{':
|
|
case '}':
|
|
case '(':
|
|
case ')':
|
|
// these are all single
|
|
$match = array($input[0]);
|
|
$tt = $input[0];
|
|
break;
|
|
|
|
case '@':
|
|
// check end of conditional comment
|
|
if (substr($input, 0, 3) == '@*/') {
|
|
$match = array('@*/');
|
|
$tt = TOKEN_CONDCOMMENT_END;
|
|
}
|
|
else {
|
|
throw $this->newSyntaxError('Illegal token');
|
|
}
|
|
break;
|
|
|
|
case "\n":
|
|
if ($this->scanNewlines) {
|
|
$match = array("\n");
|
|
$tt = TOKEN_NEWLINE;
|
|
}
|
|
else {
|
|
throw $this->newSyntaxError('Illegal token');
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// Fast path for identifiers: word chars followed by whitespace or various other tokens.
|
|
// Note we don't need to exclude digits in the first char, as they've already been found
|
|
// above.
|
|
if (!preg_match('/^[$\w]+(?=[\s\/\|\^\&<>\+\-\*%=!.;,\?:~\[\]\{\}\(\)@])/', $input, $match)) {
|
|
// Character classes per ECMA-262 edition 5.1 section 7.6
|
|
// Per spec, must accept Unicode 3.0, *may* accept later versions.
|
|
// We'll take whatever PCRE understands, which should be more recent.
|
|
$identifierStartChars = "\\p{L}\\p{Nl}" . # UnicodeLetter
|
|
"\$" .
|
|
"_";
|
|
$identifierPartChars = $identifierStartChars .
|
|
"\\p{Mn}\\p{Mc}" . # UnicodeCombiningMark
|
|
"\\p{Nd}" . # UnicodeDigit
|
|
"\\p{Pc}"; # UnicodeConnectorPunctuation
|
|
$unicodeEscape = "\\\\u[0-9A-F-a-f]{4}";
|
|
$identifierRegex = "/^" .
|
|
"(?:[$identifierStartChars]|$unicodeEscape)" .
|
|
"(?:[$identifierPartChars]|$unicodeEscape)*" .
|
|
"/uS";
|
|
if (preg_match($identifierRegex, $input, $match)) {
|
|
if (strpos($match[0], '\\') !== false) {
|
|
// Per ECMA-262 edition 5.1, section 7.6 escape sequences should behave as if they were
|
|
// the original chars, but only within the boundaries of the identifier.
|
|
$decoded = preg_replace_callback('/\\\\u([0-9A-Fa-f]{4})/',
|
|
array(__CLASS__, 'unicodeEscapeCallback'),
|
|
$match[0]);
|
|
|
|
// Since our original regex didn't de-escape the originals, we need to check for validity again.
|
|
// No need to worry about token boundaries, as anything outside the identifier is illegal!
|
|
if (!preg_match("/^[$identifierStartChars][$identifierPartChars]*$/u", $decoded)) {
|
|
throw $this->newSyntaxError('Illegal token');
|
|
}
|
|
|
|
// Per spec it _ought_ to work to use these escapes for keywords words as well...
|
|
// but IE rejects them as invalid, while Firefox and Chrome treat them as identifiers
|
|
// that don't match the keyword.
|
|
if (in_array($decoded, $this->keywords)) {
|
|
throw $this->newSyntaxError('Illegal token');
|
|
}
|
|
|
|
// TODO: save the decoded form for output?
|
|
}
|
|
}
|
|
else {
|
|
throw $this->newSyntaxError('Illegal token');
|
|
}
|
|
}
|
|
|
|
// Identifiers after an OP_DOT can include otherwise reserve keywords.
|
|
if ($op_dot) {
|
|
$tt = TOKEN_IDENTIFIER;
|
|
}
|
|
else {
|
|
$tt = in_array($match[0], $this->keywords) ? $match[0] : TOKEN_IDENTIFIER;
|
|
}
|
|
}
|
|
}
|
|
|
|
$this->tokenIndex = ($this->tokenIndex + 1) & 3;
|
|
|
|
if (!isset($this->tokens[$this->tokenIndex])) {
|
|
$this->tokens[$this->tokenIndex] = new JSToken();
|
|
}
|
|
|
|
$token = $this->tokens[$this->tokenIndex];
|
|
$token->type = $tt;
|
|
|
|
if ($tt == OP_ASSIGN) {
|
|
$token->assignOp = $op;
|
|
}
|
|
|
|
$token->start = $this->cursor;
|
|
|
|
$token->value = $match[0];
|
|
$this->cursor += strlen($match[0]);
|
|
|
|
$token->end = $this->cursor;
|
|
$token->lineno = $this->lineno;
|
|
|
|
return $tt;
|
|
}
|
|
|
|
public function unget() {
|
|
if (++$this->lookahead == 4) {
|
|
throw $this->newSyntaxError('PANIC: too much lookahead!');
|
|
}
|
|
|
|
$this->tokenIndex = ($this->tokenIndex - 1) & 3;
|
|
}
|
|
|
|
public function newSyntaxError($m) {
|
|
return new Exception('Parse error: ' . $m . ' in file \'' . $this->filename . '\' on line ' . $this->lineno);
|
|
}
|
|
|
|
public static function unicodeEscapeCallback($m) {
|
|
return html_entity_decode('&#x' . $m[1]. ';', ENT_QUOTES, 'UTF-8');
|
|
}
|
|
}
|
|
|
|
class JSToken {
|
|
public $type;
|
|
public $value;
|
|
public $start;
|
|
public $end;
|
|
public $lineno;
|
|
public $assignOp;
|
|
}
|