tags
	public static $use_pre = true;

	// This flag tells us if SqlFormatted has been initialized
	protected static $init;

	// Regular expressions for tokenizing
	protected static $regex_boundaries;
	protected static $regex_reserved;
	protected static $regex_reserved_newline;
	protected static $regex_reserved_toplevel;
	protected static $regex_function;

	// Cache variables
	// Only tokens shorter than this size will be cached.  Somewhere between 10 and 20 seems to work well for most cases.
	public static $max_cachekey_size = 15;
	protected static $token_cache = array();
	protected static $cache_hits = 0;
	protected static $cache_misses = 0;

	/**
	 * Get stats about the token cache
	 * @return Array An array containing the keys 'hits', 'misses', 'entries', and 'size' in bytes
	 */
	public static function getCacheStats()
	{
		return array(
			'hits'=>self::$cache_hits,
			'misses'=>self::$cache_misses,
			'entries'=>count(self::$token_cache),
			'size'=>strlen(serialize(self::$token_cache))
		);
	}

	/**
	 * Stuff that only needs to be done once.  Builds regular expressions and sorts the reserved words.
	 */
	protected static function init()
	{
		if (self::$init) return;

		// Sort reserved word list from longest word to shortest, 3x faster than usort
		$reservedMap = array_combine(self::$reserved, array_map('strlen', self::$reserved));
		arsort($reservedMap);
		self::$reserved = array_keys($reservedMap);

		// Set up regular expressions
		self::$regex_boundaries = '('.implode('|',array_map(array(__CLASS__, 'quote_regex'),self::$boundaries)).')';
		self::$regex_reserved = '('.implode('|',array_map(array(__CLASS__, 'quote_regex'),self::$reserved)).')';
		self::$regex_reserved_toplevel = str_replace(' ','\\s+','('.implode('|',array_map(array(__CLASS__, 'quote_regex'),self::$reserved_toplevel)).')');
		self::$regex_reserved_newline = str_replace(' ','\\s+','('.implode('|',array_map(array(__CLASS__, 'quote_regex'),self::$reserved_newline)).')');

		self::$regex_function = '('.implode('|',array_map(array(__CLASS__, 'quote_regex'),self::$functions)).')';

		self::$init = true;
	}

	/**
	 * Return the next token and token type in a SQL string.
	 * Quoted strings, comments, reserved words, whitespace, and punctuation are all their own tokens.
	 *
	 * @param String $string   The SQL string
	 * @param array	 $previous The result of the previous getNextToken() call
	 *
	 * @return Array An associative array containing the type and value of the token.
	 */
	protected static function getNextToken($string, $previous = null)
	{
		// Whitespace
		if (preg_match('/^\s+/',$string,$matches)) {
			return array(
				self::TOKEN_VALUE => $matches[0],
				self::TOKEN_TYPE=>self::TOKEN_TYPE_WHITESPACE
			);
		}

		// Comment
		if ($string[0] === '#' || (isset($string[1])&&($string[0]==='-'&&$string[1]==='-') || ($string[0]==='/'&&$string[1]==='*'))) {
			// Comment until end of line
			if ($string[0] === '-' || $string[0] === '#') {
				$last = strpos($string, "\n");
				$type = self::TOKEN_TYPE_COMMENT;
			} else { // Comment until closing comment tag
				$last = strpos($string, "*/", 2) + 2;
				$type = self::TOKEN_TYPE_BLOCK_COMMENT;
			}

			if ($last === false) {
				$last = strlen($string);
			}

			return array(
				self::TOKEN_VALUE => substr($string, 0, $last),
				self::TOKEN_TYPE  => $type
			);
		}

		// Quoted String
		if ($string[0]==='"' || $string[0]==='\'' || $string[0]==='`' || $string[0]==='[') {
			$return = array(
				self::TOKEN_TYPE => (($string[0]==='`' || $string[0]==='[')? self::TOKEN_TYPE_BACKTICK_QUOTE : self::TOKEN_TYPE_QUOTE),
				self::TOKEN_VALUE => self::getQuotedString($string)
			);

			return $return;
		}

		// User-defined Variable
		if (($string[0] === '@' || $string[0] === ':') && isset($string[1])) {
			$ret = array(
				self::TOKEN_VALUE => null,
				self::TOKEN_TYPE => self::TOKEN_TYPE_VARIABLE
			);

			// If the variable name is quoted
			if ($string[1]==='"' || $string[1]==='\'' || $string[1]==='`') {
				$ret[self::TOKEN_VALUE] = $string[0].self::getQuotedString(substr($string,1));
			}
			// Non-quoted variable name
			else {
				preg_match('/^('.$string[0].'[a-zA-Z0-9\._\$]+)/',$string,$matches);
				if ($matches) {
					$ret[self::TOKEN_VALUE] = $matches[1];
				}
			}

			if($ret[self::TOKEN_VALUE] !== null) return $ret;
		}

		// Number (decimal, binary, or hex)
		if (preg_match('/^([0-9]+(\.[0-9]+)?|0x[0-9a-fA-F]+|0b[01]+)($|\s|"\'`|'.self::$regex_boundaries.')/',$string,$matches)) {
			return array(
				self::TOKEN_VALUE => $matches[1],
				self::TOKEN_TYPE=>self::TOKEN_TYPE_NUMBER
			);
		}

		// Boundary Character (punctuation and symbols)
		if (preg_match('/^('.self::$regex_boundaries.')/',$string,$matches)) {
			return array(
				self::TOKEN_VALUE => $matches[1],
				self::TOKEN_TYPE  => self::TOKEN_TYPE_BOUNDARY
			);
		}

		// A reserved word cannot be preceded by a '.'
		// this makes it so in "mytable.from", "from" is not considered a reserved word
		if (!$previous || !isset($previous[self::TOKEN_VALUE]) || $previous[self::TOKEN_VALUE] !== '.') {
			$upper = strtoupper($string);
			// Top Level Reserved Word
			if (preg_match('/^('.self::$regex_reserved_toplevel.')($|\s|'.self::$regex_boundaries.')/', $upper,$matches)) {
				return array(
					self::TOKEN_TYPE=>self::TOKEN_TYPE_RESERVED_TOPLEVEL,
					self::TOKEN_VALUE=>substr($string,0,strlen($matches[1]))
				);
			}
			// Newline Reserved Word
			if (preg_match('/^('.self::$regex_reserved_newline.')($|\s|'.self::$regex_boundaries.')/', $upper,$matches)) {
				return array(
					self::TOKEN_TYPE=>self::TOKEN_TYPE_RESERVED_NEWLINE,
					self::TOKEN_VALUE=>substr($string,0,strlen($matches[1]))
				);
			}
			// Other Reserved Word
			if (preg_match('/^('.self::$regex_reserved.')($|\s|'.self::$regex_boundaries.')/', $upper,$matches)) {
				return array(
					self::TOKEN_TYPE=>self::TOKEN_TYPE_RESERVED,
					self::TOKEN_VALUE=>substr($string,0,strlen($matches[1]))
				);
			}
		}

		// A function must be suceeded by '('
		// this makes it so "count(" is considered a function, but "count" alone is not
		$upper = strtoupper($string);
		// function
		if (preg_match('/^('.self::$regex_function.'[(]|\s|[)])/', $upper,$matches)) {
			return array(
				self::TOKEN_TYPE=>self::TOKEN_TYPE_RESERVED,
				self::TOKEN_VALUE=>substr($string,0,strlen($matches[1])-1)
			);
		}

		// Non reserved word
		preg_match('/^(.*?)($|\s|["\'`]|'.self::$regex_boundaries.')/',$string,$matches);

		return array(
			self::TOKEN_VALUE => $matches[1],
			self::TOKEN_TYPE  => self::TOKEN_TYPE_WORD
		);
	}

	protected static function getQuotedString($string)
	{
		$ret = null;

		// This checks for the following patterns:
		// 1. backtick quoted string using `` to escape
		// 2. square bracket quoted string (SQL Server) using ]] to escape
		// 3. double quoted string using "" or \" to escape
		// 4. single quoted string using '' or \' to escape
		if ( preg_match('/^(((`[^`]*($|`))+)|((\[[^\]]*($|\]))(\][^\]]*($|\]))*)|(("[^"\\\\]*(?:\\\\.[^"\\\\]*)*("|$))+)|((\'[^\'\\\\]*(?:\\\\.[^\'\\\\]*)*(\'|$))+))/s', $string, $matches)) {
			$ret = $matches[1];
		}

		return $ret;
	}

	/**
	 * Takes a SQL string and breaks it into tokens.
	 * Each token is an associative array with type and value.
	 *
	 * @param String $string The SQL string
	 *
	 * @return Array An array of tokens.
	 */
	protected static function tokenize($string)
	{
		self::init();

		$tokens = array();

		// Used for debugging if there is an error while tokenizing the string
		$original_length = strlen($string);

		// Used to make sure the string keeps shrinking on each iteration
		$old_string_len = strlen($string) + 1;

		$token = null;

		$current_length = strlen($string);

		// Keep processing the string until it is empty
		while ($current_length) {
			// If the string stopped shrinking, there was a problem
			if ($old_string_len <= $current_length) {
				$tokens[] = array(
					self::TOKEN_VALUE=>$string,
					self::TOKEN_TYPE=>self::TOKEN_TYPE_ERROR
				);

				return $tokens;
			}
			$old_string_len =  $current_length;

			// Determine if we can use caching
			if ($current_length >= self::$max_cachekey_size) {
				$cacheKey = substr($string,0,self::$max_cachekey_size);
			} else {
				$cacheKey = false;
			}

			// See if the token is already cached
			if ($cacheKey && isset(self::$token_cache[$cacheKey])) {
				// Retrieve from cache
				$token = self::$token_cache[$cacheKey];
				$token_length = strlen($token[self::TOKEN_VALUE]);
				self::$cache_hits++;
			} else {
				// Get the next token and the token type
				$token = self::getNextToken($string, $token);
				$token_length = strlen($token[self::TOKEN_VALUE]);
				self::$cache_misses++;

				// If the token is shorter than the max length, store it in cache
				if ($cacheKey && $token_length < self::$max_cachekey_size) {
					self::$token_cache[$cacheKey] = $token;
				}
			}

			$tokens[] = $token;

			// Advance the string
			$string = substr($string, $token_length);

			$current_length -= $token_length;
		}

		return $tokens;
	}

	/**
	 * Format the whitespace in a SQL string to make it easier to read.
	 *
	 * @param String  $string	 The SQL string
	 * @param boolean $highlight If true, syntax highlighting will also be performed
	 *
	 * @return String The SQL string with HTML styles and formatting wrapped in a 
 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;
		$inline_count = 0;
		$inline_indented = false;
		$clause_limit = false;

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

		// Remove existing whitespace
		$tokens = array();
		foreach ($original_tokens as $i=>$token) {
			if ($token[self::TOKEN_TYPE] !== self::TOKEN_TYPE_WHITESPACE) {
				$token['i'] = $i;
				$tokens[] = $token;
			}
		}

		// Format token by token
		foreach ($tokens as $i=>$token) {
			// 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');
			}

			// 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;
			}

			// 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) {
					$indent = str_repeat($tab,$indent_level);
					$return .= "\n" . $indent;
					$highlighted = str_replace("\n","\n".$indent,$highlighted);
				}

				$return .= $highlighted;
				$newline = true;
				continue;
			}

			if ($inline_parentheses) {
				// End of inline parentheses
				if ($token[self::TOKEN_VALUE] === ')') {
					$return = rtrim($return,' ');

					if ($inline_indented) {
						array_shift($indent_types);
						$indent_level --;
						$return .= "\n" . str_repeat($tab, $indent_level);
					}

					$inline_parentheses = false;

					$return .= $highlighted . ' ';
					continue;
				}

				if ($token[self::TOKEN_VALUE] === ',') {
					if ($inline_count >= 30) {
						$inline_count = 0;
						$newline = true;
					}
				}

				$inline_count += strlen($token[self::TOKEN_VALUE]);
			}

			// 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
				$length = 0;
				for ($j=1;$j<=250;$j++) {
					// Reached end of string
					if (!isset($tokens[$i+$j])) break;

					$next = $tokens[$i+$j];

					// Reached closing parentheses, able to inline it
					if ($next[self::TOKEN_VALUE] === ')') {
						$inline_parentheses = true;
						$inline_count = 0;
						$inline_indented = false;
						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_RESERVED_TOPLEVEL || $next[self::TOKEN_TYPE]===self::TOKEN_TYPE_RESERVED_NEWLINE || $next[self::TOKEN_TYPE]===self::TOKEN_TYPE_COMMENT || $next[self::TOKEN_TYPE]===self::TOKEN_TYPE_BLOCK_COMMENT) {
						break;
					}

					$length += strlen($next[self::TOKEN_VALUE]);
				}

				if ($inline_parentheses && $length > 30) {
					$increase_block_indent = true;
					$inline_indented = true;
					$newline = true;
				}

				// Take out the preceding space unless there was whitespace there in the original query
				if (isset($original_tokens[$token['i']-1]) && $original_tokens[$token['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,' ');

				$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);
				}
			}

			// Top level reserved words start a new line and increase the special indent level
			elseif ($token[self::TOKEN_TYPE] === self::TOKEN_TYPE_RESERVED_TOPLEVEL) {
				$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 top level reserved word
				$newline = true;
				// Add a newline before the top level 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 SQL 'LIMIT' clause, start variable to reset newline
				if ($token[self::TOKEN_VALUE] === 'LIMIT' && !$inline_parentheses) {
					$clause_limit = true;
				}
			}

			// Checks if we are out of the limit clause
			elseif ($clause_limit && $token[self::TOKEN_VALUE] !== "," && $token[self::TOKEN_TYPE] !== self::TOKEN_TYPE_NUMBER && $token[self::TOKEN_TYPE] !== self::TOKEN_TYPE_WHITESPACE) {
				$clause_limit = false;
			}

			// Commas start a new line (unless within inline parentheses or SQL 'LIMIT' clause)
			elseif ($token[self::TOKEN_VALUE] === ',' && !$inline_parentheses) {
				//If the previous TOKEN_VALUE is 'LIMIT', resets new line
				if ($clause_limit === true) {
					$newline = false;
					$clause_limit = false;
				}
				// All other cases of commas
				else {
					$newline = true;
				}
			}

			// Newline reserved words start a new line
			elseif ($token[self::TOKEN_TYPE] === self::TOKEN_TYPE_RESERVED_NEWLINE) {
				// Add a newline before the reserved word (if not already added)
				if (!$added_newline) {
					$return .= "\n" . 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);
				}
			}

			// Multiple boundary characters in a row should not have spaces between them (not including parentheses)
			elseif ($token[self::TOKEN_TYPE] === self::TOKEN_TYPE_BOUNDARY) {
				if (isset($tokens[$i-1]) && $tokens[$i-1][self::TOKEN_TYPE] === self::TOKEN_TYPE_BOUNDARY) {
					if (isset($original_tokens[$token['i']-1]) && $original_tokens[$token['i']-1][self::TOKEN_TYPE] !== self::TOKEN_TYPE_WHITESPACE) {
						$return = rtrim($return,' ');
					}
				}
			}

			// 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 this is the "-" of a negative number, it shouldn't have a space after it
			if($token[self::TOKEN_VALUE] === '-' && isset($tokens[$i+1]) && $tokens[$i+1][self::TOKEN_TYPE] === self::TOKEN_TYPE_NUMBER && isset($tokens[$i-1])) {
				$prev = $tokens[$i-1][self::TOKEN_TYPE];
				if($prev !== self::TOKEN_TYPE_QUOTE && $prev !== self::TOKEN_TYPE_BACKTICK_QUOTE && $prev !== self::TOKEN_TYPE_WORD && $prev !== self::TOKEN_TYPE_NUMBER) {
					$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 = self::output($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 self::output($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];
		}
		$result = self::format( $result,false);

		return $result;
	}

	/**
	 * Compress a query by collapsing white space and removing comments
	 *
	 * @param String $string The SQL string
	 *
	 * @return String The SQL string without comments
	 */
	public static function compress($string)
	{
		$result = '';

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

		$whitespace = true;
		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;
			}
			// Remove extra whitespace in reserved words (e.g "OUTER	 JOIN" becomes "OUTER JOIN")
			elseif ($token[self::TOKEN_TYPE] === self::TOKEN_TYPE_RESERVED || $token[self::TOKEN_TYPE] === self::TOKEN_TYPE_RESERVED_NEWLINE || $token[self::TOKEN_TYPE] === self::TOKEN_TYPE_RESERVED_TOPLEVEL) {
				$token[self::TOKEN_VALUE] = preg_replace('/\s+/',' ',$token[self::TOKEN_VALUE]);
			}

			if ($token[self::TOKEN_TYPE] === self::TOKEN_TYPE_WHITESPACE) {
				// If the last token was whitespace, don't add another one
				if ($whitespace) {
					continue;
				} else {
					$whitespace = true;
					// Convert all whitespace to a single space
					$token[self::TOKEN_VALUE] = ' ';
				}
			} else {
				$whitespace = false;
			}

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

		return rtrim($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];

		if (self::is_cli()) {
			$token = $token[self::TOKEN_VALUE];
		} else {
			if (defined('ENT_IGNORE')) {
			  $token = htmlentities($token[self::TOKEN_VALUE],ENT_COMPAT | ENT_IGNORE ,'UTF-8');
			} else {
			  $token = htmlentities($token[self::TOKEN_VALUE],ENT_COMPAT,'UTF-8');
			}
		}

		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_RESERVED_TOPLEVEL) {
			return self::highlightReservedWord($token);
		} elseif ($type===self::TOKEN_TYPE_RESERVED_NEWLINE) {
			return self::highlightReservedWord($token);
		} elseif ($type===self::TOKEN_TYPE_NUMBER) {
			return self::highlightNumber($token);
		} elseif ($type===self::TOKEN_TYPE_VARIABLE) {
			return self::highlightVariable($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)
	{
		if (self::is_cli()) {
			return self::$cli_quote . $value . "\x1b[0m";
		} else {
			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)
	{
		if (self::is_cli()) {
			return self::$cli_backtick_quote . $value . "\x1b[0m";
		} else {
			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)
	{
		if (self::is_cli()) {
			return self::$cli_reserved . $value . "\x1b[0m";
		} else {
			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;

		if (self::is_cli()) {
			return self::$cli_boundary . $value . "\x1b[0m";
		} else {
			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)
	{
		if (self::is_cli()) {
			return self::$cli_number . $value . "\x1b[0m";
		} else {
			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)
	{
		if (self::is_cli()) {
			return self::$cli_error . $value . "\x1b[0m";
		} else {
			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)
	{
		if (self::is_cli()) {
			return self::$cli_comment . $value . "\x1b[0m";
		} else {
			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)
	{
		if (self::is_cli()) {
			return self::$cli_word . $value . "\x1b[0m";
		} else {
			return '' . $value . '';
		}
	}

	/**
	 * Highlights a variable token
	 *
	 * @param String $value The token's value
	 *
	 * @return String HTML code of the highlighted token.
	 */
	protected static function highlightVariable($value)
	{
		if (self::is_cli()) {
			return self::$cli_variable . $value . "\x1b[0m";
		} else {
			return '' . $value . '';
		}
	}

	/**
	 * 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,'/');
	}

	/**
	 * Helper function for building string output
	 *
	 * @param String $string The string to be quoted
	 *
	 * @return String The quoted string
	 */
	private static function output($string)
	{
		if (self::is_cli()) {
			return $string."\n";
		} else {
			$string=trim($string);
			if (!self::$use_pre) {
				return $string;
			}

			return '
' . $string . '
';
		}
	}

	private static function is_cli()
	{
		if (isset(self::$cli)) return self::$cli;
		else return php_sapi_name() === 'cli';
	}

}