tag
     */
    public static function format($string, $highlight=true) {
        // This variable will be populated with formatted html
        $return = '';

        // Use an actual tab while formatting and then switch out with self::$tab at the end
        $tab = "\t";

        $indent_level = 0;
        $newline = false;
        $inline_parentheses = false;
        $increase_special_indent = false;
        $increase_block_indent = false;
        $indent_types = array();
        $added_newline = false;

        // Tokenize String
        $tokens = self::tokenize($string);

        // Format token by token
        foreach ($tokens as $i=>$token) {
            // Don't process whitespace
            if ($token[self::TOKEN_TYPE] === self::TOKEN_TYPE_WHITESPACE) {
                continue;
            }
            
            // Get highlighted token if doing syntax highlighting
            if ($highlight) {
                $highlighted = self::highlightToken($token);
            } else { // If returning raw text
                $highlighted = $token[self::TOKEN_VALUE];
            }

            // If we are increasing the special indent level now
            if($increase_special_indent) {
                $indent_level++;
                $increase_special_indent = false;
                array_unshift($indent_types,'special');
            }
            // If we are increasing the block indent level now
            if($increase_block_indent) {
                $indent_level++;
                $increase_block_indent = false;
                array_unshift($indent_types,'block');
            }
           
            // Display comments directly where they appear in the source
            if ($token[self::TOKEN_TYPE] === self::TOKEN_TYPE_COMMENT || $token[self::TOKEN_TYPE] === self::TOKEN_TYPE_BLOCK_COMMENT) {
                if ($token[self::TOKEN_TYPE] === self::TOKEN_TYPE_BLOCK_COMMENT) {
                    $return .= "\n" . str_repeat($tab,$indent_level);
                }

                $return .= $highlighted;
                $newline = true;
                continue;
            }
           
            // If we need a new line before the token
            if ($newline) {
                $return .= "\n" . str_repeat($tab, $indent_level);
                $newline = false;
                $added_newline = true;
            }
            else {
                $added_newline = false;
            }

            // Opening parentheses increase the block indent level and start a new line
            if ($token[self::TOKEN_VALUE] === '(') {
                // First check if this should be an inline parentheses block
                // Examples are "NOW()", "COUNT(*)", "int(10)", key(`somecolumn`), DECIMAL(7,2)
                // Allow up to 3 non-whitespace tokens inside inline parentheses
                $nonwhitespace = 0;
                for($j=1;$j<=8;$j++) {
                    // Reached end of string
                    if(!isset($tokens[$i+$j])) break;
                    
                    $next = $tokens[$i+$j];
                    
                    // Ignore whitespace
                    if($next[self::TOKEN_TYPE]===self::TOKEN_TYPE_WHITESPACE) {
                        continue;
                    }
                   
                    // Reached closing parentheses
                    if($next[self::TOKEN_VALUE] === ')') {
                        $inline_parentheses = true;
                        break;
                    }
                    
                    // Reached an invalid token for inline parentheses
                    if ($next[self::TOKEN_VALUE]===';' || $next[self::TOKEN_VALUE]==='(') {
                        break;
                    }
                    
                    // Reached an invalid token type for inline parentheses
                    if ($next[self::TOKEN_TYPE]===self::TOKEN_TYPE_SPECIAL_RESERVED || $next[self::TOKEN_TYPE]===self::TOKEN_TYPE_COMMENT || $next[self::TOKEN_TYPE]===self::TOKEN_TYPE_BLOCK_COMMENT) {
                        break;
                    }
                    
                    // Too many tokens for inline parentheses
                    if ($nonwhitespace >= 3) {
                        break;
                    }
                    
                    $nonwhitespace++;
                }
               
                // Take out the preceding space unless there was whitespace there in the original query
                if (isset($tokens[$i-1]) && $tokens[$i-1][self::TOKEN_TYPE] !== self::TOKEN_TYPE_WHITESPACE) {
                    $return = rtrim($return,' ');
                }
               
                if(!$inline_parentheses) {
                    $increase_block_indent = true;
                    // Add a newline after the parentheses
                    $newline = true;
                }
                
            }
           
            // Closing parentheses decrease the block indent level
            elseif ($token[self::TOKEN_VALUE] === ')') {
                // Remove whitespace before the closing parentheses
                $return = rtrim($return,' ');
                   
                // If we are in an inline parentheses section
                if($inline_parentheses) {
                    $inline_parentheses = false;
                }
                else {
                    $indent_level--;
           
                    // Reset indent level
                    while($j=array_shift($indent_types)) {
                        if($j==='special') {
                            $indent_level--;
                        }
                        else {
                            break;
                        }
                    }
                   
                    if($indent_level < 0) {
                        // This is an error
                        $indent_level = 0;
                       
                        if ($highlight) {
                            $return .= "\n".self::highlightError($token[self::TOKEN_VALUE]);
                            continue;
                        }
                    }
                   
                    // Add a newline before the closing parentheses (if not already added)
                    if(!$added_newline) {
                        $return .= "\n" . str_repeat($tab, $indent_level);
                    }
                }
               
            }
           
            // Commas start a new line (unless within inline parentheses)
            elseif ($token[self::TOKEN_VALUE] === ',' && !$inline_parentheses) {
                $newline = true;
            }
           
            // Special reserved words start a new line and increase the special indent level
            elseif ($token[self::TOKEN_TYPE] === self::TOKEN_TYPE_SPECIAL_RESERVED) {
                $increase_special_indent = true;
               
                // If the last indent type was 'special', decrease the special indent for this round
                reset($indent_types);
                if(current($indent_types)==='special') {
                    $indent_level--;
                    array_shift($indent_types);
                }
               
                // Add a newline after the special reserved word
                $newline = true;
                // Add a newline before the special reserved word (if not already added)
                if(!$added_newline) {
                    $return .= "\n" . str_repeat($tab, $indent_level);
                }
                // If we already added a newline, redo the indentation since it may be different now
                else {
                    $return = rtrim($return,$tab).str_repeat($tab, $indent_level);
                }

                // If the token may have extra whitespace
                if (strpos($token[self::TOKEN_VALUE],' ')!==false || strpos($token[self::TOKEN_VALUE],"\n")!==false || strpos($token[self::TOKEN_VALUE],"\t")!==false) {
                    $highlighted = preg_replace('/\s+/',' ',$highlighted);
                }
            }

            // If the token shouldn't have a space before it
            if ($token[self::TOKEN_VALUE] === '.' || $token[self::TOKEN_VALUE] === ',' || $token[self::TOKEN_VALUE] === ';') {
                $return = rtrim($return, ' ');
            }
           
            $return .= $highlighted.' ';

            // If the token shouldn't have a space after it
            if ($token[self::TOKEN_VALUE] === '(' || $token[self::TOKEN_VALUE] === '.') {
                $return = rtrim($return,' ');
            }
        }

        // If there are unmatched parentheses
        if ($highlight && array_search('block',$indent_types) !== false) {
            $return .= "\n".self::highlightError("WARNING: unclosed parentheses or section");
        }
       
        // Replace tab characters with the configuration tab character
        $return = trim(str_replace("\t",self::$tab,$return));

        if ($highlight) {
            $return = "
" . $return . "
";
        }

        return $return;       
    }

    /**
     * Add syntax highlighting to a SQL string
     *
     * @param String $string The SQL string
     *
     * @return String The SQL string with HTML styles applied
     */
    public static function highlight($string)
    {
        $tokens = self::tokenize($string);

        $return = '';

        foreach ($tokens as $token) {
            $return .= self::highlightToken($token);
        }

        return "
" . trim($return) . "
";
    }

    /**
     * Split a SQL string into multiple queries.
     * Uses ";" as a query delimiter.
     *
     * @param String $string The SQL string
     *
     * @return Array An array of individual query strings without trailing semicolons
     */
    public static function splitQuery($string)
    {
        $queries = array();
        $current_query = '';
        $empty = true;

        $tokens = self::tokenize($string);
        
        foreach ($tokens as $token) {            
            // If this is a query separator
            if ($token[self::TOKEN_VALUE] === ';') {
                if (!$empty) {
                    $queries[] = $current_query.';';
                }
                $current_query = '';
                $empty = true;
                continue;
            }
            
            // If this is a non-empty character
            if($token[self::TOKEN_TYPE] !== self::TOKEN_TYPE_WHITESPACE && $token[self::TOKEN_TYPE] !== self::TOKEN_TYPE_COMMENT && $token[self::TOKEN_TYPE] !== self::TOKEN_TYPE_BLOCK_COMMENT) {
                $empty = false;
            }

            $current_query .= $token[self::TOKEN_VALUE];
        }

        if (!$empty) {
            $queries[] = trim($current_query);
        }

        return $queries;
    }

    /**
     * Remove all comments from a SQL string
     *
     * @param String $string The SQL string
     *
     * @return String The SQL string without comments
     */
    public static function removeComments($string)
    {
        $result = '';

        $tokens = self::tokenize($string);

        foreach ($tokens as $token) {
            // Skip comment tokens
            if ($token[self::TOKEN_TYPE] === self::TOKEN_TYPE_COMMENT || $token[self::TOKEN_TYPE] === self::TOKEN_TYPE_BLOCK_COMMENT) {
                continue;
            }

            $result .= $token[self::TOKEN_VALUE];
        }

        return $result;
    }

    /**
     * Highlights a token depending on its type.
     *
     * @param Array $token An associative array containing type and value.
     *
     * @return String HTML code of the highlighted token.
     */
    protected static function highlightToken($token)
    {
        $type = $token[self::TOKEN_TYPE];
        $token = htmlentities($token[self::TOKEN_VALUE]);

        if($type===self::TOKEN_TYPE_BOUNDARY) {
            return self::highlightBoundary($token);
        }
        elseif($type===self::TOKEN_TYPE_WORD) {
            return self::highlightWord($token);
        }
        elseif($type===self::TOKEN_TYPE_BACKTICK_QUOTE) {
            return self::highlightBacktickQuote($token);
        }
        elseif($type===self::TOKEN_TYPE_QUOTE) {
            return self::highlightQuote($token);
        }
        elseif($type===self::TOKEN_TYPE_RESERVED) {
            return self::highlightReservedWord($token);
        }
        elseif($type===self::TOKEN_TYPE_SPECIAL_RESERVED) {
            return self::highlightReservedWord($token);
        }
        elseif($type===self::TOKEN_TYPE_NUMBER) {
            return self::highlightNumber($token);
        }
        elseif($type===self::TOKEN_TYPE_COMMENT || $type===self::TOKEN_TYPE_BLOCK_COMMENT) {
            return self::highlightComment($token);
        }
        
        return $token;
    }

    /**
     * Highlights a quoted string
     *
     * @param String $value The token's value
     *
     * @return String HTML code of the highlighted token.
     */
    protected static function highlightQuote($value)
    {
        return '' . $value . '';
    }

    /**
     * Highlights a backtick quoted string
     *
     * @param String $value The token's value
     *
     * @return String HTML code of the highlighted token.
     */
    protected static function highlightBacktickQuote($value) {
        return '' . $value . '';
    }

    /**
     * Highlights a reserved word
     *
     * @param String $value The token's value
     *
     * @return String HTML code of the highlighted token.
     */
    protected static function highlightReservedWord($value)
    {
        return '' . $value . '';
    }

    /**
     * Highlights a boundary token
     *
     * @param String $value The token's value
     *
     * @return String HTML code of the highlighted token.
     */
    protected static function highlightBoundary($value)
    {
        if($value==='(' || $value===')') return $value;
        
        return '' . $value . '';
    }

    /**
     * Highlights a number
     *
     * @param String $value The token's value
     *
     * @return String HTML code of the highlighted token.
     */
    protected static function highlightNumber($value)
    {
        return '' . $value . '';
    }

    /**
     * Highlights an error
     *
     * @param String $value The token's value
     *
     * @return String HTML code of the highlighted token.
     */
    protected static function highlightError($value)
    {
        return '' . $value . '';
    }

    /**
     * Highlights a comment
     *
     * @param String $value The token's value
     *
     * @return String HTML code of the highlighted token.
     */
    protected static function highlightComment($value)
    {
        return '' . $value . '';
    }

    /**
     * Highlights a word token
     *
     * @param String $value The token's value
     *
     * @return String HTML code of the highlighted token.
     */
    protected static function highlightWord($value)
    {
        return '' . $value . '';
    }

    /**
     * Helper function for sorting the list of reserved words by length
     *
     * @param String $a The first string
     * @param String $b The second string
     *
     * @return int The comparison of the string lengths
     */
    private static function sortLength($a, $b)
    {
        return strlen($b) - strlen($a);
    }
   
    /**
     * Helper function for building regular expressions for reserved words and boundary characters
     *
     * @param String $a The string to be quoted
     *
     * @return String The quoted string
     */
    private static function quote_regex($a) {
        return preg_quote($a,'/');
    }
}