scanner/parser.php

<?php
define( 'PHPPARSER_FETCH_CLASSES',		1 );
define( 'PHPPARSER_FETCH_FUNCTIONS',	2 );
define( 'PHPPARSER_FETCH_CALLS',		4 );
define( 'PHPPARSER_FETCH_INCLUDES',		8 );
define( 'PHPPARSER_FETCH_INTERNAL',		16 );
define( 'PHPPARSER_FETCH_CONSTRUCTS',	32 );
define( 'PHPPARSER_FETCH_EXPRESSIONS',	64 );
define( 'PHPPARSER_FETCH_INLINE_HTML',	128 );

define( 'PHPPARSER_FETCH_ALL',			65535 );

define( 'PHPPARSER_CLASS_DEF',			1 );
define( 'PHPPARSER_FUNCTION_DEF',		2 );
define( 'PHPPARSER_FUNCTION_CALL',		3 );
define( 'PHPPARSER_INCLUDE',			4 );
define( 'PHPPARSER_EXPRESSION',			5 );
define( 'PHPPARSER_LANGUAGE_CONSTRUCT',	6 );
define( 'PHPPARSER_INLINE_HTML',		7 );
define( 'PHPPARSER_VARIABLE',			8 );
define( 'PHPPARSER_ASSIGNMENT',			9 );

class PHPParser {

	var $fetch_mode;
	var $file_name;
	var $internal_functions;
	var $defined_functions;
	var $callbacks;

	function PHPParser( $fetch_mode = PHPPARSER_FETCH_ALL, $functionlist = array() ) {
		$this->reset( $fetch_mode );
		$this->internal_functions = get_defined_functions(); $this->internal_functions = $this->internal_functions['internal'];
		$this->addFunctionDefinitions( $functionlist );
		$this->callbacks = array();
	}

	function reset( $fetch_mode = null ) {
		if( $fetch_mode > 0 ) {
			$this->fetch_mode = $fetch_mode;
		}
		$this->file_name = '';
		$this->defined_functions = array();
	}

	function addFunctionDefinitions( $functionlist ) {
		if( is_array( $functionlist ) ) {
			array_merge( $this->defined_functions, $functionlist );
		}
	}

	function registerCallback( $function_name, $fetch_mode = PHPPARSER_FETCH_ALL ) {
		if( is_callable( $function_name ) ) {
			$this->callbacks[] = array(
				'function' => $function_name,
				'fetch' => $fetch_mode
			);
			return count( $this->callbacks );
		} else {
			return false;
		}
	}
	
	function foundObject( $object ) {
		if( !is_array( $object ) ) {
			// Now how the hell did that happen?
			return false;
		}
		foreach( $this->callbacks as $callback ) {
			call_user_func( $callback['function'], $object );
		}
	}
	
	function parseFile( $file ) {
		if( !file_exists( $file ) || !is_readable( $file ) ) { return false; }
		$this->file_name = $file;
		$this->parse( file_get_contents( $file ) );
	}

	function parse( $content ) {
		$tokens = token_get_all( $content );
		$lines = preg_split( '/\r?(\n|\r)/', $content );
		$line = 1;
		$depth = 0;
		$block = 0;
		$block_count = 0;

		$class = $classname = null;
		$function = $functionname = null;
		$string = $last_token = null;
		$switch = array();
		$expressions = array('');
		$expression = &$expressions[0];
		$assignment = false;
		$line_text = '';

		$internal_functions = get_defined_functions(); $internal_functions = $internal_functions['internal'];
		$local_functions = array();
		$local_classes = array();
		$expression_variables = array(array());
		$variables = &$expression_variables[0];
		$open_blocks = array( 0 );
		$in_string = false;
		$buffer = array(T_INLINE_HTML => '');
		foreach( $tokens as $token ) {
			//echo ( is_string( $token ) ? 'CHAR: ' . $token : token_name( $token[0] ) . ': ' . $token[1] ) . "\n";
			if( !in_array( 0, $open_blocks ) ) {
				//echo "PARSER ERROR: LOST ZERO BLOCK AT FILE {$this->file_name} LINE $line\n";
				$open_blocks = array_merge( array(0), $open_blocks );
			}
			$classname = isset( $class['name'] ) ? $class['name'] : '';
			$functionname = isset( $function['name'] ) ? $function['name'] : '';
			if( $token == '"' ) {
				$in_string = !$in_string;
			}
			if( $in_string ) {
				$expression .= is_string( $token ) ? $token : $token[1];
				$count = preg_match_all( '/\r?(\n|\r)/', is_string( $token ) ? $token : $token[1], $m = array() );
				$line += $count;
				continue;
			}
			if( is_string( $token ) ) {
				// Single character token
				$text = $token;
				switch( $token ) {
					case '{':
						$block_count++;
						$block = $block_count;
						array_push( $open_blocks, $block );
						$depth = count( $open_blocks ) - 1;
						break;
					case '}':
						array_pop( $open_blocks );
						$depth = count( $open_blocks ) - 1;
						$block = $depth == 0 ? 0 : ( isset( $open_blocks[$depth] ) ? $open_blocks[$depth] : 0 );
						if( !empty( $class ) && $class['block'] == $block ) { $class = $functionname = null; }
						if( !empty( $function ) && $function['block'] == $block ) { $function = $functionname = null; }
						if( in_array( $block, $switch ) ) {
							array_pop( $open_blocks );
							$depth = count( $open_blocks ) - 1;
							$block = $depth == 0 ? 0 : $open_blocks[$depth-1];
						}
						break;
					case '(':
						if(
							(bool)($this->fetch_mode & PHPPARSER_FETCH_CALLS)
							&& !empty( $string )
							&& $last_token != T_FUNCTION
							&& $last_token != T_OBJECT_OPERATOR
							&& $last_token != T_DOUBLE_COLON
							&& $last_token != T_NEW
							//&& ( (bool)($this->fetch_mode & PHPPARSER_FETCH_INTERNAL) && !in_array( $string, $this->internal_functions ) )
						) {
							$this->foundObject( array(
								'type'		  => PHPPARSER_FUNCTION_CALL,
								'name'		  => strtolower( $string ),
								'file'		  => $this->file_name,
								'context'	  => $lines[$line - 1],
								'line'		  => $line,
								'block'		 => $block,
								'depth'		 => $depth,
								'in_class'		  => $classname,
								'in_function'   => $functionname,
								'open_blocks'   => $open_blocks
							) );
						}
						break;
					case ')':
						$in_function_params = false;
						$in_foreach_params = false;
						$in_list = false;
						break;
					case '[':
						$expressions[] = '';
						$expression_variables[] = array();
						$variables = &$expression_variables[count($expression_variables) - 1];
						break;
					case ']':
						/*
							TODO: Subexpression reporting is NOT quite as accurate as it should be...
							See the unit test failure for an example. The assigned variable is reported fine, which is good,
							but the value it is assigned will not be. Since this isn't awfully important, and the fact that
							everything else does is, I'm leaving this as-is for now.
						*/
						$e = array_pop($expressions);
						$expression = &$expressions[count($expressions) - 1];
						$expression .= trim($e);
						array_pop($expression_variables);
						$variables = &$expression_variables[count($expression_variables) - 1];
						$variables[count($variables) - 1] = end($variables) . '[' . trim($e) . ']';
						break;
					default:
						/*	Should be able to add a hook here later on to catch the use of defines,
							which are basically just T_STRINGs that PHP can't find anything else to
							do with. That could be useful in determining whether a define is defined.
						*/
						$string = null;
						break;
				}
				if (
					(bool)($this->fetch_mode & PHPPARSER_FETCH_EXPRESSIONS)
					&& (
						(($in_function_params || $in_foreach_params) && in_array( $token, array( '{', '}', '(', ')', ';', ',', '?', ':' ) ))
						|| in_array( $token, array( '{', '}', ';', '=', '?', ':' ) )
					)
				) {
					$expression = trim($expression);
					if ($assignment) {
						// If this was a list assignment, we've got an array of variables to mark as assigned at once!
						$variable = is_array($assignment) ? $assignment : array($assignment);
						foreach ($variable as $var) {
							$this->foundObject( array(
								'type'		  => PHPPARSER_ASSIGNMENT,
								'name'		  => "$var=$expression",
								'file'		  => $this->file_name,
								'context'	  => $lines[$line - 1],
								'line'		  => $line,
								'block'		 => $block,
								'depth'		 => $depth,
								'in_class'		  => $classname,
								'in_function'   => $functionname
							) );
						}
						$assignment = false;
					}
					elseif (strlen($expression) > 0) {
						foreach($variables as $var) {
						}
						$this->foundObject( array(
							'type'		  => PHPPARSER_EXPRESSION,
							'name'		  => $expression,
							'file'		  => $this->file_name,
							'context'	  => $lines[$line - 1],
							'line'		  => $line,
							'block'		 => $block,
							'depth'		 => $depth,
							'in_class'		  => $classname,
							'in_function'   => $functionname,
							'open_blocks'   => $open_blocks
						) );
					}
					$expression = '';
					$variable_declaration = false;
					$assignment = ('=' == $token ? array_pop($variables) : false);
					while (count($variables) > 0) {
						$variable = array_pop($variables);
						$this->foundObject( array(
							'type'		  => PHPPARSER_VARIABLE,
							'name'		  => $variable,
							'file'		  => $this->file_name,
							'context'	  => $lines[$line - 1],
							'line'		  => $line,
							'block'		 => $block,
							'depth'		 => $depth,
							'in_class'		  => $classname,
							'in_function'   => $functionname
						) );
					}
				} else { $expression .= $token; }
				if ($expression !== end($expressions))
					$expression = &$expressions[count($expressions) - 1];
				if( !empty($buffer[T_INLINE_HTML]) && (bool)($this->fetch_mode & PHPPARSER_FETCH_INLINE_HTML) ) {
					$this->foundObject( array(
						'type'		  => PHPPARSER_INLINE_HTML,
						'name'		  => $buffer[T_INLINE_HTML],
						'file'		  => $this->file_name,
						'context'	  => $lines[$line - 1],
						'line'		  => $line,
						'block'		 => $block,
						'depth'		 => $depth,
						'in_class'		  => $classname,
						'in_function'   => $functionname
					) );
					$buffer[T_INLINE_HTML] = '';
					if( !in_array( $token, array( '(', ')' ) ) ) { $last_token = null; }
				}
			} else {
				list($id, $text) = $token;
				switch( $id ) {
					case T_CURLY_OPEN:
					case T_DOLLAR_OPEN_CURLY_BRACES:
						$block_count++;
						$block = $block_count;
						array_push( $open_blocks, $block );
						$depth = count( $open_blocks ) - 1;
						break;
					case T_STRING:
						$string = $text;
						switch( $last_token ) {
							case T_CLASS:
								if( (bool)($this->fetch_mode & PHPPARSER_FETCH_CLASSES) ) {
									$this->foundObject( array(
										'type'		  => PHPPARSER_CLASS_DEF,
										'name'		  => strtolower( $string ),
										'file'		  => $this->file_name,
										'context'	  => $lines[$line - 1],
										'line'		  => $line,
										'block'		 => $block,
										'depth'		 => $depth,
										'in_class'		  => $classname,
										'in_function'   => $functionname
									) );
								}
								$class = array( 'name' => $text, 'block' => $block );
								break;
							case T_FUNCTION:
								$variable_declaration = false;
								if( (bool)($this->fetch_mode & PHPPARSER_FETCH_FUNCTIONS) && empty( $classname ) ) { // Not interested in member function definitions
									$this->foundObject( array(
										'type'		  => PHPPARSER_FUNCTION_DEF,
										'name'		  => strtolower( $string ),
										'file'		  => $this->file_name,
										'context'	  => $lines[$line],
										'line'		  => $line,
										'block'		 => $block,
										'depth'		 => $depth,
										'in_class'		  => $classname,
										'in_function'   => $functionname
									) );
								}
								$function = array( 'name' => $text, 'block' => $block );
								$in_function_params = true;
								break;
						}
						break;
					case T_CONSTANT_ENCAPSED_STRING:
						switch( $last_token ) {
							case T_INCLUDE:
							case T_INCLUDE_ONCE:
							case T_REQUIRE:
							case T_REQUIRE_ONCE:
								if( (bool)($this->fetch_mode & PHPPARSER_FETCH_INCLUDES) ) {
									$this->foundObject( array(
										'type'		  => PHPPARSER_INCLUDE,
										'name'		  => trim( str_replace( '\'', '', $text ) ),
										'file'		  => $this->file_name,
										'context'	  => $lines[$line - 1],
										'line'		  => $line,
										'block'		 => $block,
										'depth'		 => $depth,
										'in_class'		  => $classname,
										'in_function'   => $functionname
									) );
								}
								break;
						}
						break;
					case T_GLOBAL:
					case T_VAR:
					case T_PRIVATE:
					case T_PUBLIC:
					case T_PROTECTED:
					case T_STATIC:
						$variable_declaration = true;
						break;
					case T_LIST:
						$in_list = true;
						$variables[] = array();
						break;
					case T_VARIABLE:
						if ($in_list) {
							/*
								TODO: Proper fix for this.
								Has to do with the less-than-perfect sub-expressions. If an entry in a list() is a keyed value of an array (i.e. $var[$key]),
								everything sort of falls apart.
							*/
							if (!is_array($variables[count($variables) - 1]) )
								$variables[count($variables) - 1] = array(end($variables));
							$variables[count($variables) - 1][] = $text;
						} else {
							$variables[] = $text;
						}
						if( (bool)($this->fetch_mode & PHPPARSER_FETCH_EXPRESSIONS) ) {
							if (
								$variable_declaration
								|| in_array($last_token, array(T_AS))
								|| ($in_foreach_params && T_DOUBLE_ARROW == $last_token)
								|| $in_function_params
							) {
								$this->foundObject( array(
									'type'		  => PHPPARSER_ASSIGNMENT,
									'name'		  => "$text=$text",
									'file'		  => $this->file_name,
									'context'	  => $lines[$line - 1],
									'line'		  => $line,
									'block'		 => $block,
									'depth'		 => $depth,
									'in_class'		  => $classname,
									'in_function'   => $functionname
								) );
							}
						}
						break;
					///*
					case T_SWITCH:
						$block_count++;
						$block = $block_count;
						array_push( $open_blocks, $block );
						$depth = count( $open_blocks ) - 1;
						$switch[$block] = $block;
						break;
					case T_CASE:
					case T_DEFAULT:
						// Each conditional of a switch statement is its own block
						array_pop( $open_blocks );
						$block_count++;
						$block = $block_count;
						array_push( $open_blocks, $block );
						$depth = count( $open_blocks ) - 1;
						break;
					case T_AS:
						$in_foreach_params = true;
						break;
					case T_INLINE_HTML:
						// NOTE: There seems to be a string limit of around 400 characters, which is very easy to reach with this token
						// We'll get around it by combining adjacent token results
						$buffer[T_INLINE_HTML] .= $text;
						break;
					//*/
				}
				if( !in_array( $id, array( T_WHITESPACE, /*T_COMMENT, T_DOC_COMMENT,*/ T_STRING ) ) ) { $string = null; $last_token = $id; }
				if( (bool)($this->fetch_mode & PHPPARSER_FETCH_CONSTRUCTS) && in_array( $id, array(
					T_ARRAY,
					T_ECHO,
					T_EMPTY,
					T_EVAL,
					T_EXIT,
					T_HALT_COMPILER,
					T_INCLUDE,
					T_INCLUDE_ONCE,
					T_ISSET,
					T_LIST,
					T_PRINT,
					T_REQUIRE,
					T_REQUIRE_ONCE,
					T_UNSET
				) ) ) {
					$this->foundObject( array(
						'type'		  => PHPPARSER_LANGUAGE_CONSTRUCT,
						'name'		  => $text,
						'file'		  => $this->file_name,
						'context'	  => $lines[$line - 1],
						'line'		  => $line,
						'block'		 => $block,
						'depth'		 => $depth,
						'in_class'		  => $classname,
						'in_function'   => $functionname
					) );
				}
				$expression .= ( in_array( $id, array(
						/* Values */
						T_STRING,
						T_CHARACTER,
						T_CONSTANT_ENCAPSED_STRING,
						T_ENCAPSED_AND_WHITESPACE,
						T_WHITESPACE,
						T_DNUMBER,
						T_LNUMBER,
						T_NUM_STRING,
						T_VARIABLE,
						//T_ARRAY,
						T_STRING_VARNAME,
						
						/* Operators */
						T_BOOLEAN_AND,
						T_BOOLEAN_OR,
						T_DEC,
						T_INC,
						T_IS_EQUAL,
						T_IS_GREATER_OR_EQUAL,
						T_IS_IDENTICAL,
						T_IS_NOT_EQUAL,
						T_IS_NOT_IDENTICAL,
						T_IS_SMALLER_OR_EQUAL,
						T_LOGICAL_AND,
						T_LOGICAL_OR,
						T_LOGICAL_XOR,
						T_OBJECT_OPERATOR,
						T_DOUBLE_COLON,
						T_SL,
						T_SR,
						
						/* Casts */
						T_DOUBLE_CAST,
						T_INT_CAST,
						T_OBJECT_CAST,
						T_STRING_CAST,
						T_UNSET_CAST,
						
						/* Constructs */
						T_ECHO,
						T_PRINT
					) ) ) ? $text : ' ';
				if( (bool)($this->fetch_mode & PHPPARSER_FETCH_EXPRESSIONS) && in_array( $id, array( T_CLOSE_TAG ) ) && strlen( trim( $expression ) ) > 0 ) {
					$this->foundObject( array(
						'type'		  => PHPPARSER_EXPRESSION,
						'name'		  => trim( $expression ),
						'file'		  => $this->file_name,
						'context'	  => $lines[$line - 1],
						'line'		  => $line,
						'block'		 => $block,
						'depth'		 => $depth,
						'in_class'		  => $classname,
						'in_function'   => $functionname,
						'open_blocks'   => $open_blocks
					) );
					$expression = '';
				}
				if( $id != T_INLINE_HTML && !empty($buffer[T_INLINE_HTML]) && (bool)($this->fetch_mode & PHPPARSER_FETCH_INLINE_HTML) ) {
					$this->foundObject( array(
						'type'		  => PHPPARSER_INLINE_HTML,
						'name'		  => $buffer[T_INLINE_HTML],
						'file'		  => $this->file_name,
						'context'	  => $lines[$line - 1],
						'line'		  => $line,
						'block'		 => $block,
						'depth'		 => $depth,
						'in_class'		  => $classname,
						'in_function'   => $functionname
					) );
					$buffer[T_INLINE_HTML] = '';
				}
				$count = preg_match_all( '/\r?(\n|\r)/', $text, $m );
				$line += $count;
			}
		}
	}
}
?>