Changeset 1771 for trunk/buildscripts/jsbuilder/jsmin.php

Timestamp:

03/25/2007 07:27:59 PM (22 months ago)

Author:

xue

Message:

merge from 3.0 branch till 1769.

Files:

• trunk/buildscripts/jsbuilder/jsmin.php (modified) (36 diffs)

trunk/buildscripts/jsbuilder/jsmin.php

@@ -1 +1 @@
 <?php
-
-/**
-* JSMin.php (for PHP 5)
+/**
+* JSMin_lib.php (for PHP 4, 5)
 *
 * PHP adaptation of JSMin, published by Douglas Crockford as jsmin.c, also based
@@ -38 +37 @@
 * @copyright   No new copyright ; please keep above and following information.
 * @author      David Holmes <dholmes@cfdsoftware.net> of CFD Labs, France
-* @version     0.1 (PHP translation)   2006-04-11
+* @author      Gaetano Giunta
+* @version     $Id: $
 *
 * Please note, this is a brutal and simple conversion : it could undoubtedly be
@@ -44 +44 @@
 * features.
 *
-* PHP 5 is required because OO style of programming is used, as well as classes
-* from the Standard PHP Library (SPL).
+* Exceptions and all PHP 5 - only features ahve been removed for compat with PHP 4
 *
 * Note : whereas jsmin.c works specifically with the standard input and output
@@ -67 +66 @@
 *
 * See JSMin.php -h (or --help) for command-line documentation.
+*
+* NEW AND IMPROVED in version 0.2:
+* to take advantage of this file in your own code, you can do the following:
+*
+* define('JSMIN_AS_LIB', true); // prevents auto-run on include
+* include('jsmin.php');
+* // the JSMin class now works on php strings, too
+* $jsMin = new JSMin(file_get_contents('e:/htdocs/awstats_misc_tracker.js'), false);
+* // in that case, the modifies string is returned by minify():
+* $out = $jsMin->minify();
+*
 */
 
@@ -73 +83 @@
 */
 
-define('VERSION', '0.1');
+define('JSMIN_VERSION', '0.2');
 
 /**
@@ -99 +109 @@
 * Generic exception class related to JSMin.
 */
-
+/*
 class JSMinException extends Exception {
 }
+*/
+class JSMinException {
+}
 
 /**
@@ -132 +145 @@
 
 /**
+ * Constant describing an {@link action()} : Output A. Copy B to A. Get the next B.
+ */
+
+define ('JSMIN_ACT_FULL', 1);
+
+/**
+ * Constant describing an {@link action()} : Copy B to A. Get the next B. (Delete A).
+ */
+
+define ('JSMIN_ACT_BUF', 2);
+
+/**
+ * Constant describing an {@link action()} : Get the next B. (Delete B).
+ */
+
+define ('JSMIN_ACT_IMM', 3);
+
+/**
 * Main JSMin application class.
 *
@@ -137 +168 @@
 *
 * $jsMin = new JSMin(...input..., ...output...);
-* $jsMin -> minify();
+* $jsMin->minify();
 *
 * Do not specify input and/or output (or default to '-') to use stdin and/or stdout.
@@ -145 +176 @@
 
     /**
-     * Constant describing an {@link action()} : Output A. Copy B to A. Get the next B.
-     */
-
-    const ACT_FULL = 1;
-
-    /**
-     * Constant describing an {@link action()} : Copy B to A. Get the next B. (Delete A).
-     */
-
-    const ACT_BUF = 2;
-
-    /**
-     * Constant describing an {@link action()} : Get the next B. (Delete B).
-     */
-
-    const ACT_IMM = 3;
-
-    /**
      * The input stream, from which to read a JS file to minimize. Obtained by fopen().
-     * @var SplFileObject
-     */
-
-    private $in;
+     * NB: might be a string instead of a stream
+     * @var SplFileObject | string
+     */
+    var $in;
 
     /**
      * The output stream, in which to write the minimized JS file. Obtained by fopen().
-     * @var SplFileObject
-     */
-
-    private $out;
+     * NB: might be a string instead of a stream
+     * @var SplFileObject | string
+     */
+    var $out;
 
     /**
@@ -180 +193 @@
      * @var string
      */
-
-    private $theA;
+    var $theA;
 
     /**
@@ -187 +199 @@
      * @var string
      */
-
-    private $theB;
+    var $theB;
+
+        /** variables used for string-based parsing **/
+        var $inLength = 0;
+        var $inPos = 0;
+        var $isString = false;
 
     /**
@@ -196 +212 @@
      * @return  boolean     Whether the char is a letter, digit, underscore, dollar, backslash, or non-ASCII.
      */
-
-    private static function isAlphaNum($c) {
+    function isAlphaNum($c) {
 
         // Get ASCII value of character for C-like comparisons
@@ -223 +238 @@
      * @see     peek()
      */
-
-    private function get() {
+    function get() {
 
         // Get next input character and advance position in file
-
-        $c = $this -> in -> fgetc();
+//var_dump($this);
+                if ($this->isString) {
+                        if ($this->inPos < $this->inLength) {
+                                $c = $this->in[$this->inPos];
+                                ++$this->inPos;
+                        }
+                        else {
+                                return EOF;
+                        }
+                }
+                else
+                $c = $this->in->fgetc();
 
         // Test for non-problematic characters
@@ -257 +281 @@
      * @see     get()
      */
-
-    private function peek() {
-
-        // Get next input character
-
-        $c = $this -> in -> fgetc();
-
-        // Regress position in file
-
-        $this -> in -> fseek(-1, SEEK_CUR);
-
-        // Return character obtained
+    function peek() {
+
+                if ($this->isString) {
+                        if ($this->inPos < $this->inLength) {
+                                $c = $this->in[$this->inPos];
+                        }
+                        else {
+                                return EOF;
+                        }
+                }
+                else {
+                // Get next input character
+
+                $c = $this->in->fgetc();
+
+                // Regress position in file
+
+                $this->in->fseek(-1, SEEK_CUR);
+
+                // Return character obtained
+            }
 
         return $c;
     }
+
+        /**
+         * Adds a char to the output steram / string
+         * @see $out
+         */
+        function put($c)
+        {
+                if ($this->isString) {
+                        $this->out .= $c;
+                }
+                else {
+                        $this->out->fwrite($c);
+                }
+        }
 
     /**
@@ -282 +329 @@
      * @see     $in
      */
-
-    private function next() {
+    function next() {
 
         // Get next char from input, translated if necessary
 
-        $c = $this -> get();
+        $c = $this->get();
 
         // Check comment possibility
@@ -295 +341 @@
             // Look ahead : a comment is two slashes or slashes followed by asterisk (to be closed)
 
-            switch ($this -> peek()) {
+            switch ($this->peek()) {
 
                 case '/' :
 
                     // Comment is up to the end of the line
-                    // TOTEST : simple $this -> in -> fgets()
+                    // TOTEST : simple $this->in->fgets()
 
                     while (true) {
 
-                        $c = $this -> get();
+                        $c = $this->get();
 
                         if (ord($c) <= ORD_NL) {
@@ -320 +366 @@
                         // N.B. not using switch() because of having to test EOF with ===
 
-                        $c = $this -> get();
+                        $c = $this->get();
 
                         if ($c == '*') {
@@ -326 +372 @@
                             // Comment termination if the char ahead is a slash
 
-                            if ($this -> peek() == '/') {
+                            if ($this->peek() == '/') {
 
                                 // Advance again and make into a single space
 
-                                $this -> get();
+                                $this->get();
                                 return ' ';
                             }
@@ -338 +384 @@
                             // Whoopsie
 
-                            throw new UnterminatedCommentJSMinException();
+                            //throw new UnterminatedCommentJSMinException();
+                            trigger_error('UnterminatedComment', E_USER_ERROR);
                         }
                     }
@@ -360 +407 @@
      * The action to perform is determined by the argument :
      *
-     * JSMin :: ACT_FULL : Output A. Copy B to A. Get the next B.
-     * JSMin :: ACT_BUF  : Copy B to A. Get the next B. (Delete A).
-     * JSMin :: ACT_IMM  : Get the next B. (Delete B).
+     * JSMin::ACT_FULL : Output A. Copy B to A. Get the next B.
+     * JSMin::ACT_BUF  : Copy B to A. Get the next B. (Delete A).
+     * JSMin::ACT_IMM  : Get the next B. (Delete B).
      *
      * A string is treated as a single character. Also, regular expressions are recognized if preceded
      * by '(', ',' or '='.
      *
-     * @param   int     $action     The action to perform : one of the JSMin :: ACT_* constants.
-     */
-
-    private function action($action) {
+     * @param   int     $action     The action to perform : one of the JSMin::ACT_* constants.
+     */
+    function action($action) {
 
         // Choice of possible actions
@@ -377 +423 @@
         switch ($action) {
 
-            case self :: ACT_FULL :
+            case JSMIN_ACT_FULL :
 
                 // Write A to output, then fall through
 
-                $this -> out -> fwrite($this -> theA);
-
-            case self :: ACT_BUF : // N.B. possible fallthrough from above
+                $this->put($this->theA);
+
+            case JSMIN_ACT_BUF : // N.B. possible fallthrough from above
 
                 // Copy B to A
 
-                $tmpA = $this -> theA = $this -> theB;
+                $tmpA = $this->theA = $this->theB;
 
                 // Treating a string as a single char : outputting it whole
@@ -398 +444 @@
                         // Output string contents
 
-                        $this -> out -> fwrite($tmpA);
+                        $this->put($tmpA);
 
                         // Get next character, watching out for termination of the current string,
@@ -404 +450 @@
                         // (upon which the following char is directly output to serve the escape mechanism)
 
-                        $tmpA = $this -> theA = $this -> get();
-
-                        if ($tmpA == $this -> theB) {
+                        $tmpA = $this->theA = $this->get();
+
+                        if ($tmpA == $this->theB) {
 
                             // String terminated
@@ -419 +465 @@
                             // Whoopsie
 
-                            throw new UnterminatedStringLiteralJSMinException();
+                            //throw new UnterminatedStringLiteralJSMinException();
+                            trigger_error('UnterminatedStringLiteral', E_USER_ERROR);
                         }
 
@@ -428 +475 @@
                             // Escape next char immediately
 
-                            $this -> out -> fwrite($tmpA);
-                            $tmpA = $this -> theA = $this -> get();
+                            $this->put($tmpA);
+                            $tmpA = $this->theA = $this->get();
                         }
                     }
                 }
 
-            case self :: ACT_IMM : // N.B. possible fallthrough from above
+            case JSMIN_ACT_IMM : // N.B. possible fallthrough from above
 
                 // Get the next B
 
-                $this -> theB = $this -> next();
+                $this->theB = $this->next();
 
                 // Special case of recognising regular expressions (beginning with /) that are
                 // preceded by '(', ',' or '='
 
-                $tmpA = $this -> theA;
-
-                if ($this -> theB == '/' && ($tmpA == '(' || $tmpA == ',' || $tmpA == '=')) {
+                $tmpA = $this->theA;
+
+                if ($this->theB == '/' && ($tmpA == '(' || $tmpA == ',' || $tmpA == '=')) {
 
                     // Output the two successive chars
 
-                    $this -> out -> fwrite($tmpA);
-                    $this -> out -> fwrite($this -> theB);
+                    $this->put($tmpA);
+                    $this->put($this->theB);
 
                     // Look for the end of the RE literal, watching out for escaped chars or a control /
@@ -457 +504 @@
                     while (true) {
 
-                        $tmpA = $this -> theA = $this -> get();
+                        $tmpA = $this->theA = $this->get();
 
                         if ($tmpA == '/') {
@@ -472 +519 @@
                             // Escape next char immediately
 
-                            $this -> out -> fwrite($tmpA);
-                            $tmpA = $this -> theA = $this -> get();
+                            $this->put($tmpA);
+                            $tmpA = $this->theA = $this->get();
                         }
                         else if (ord($tmpA) <= ORD_NL) {
@@ -479 +526 @@
                             // Whoopsie
 
-                            throw new UnterminatedRegExpLiteralJSMinException();
+                            //throw new UnterminatedRegExpLiteralJSMinException();
+                            trigger_error('UnterminatedRegExpLiteral', E_USER_ERROR);
                         }
 
                         // Output RE characters
 
-                        $this -> out -> fwrite($tmpA);
+                        $this->put($tmpA);
                     }
 
                     // Move forward after the RE literal
 
-                    $this -> theB = $this -> next();
+                    $this->theB = $this->next();
                 }
 
             break;
-            default : throw new JSMinException('Expected a JSMin :: ACT_* constant in action().');
+            default :
+                                //throw new JSMinException('Expected a JSMin::ACT_* constant in action().');
+                                trigger_error('Expected a JSMin::ACT_* constant in action()', E_USER_ERROR);
         }
     }
@@ -501 +551 @@
      *
      * The code is read from the input stream, and its minified version is written to the output one.
+     * In case input is a string, minified vesrions is also returned by this function as string.
      * That is : characters which are insignificant to JavaScript are removed, as well as comments ;
      * tabs are replaced with spaces ; carriage returns are replaced with linefeeds, and finally most
@@ -508 +559 @@
      * the name of this class.
      *
-     * @see     __construct()
-     */
-
-    public function minify() {
+     * @see     JSMin()
+     * @return null | string
+     */
+    function minify() {
 
         // Initialize A and run the first (minimal) action
 
-        $this -> theA = "\n";
-        $this -> action(self :: ACT_IMM);
+        $this->theA = "\n";
+        $this->action(JSMIN_ACT_IMM);
 
         // Proceed all the way to the end of the input file
 
-        while ($this -> theA !== EOF) {
-
-            switch ($this -> theA) {
+        while ($this->theA !== EOF) {
+
+            switch ($this->theA) {
 
                 case ' ' :
 
-                    if (self :: isAlphaNum($this -> theB)) {
-                        $this -> action(self :: ACT_FULL);
+                    if (JSMin::isAlphaNum($this->theB)) {
+                        $this->action(JSMIN_ACT_FULL);
                     }
                     else {
-                        $this -> action(self :: ACT_BUF);
+                        $this->action(JSMIN_ACT_BUF);
                     }
 
@@ -536 +587 @@
                 case "\n" :
 
-                    switch ($this -> theB) {
+                    switch ($this->theB) {
 
                         case '{' : case '[' : case '(' :
                         case '+' : case '-' :
 
-                            $this -> action(self :: ACT_FULL);
+                            $this->action(JSMIN_ACT_FULL);
 
                         break;
                         case ' ' :
 
-                            $this -> action(self :: ACT_IMM);
+                            $this->action(JSMIN_ACT_IMM);
 
                         break;
                         default :
 
-                            if (self :: isAlphaNum($this -> theB)) {
-                                $this -> action(self :: ACT_FULL);
+                            if (JSMin::isAlphaNum($this->theB)) {
+                                $this->action(JSMIN_ACT_FULL);
                             }
                             else {
-                                $this -> action(self :: ACT_BUF);
+                                $this->action(JSMIN_ACT_BUF);
                             }
 
@@ -564 +615 @@
                 default :
 
-                    switch ($this -> theB) {
+                    switch ($this->theB) {
 
                         case ' ' :
 
-                            if (self :: isAlphaNum($this -> theA)) {
-
-                                $this -> action(self :: ACT_FULL);
+                            if (JSMin::isAlphaNum($this->theA)) {
+
+                                $this->action(JSMIN_ACT_FULL);
                                 break;
                             }
@@ -576 +627 @@
                             // else
 
-                            $this -> action(self :: ACT_IMM);
+                            $this->action(JSMIN_ACT_IMM);
 
                         break;
                         case "\n" :
 
-                            switch ($this -> theA) {
+                            switch ($this->theA) {
 
                                 case '}' : case ']' : case ')' : case '+' :
                                 case '-' : case '"' : case '\'' :
 
-                                    $this -> action(self :: ACT_FULL);
+                                    $this->action(JSMIN_ACT_FULL);
 
                                 break;
                                 default :
 
-                                    if (self :: isAlphaNum($this -> theA)) {
-                                        $this -> action(self :: ACT_FULL);
+                                    if (JSMin::isAlphaNum($this->theA)) {
+                                        $this->action(JSMIN_ACT_FULL);
                                     }
                                     else {
-                                        $this -> action(self :: ACT_IMM);
+                                        $this->action(JSMIN_ACT_IMM);
                                     }
 
@@ -604 +655 @@
                         default :
 
-                            $this -> action(self :: ACT_FULL);
+                            $this->action(JSMIN_ACT_FULL);
 
                         break;
@@ -612 +663 @@
             }
         }
+
+            if ($this->isString) {
+                    return $this->out;
+
+            }