JSMin_lib.php

Go to the documentation of this file.

<?php
define('JSMIN_VERSION', '0.2');
 
define('EOF', FALSE);
 
define('ORD_NL', ord("\n"));
define('ORD_space', ord(' '));
define('ORD_cA', ord('A'));
define('ORD_cZ', ord('Z'));
define('ORD_a', ord('a'));
define('ORD_z', ord('z'));
define('ORD_0', ord('0'));
define('ORD_9', ord('9'));
 
/*
class JSMinException extends Exception {
}
*/
class JSMinException {
}
 
class FileOpenFailedJSMinException extends JSMinException {
}
 
class UnterminatedCommentJSMinException extends JSMinException {
}
 
class UnterminatedStringLiteralJSMinException extends JSMinException {
}
 
class UnterminatedRegExpLiteralJSMinException extends JSMinException {
}
 
define ('JSMIN_ACT_FULL', 1);
 
define ('JSMIN_ACT_BUF', 2);
 
define ('JSMIN_ACT_IMM', 3);
 
class JSMin {
 
    var $in;
 
    var $out;
 
    var $theA;
 
    var $theB;
 
        var $inLength = 0;
        var $inPos = 0;
        var $isString = false;
 
    function isAlphaNum($c) {
 
        // Get ASCII value of character for C-like comparisons
 
        $a = ord($c);
 
        // Compare using defined character ordinals, or between PHP strings
        // Note : === is micro-faster than == when types are known to be the same
 
        return
            ($a >= ORD_a && $a <= ORD_z) ||
            ($a >= ORD_0 && $a <= ORD_9) ||
            ($a >= ORD_cA && $a <= ORD_cZ) ||
            $c === '_' || $c === '$' || $c === '\\' || $a > 126
        ;
    }
 
    function get() {
 
        // Get next input character and advance position in file
 
                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
 
        if ($c === "\n" || $c === EOF || ord($c) >= ORD_space) {
            return $c;
        }
 
        // else
        // Make linefeeds into newlines
 
        if ($c === "\r") {
            return "\n";
        }
 
        // else
        // Consider space
 
        return ' ';
    }
 
    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;
    }
 
        function put($c)
        {
                if ($this->isString) {
                        $this->out .= $c;
                }
                else {
                        $this->out->fwrite($c);
                }
        }
 
    function next() {
 
        // Get next char from input, translated if necessary
 
        $c = $this->get();
 
        // Check comment possibility
 
        if ($c == '/') {
 
            // Look ahead : a comment is two slashes or slashes followed by asterisk (to be closed)
 
            switch ($this->peek()) {
 
                case '/' :
 
                    // Comment is up to the end of the line
                    // TOTEST : simple $this->in->fgets()
 
                    while (true) {
 
                        $c = $this->get();
 
                        if (ord($c) <= ORD_NL) {
                            return $c;
                        }
                    }
 
                case '*' :
 
                    // Comment is up to comment close.
                    // Might not be terminated, if we hit the end of file.
 
                    while (true) {
 
                        // N.B. not using switch() because of having to test EOF with ===
 
                        $c = $this->get();
 
                        if ($c == '*') {
 
                            // Comment termination if the char ahead is a slash
 
                            if ($this->peek() == '/') {
 
                                // Advance again and make into a single space
 
                                $this->get();
                                return ' ';
                            }
                        }
                        else if ($c === EOF) {
 
                            // Whoopsie
 
                            //throw new UnterminatedCommentJSMinException();
                            trigger_error('UnterminatedComment', E_USER_ERROR);
                        }
                    }
 
                default :
 
                    // Not a comment after all
 
                    return $c;
            }
        }
 
        // No risk of a comment
 
        return $c;
    }
 
    function action($action) {
 
        // Choice of possible actions
        // Note the frequent fallthroughs : the actions are decrementally "long"
 
        switch ($action) {
 
            case JSMIN_ACT_FULL :
 
                // Write A to output, then fall through
 
                $this->put($this->theA);
 
            case JSMIN_ACT_BUF : // N.B. possible fallthrough from above
 
                // Copy B to A
 
                $tmpA = $this->theA = $this->theB;
 
                // Treating a string as a single char : outputting it whole
                // Note that the string-opening char (" or ') is memorized in B
 
                if ($tmpA == '\'' || $tmpA == '"') {
 
                    while (true) {
 
                        // Output string contents
 
                        $this->put($tmpA);
 
                        // Get next character, watching out for termination of the current string,
                        // new line & co (then the string is not terminated !), or a backslash
                        // (upon which the following char is directly output to serve the escape mechanism)
 
                        $tmpA = $this->theA = $this->get();
 
                        if ($tmpA == $this->theB) {
 
                            // String terminated
 
                            break; // from while(true)
                        }
 
                        // else
 
                        if (ord($tmpA) <= ORD_NL) {
 
                            // Whoopsie
 
                            //throw new UnterminatedStringLiteralJSMinException();
                            trigger_error('UnterminatedStringLiteral', E_USER_ERROR);
                        }
 
                        // else
 
                        if ($tmpA == '\\') {
 
                            // Escape next char immediately
 
                            $this->put($tmpA);
                            $tmpA = $this->theA = $this->get();
                        }
                    }
                }
 
            case JSMIN_ACT_IMM : // N.B. possible fallthrough from above
 
                // Get the next B
 
                $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 == '=')) {
 
                    // Output the two successive chars
 
                    $this->put($tmpA);
                    $this->put($this->theB);
 
                    // Look for the end of the RE literal, watching out for escaped chars or a control /
                    // end of line char (the RE literal then being unterminated !)
 
                    while (true) {
 
                        $tmpA = $this->theA = $this->get();
 
                        if ($tmpA == '/') {
 
                            // RE literal terminated
 
                            break; // from while(true)
                        }
 
                        // else
 
                        if ($tmpA == '\\') {
 
                            // Escape next char immediately
 
                            $this->put($tmpA);
                            $tmpA = $this->theA = $this->get();
                        }
                        else if (ord($tmpA) <= ORD_NL) {
 
                            // Whoopsie
 
                            //throw new UnterminatedRegExpLiteralJSMinException();
                            trigger_error('UnterminatedRegExpLiteral', E_USER_ERROR);
                        }
 
                        // Output RE characters
 
                        $this->put($tmpA);
                    }
 
                    // Move forward after the RE literal
 
                    $this->theB = $this->next();
                }
 
            break;
            default :
                                //throw new JSMinException('Expected a JSMin::ACT_* constant in action().');
                                trigger_error('Expected a JSMin::ACT_* constant in action()', E_USER_ERROR);
        }
    }
 
    function minify() {
 
        // Initialize A and run the first (minimal) action
 
        $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) {
 
                case ' ' :
 
                    if (JSMin::isAlphaNum($this->theB)) {
                        $this->action(JSMIN_ACT_FULL);
                    }
                    else {
                        $this->action(JSMIN_ACT_BUF);
                    }
 
                break;
                case "\n" :
 
                    switch ($this->theB) {
 
                        case '{' : case '[' : case '(' :
                        case '+' : case '-' :
 
                            $this->action(JSMIN_ACT_FULL);
 
                        break;
                        case ' ' :
 
                            $this->action(JSMIN_ACT_IMM);
 
                        break;
                        default :
 
                            if (JSMin::isAlphaNum($this->theB)) {
                                $this->action(JSMIN_ACT_FULL);
                            }
                            else {
                                $this->action(JSMIN_ACT_BUF);
                            }
 
                        break;
                    }
 
                break;
                default :
 
                    switch ($this->theB) {
 
                        case ' ' :
 
                            if (JSMin::isAlphaNum($this->theA)) {
 
                                $this->action(JSMIN_ACT_FULL);
                                break;
                            }
 
                            // else
 
                            $this->action(JSMIN_ACT_IMM);
 
                        break;
                        case "\n" :
 
                            switch ($this->theA) {
 
                                case '}' : case ']' : case ')' : case '+' :
                                case '-' : case '"' : case '\'' :
 
                                    $this->action(JSMIN_ACT_FULL);
 
                                break;
                                default :
 
                                    if (JSMin::isAlphaNum($this->theA)) {
                                        $this->action(JSMIN_ACT_FULL);
                                    }
                                    else {
                                        $this->action(JSMIN_ACT_IMM);
                                    }
 
                                break;
                            }
 
                        break;
                        default :
 
                            $this->action(JSMIN_ACT_FULL);
 
                        break;
                    }
 
                break;
            }
        }
 
            if ($this->isString) {
                    return $this->out;
 
            }
    }
 
        function JSMin($inFileName = '-', $outFileName = '-', $comments = NULL) {
                if ($outFileName === FALSE) {
                        $this->JSMin_String($inFileName, $comments);
                }
                else {
                        $this->JSMin_File($inFileName, $outFileName, $comments);
                }
        }
 
    function JSMin_File($inFileName = '-', $outFileName = '-', $comments = NULL) {
 
        // Recuperate input and output streams.
        // Use STDIN and STDOUT by default, if they are defined (CLI mode) and no file names are provided
 
            if ($inFileName == '-')  $inFileName  = 'php://stdin';
            if ($outFileName == '-') $outFileName = 'php://stdout';
 
            /*try {
 
                $this->in = new SplFileObject($inFileName, 'rb', TRUE);
            }
            catch (Exception $e) {
 
                throw new FileOpenFailedJSMinException(
                    'Failed to open "'.$inFileName.'" for reading only.'
                );
            }
 
            try {
 
                $this->out = new SplFileObject($outFileName, 'wb', TRUE);
            }
            catch (Exception $e) {
 
                throw new FileOpenFailedJSMinException(
                    'Failed to open "'.$outFileName.'" for writing only.'
                );
            }
                        */
                        $this->in = fopen($inFileName, 'rb');
                        if (!$this->in) {
                                trigger_error('Failed to open "'.$inFileName, E_USER_ERROR);
                        }
                        $this->out = fopen($outFileName, 'wb');
                        if (!$this->out) {
                                trigger_error('Failed to open "'.$outFileName, E_USER_ERROR);
                        }
 
            // Present possible initial comments
 
            if ($comments !== NULL) {
                foreach ($comments as $comm) {
                    $this->out->fwrite('// '.str_replace("\n", " ", $comm)."\n");
                }
            }
 
    }
 
    function JSMin_String($inString, $comments = NULL) {
        $this->in = $inString;
        $this->out = '';
                $this->inLength = strlen($inString);
                $this->inPos = 0;
                $this->isString = true;
 
        if ($comments !== NULL) {
            foreach ($comments as $comm) {
                $this->out .= '// '.str_replace("\n", " ", $comm)."\n";
            }
        }
        }
}
 
?>