<?PHP
require_once('Function/ChangeUser.php');
require_once('Function/Connect.php');
require_once('Function/ConnParam.php');
require_once('Function/ConnParamBool.php');
require_once('Function/CreateDB.php');
require_once('Function/DBQuery.php');
require_once('Function/DropDB.php');
require_once('Function/Error.php');
require_once('Function/EscapeString.php');
require_once('Function/FetchField.php');
require_once('Function/FieldFlags.php');
require_once('Function/FieldLen.php');
require_once('Function/FieldName.php');
require_once('Function/FieldTable.php');
require_once('Function/FieldType.php');
require_once('Function/FreeResult.php');
require_once('Function/Generic.php');
require_once('Function/GenericBoolean.php');
require_once('Function/ListDBs.php');
require_once('Function/ListFields.php');
require_once('Function/ListProcesses.php');
require_once('Function/ListTables.php');
require_once('Function/ParReversed.php');
require_once('Function/RealEscapeString.php');
require_once('Function/SelectDB.php');
require_once('Function/Tablename.php');
require_once('Function/UnbufferedQuery.php');

/**
* ext/mysql->ext/mysqli Converter
*
* @category   Converter
* @package    MySQLConverterTool
* @author     Andrey Hristov <andrey@php.net>, Ulf Wendel <ulf.wendel@phpdoc.de>, Saif Lacrimosa <cool2309@gmail.com>
* @copyright  1997-2006 The PHP Group
* @license    http://www.php.net/license/3_0.txt  PHP License 3.0
* @version    CVS: $Id:$, Release: @package_version@
* @link       http://www.mysql.com
* @since      Class available since Release 1.0
*/
class MySQLConverterTool_Converter {
    
    // 
    // protected
    //
    
    /**
    * Scanner state constant
    * 
    * @const
    * @access protected
    */
    const STATE_NORMAL        = 'normal_state';
    
    
    /**
    * Scanner state constant
    *
    * @const
    * @access protected
    */
    const STATE_FUNC_FOUND    = 'func_found';
    
    
    /**
    * Scanner state constant
    *
    * @const
    * @access protected
    */
    const STATE_PARAM_LIST  = 'parameter_list';
    

    /**
    * Converted (= resulting) source code
    * 
    * @var  string
    */    
    protected $output = '';
        
    
    /**
    * List of errors which occured during the conversion
    *
    * @var  array
    */
    protected $errors = array();
    

    /**
    * List of PHP token
    *
    * @var  string
    */
    protected $tokens = array();
        
    
    /**
    * Mapping of ext/mysql -> ext/mysqli constants
    *
    */
    protected $mysql_ext_consts = array(
        'MYSQL_CLIENT_COMPRESS'         => 'MYSQLI_CLIENT_COMPRESS',
        'MYSQL_CLIENT_IGNORE_SPACE'     => 'MYSQLI_CLIENT_IGNORE_SPACE',
        'MYSQL_CLIENT_INTERACTIVE'      => 'MYSQLI_CLIENT_INTERACTIVE',
        'MYSQL_CLIENT_SSL'              => 'MYSQLI_CLIENT_SSL',
        'MYSQL_ASSOC'                   => 'MYSQLI_ASSOC',
        'MYSQL_BOTH'                    => 'MYSQLI_BOTH',
        'MYSQL_NUM'                     => 'MYSQLI_NUM',        
    );

       
    /**
    * Number of functions found in the given source
    * 
    * @var  int
    */
    protected $funcs_found = 0;
        
    
    /**
    * Number of functions converted in the given source
    *
    * @var  int
    */
    protected $funcs_converted = 0;
        
    
    /**
    * List of functions that are not supported
    *
    * @var array
    */
    protected $mysql_funcs_not_supported = array(
            // rewrite the ugly mysql_result calls manually!
            'mysql_result'          => true,
            // whatever that function is...
            'mysql_fetch_field2'    => true,    
        );
      
          
    /**
    * List of functions that can be converted
    *
    * Acts as kind of a function pointer list, but with objects
    *
    * @var  array
    */
    protected $mysql_funcs = array();
     
       
    /**
    * Flag: enable token debug output?
    *
    * @var  bool
    */
    protected $debug_dump_tokens = false;
    
    
    /**
    * Flag: enable parameter parsing debug output?
    * 
    * @var  bool
    */
    protected $debug_dump_params = false;
    
    
    /**
    * Current line number during the parsing process
    *
    * @var  int
    */
    protected $lineno = 0;
    
    
    //
    // public
    //

    
    /**
    *
    *
    * @param    bool    Turn on debug output of scanner token?
    * @param    bool    Turn on debug output of function parameters?
    */
    public function __construct($debug_token = false, $debug_params = false) {
        
        if (!function_exists('token_name')) {
            // HACK FIXME
            die('ext/tokenizer is needed!\n');
        }

        if (!defined('T_ML_COMMENT'))
            define('T_ML_COMMENT', T_COMMENT);
            
        if (!defined('T_DOC_COMMENT'))            
            define('T_DOC_COMMENT', T_ML_COMMENT);
            
        if (!defined('T_SIMPLE_TOKEN'))            
            define('T_SIMPLE_TOKEN', 32567);
        
        $this->debug_dump_tokens = $debug_token;
        $this->debug_dump_params = $debug_params;    
		  
        $this->mysql_funcs = 
            array(                                
                // PHP_FALIAS(mysql,				mysql_db_query,		NULL)
                'mysql'                     => new MySQLConverterTool_Function_DBQuery(), 
                // in OO this is a property
                'mysql_affected_rows'       => new MySQLConverterTool_Function_ConnParam('mysqli_affected_rows'),   
                'mysql_change_user'         => new MySQLConverterTool_Function_ChangeUser(),
                'mysql_client_encoding'     => new MySQLConverterTool_Function_ConnParam('mysqli_character_set_name'),
                'mysql_close'               => new MySQLConverterTool_Function_ConnParamBool('mysqli_close'),
                // pconnect has less params but they are not significant for mysqli_connect                
                'mysql_connect'             => new MySQLConverterTool_Function_Connect(), 
                // PHP_FALIAS(mysql_createdb,		mysql_create_db,	NULL)
                'mysql_createdb'            => new MySQLConverterTool_Function_CreateDB(), 
                'mysql_create_db'           => new MySQLConverterTool_Function_CreateDB(),
                'mysql_data_seek'           => new MySQLConverterTool_Function_Generic('mysqli_data_seek'),
                'mysql_dbname'              => new MySQLConverterTool_Function_Tablename(),
                'mysql_db_name'             => new MySQLConverterTool_Function_Tablename(),
                'mysql_db_query'            => new MySQLConverterTool_Function_DBQuery(),
                // PHP_FALIAS(mysql_dropdb,		mysql_drop_db,		NULL)
                'mysql_dropdb'              => new MySQLConverterTool_Function_DropDB(), 
                'mysql_drop_db'             => new MySQLConverterTool_Function_DropDB(),
                // in OO this is a property
                'mysql_error'               => new MySQLConverterTool_Function_Error('mysqli_error'), 
                // in OO this is a property
                'mysql_errno'               => new MySQLConverterTool_Function_Error('mysqli_errno'), 
                'mysql_escape_string'       => new MySQLConverterTool_Function_EscapeString('mysqli_real_escape_string'),
                'mysql_fetch_array'         => new MySQLConverterTool_Function_Generic('mysqli_fetch_array'),
                'mysql_fetch_assoc'         => new MySQLConverterTool_Function_Generic('mysqli_fetch_assoc'),
                'mysql_fetch_field'         => new MySQLConverterTool_Function_FetchField(),
                'mysql_fetch_lengths'       => new MySQLConverterTool_Function_GenericBoolean('mysqli_fetch_lengths'),
                'mysql_fetch_object'        => new MySQLConverterTool_Function_Generic('mysqli_fetch_object'),
                'mysql_fetch_row'           => new MySQLConverterTool_Function_Generic('mysqli_fetch_row'),
                // PHP_FALIAS(mysql_fieldflags,	mysql_field_flags,	NULL)
                'mysql_fieldflags'          => new MySQLConverterTool_Function_FieldFlags(), 
                'mysql_field_flags'         => new MySQLConverterTool_Function_FieldFlags(),
                // PHP_FALIAS(mysql_fieldlen,		mysql_field_len,	NULL)
                'mysql_fieldlen'            => new MySQLConverterTool_Function_FieldLen(), 
                'mysql_field_len'           => new MySQLConverterTool_Function_FieldLen(),
                // PHP_FALIAS(mysql_fieldname,		mysql_field_name,	NULL)
                'mysql_fieldname'           => new MySQLConverterTool_Function_FieldName(), 
                'mysql_field_name'          => new MySQLConverterTool_Function_FieldName(),
                'mysql_field_seek'          => new MySQLConverterTool_Function_GenericBoolean('mysqli_field_seek'),
                // PHP_FALIAS(mysql_fieldtable,	mysql_field_table,	NULL)
                'mysql_fieldtable'          => new MySQLConverterTool_Function_FieldTable(),
                'mysql_field_table'         => new MySQLConverterTool_Function_FieldTable(), 
                // PHP_FALIAS(mysql_fieldtype,		mysql_field_type,	NULL)
                'mysql_fieldtype'           => new MySQLConverterTool_Function_FieldType(),
                'mysql_field_type'          => new MySQLConverterTool_Function_FieldType(),
                // PHP_FALIAS(mysql_freeresult,	mysql_free_result,	NULL)
                'mysql_freeresult'          => new MySQLConverterTool_Function_FreeResult(), 
                'mysql_free_result'         => new MySQLConverterTool_Function_FreeResult(),
                'mysql_get_client_info'     => new MySQLConverterTool_Function_Generic('mysqli_get_client_info'),
                // in OO this is a property
                'mysql_get_host_info'       => new MySQLConverterTool_Function_ConnParamBool('mysqli_get_host_info'),
                // in OO this is a property
                'mysql_get_proto_info'      => new MySQLConverterTool_Function_ConnParamBool('mysqli_get_proto_info'),
                // in OO this is a property
                'mysql_get_server_info'     => new MySQLConverterTool_Function_ConnParamBool('mysqli_get_server_info'), 
                'mysql_info'                => new MySQLConverterTool_Function_ConnParam('mysqli_info'),
                'mysql_insert_id'           => new MySQLConverterTool_Function_ConnParamBool('mysqli_insert_id'),
                // PHP_FALIAS(mysql_listdbs,		mysql_list_dbs,		NULL)
                'mysql_listdbs'             => new MySQLConverterTool_Function_ListDBs(), 
                'mysql_list_dbs'            => new MySQLConverterTool_Function_ListDBs(),
                // PHP_FALIAS(mysql_listfields,	mysql_list_fields,	NULL)
                'mysql_listfields'          => new MySQLConverterTool_Function_ListFields(), 
                'mysql_list_fields'         => new MySQLConverterTool_Function_ListFields(),
                'mysql_list_processes'      => new MySQLConverterTool_Function_ListProcesses(),
                // PHP_FALIAS(mysql_listtables,	mysql_list_tables,	NULL)
                'mysql_listtables'          => new MySQLConverterTool_Function_ListTables(), 
                'mysql_list_tables'         => new MySQLConverterTool_Function_ListTables(),
                // PHP_FALIAS(mysql_numfields,		mysql_num_fields,	NULL)
                'mysql_numfields'           => new MySQLConverterTool_Function_Generic('mysqli_num_fields'),
                // in OO this is a property
                'mysql_num_fields'          => new MySQLConverterTool_Function_GenericBoolean('mysqli_num_fields'), 
                // PHP_FALIAS(mysql_numrows,		mysql_num_rows,		NULL)
                'mysql_numrows'             => new MySQLConverterTool_Function_Generic('mysqli_num_rows'), 
                // in OO this is a property
                'mysql_num_rows'            => new MySQLConverterTool_Function_Generic('mysqli_num_rows'), 
                // pconnect has less params but they are not significant for mysqli_connect
                'mysql_pconnect'            => new MySQLConverterTool_Function_Connect(), 
                'mysql_ping'                => new MySQLConverterTool_Function_ConnParam('mysqli_ping'),
                'mysql_query'               => new MySQLConverterTool_Function_ParReversed('mysqli_query'),
                'mysql_real_escape_string'  => new MySQLConverterTool_Function_RealEscapeString('mysqli_real_escape_string'),
                // mysql_result -- Get result data
                // PHP_FALIAS(mysql_selectdb,		mysql_select_db,	NULL)
                'mysql_selectdb'            => new MySQLConverterTool_Function_SelectDB(), 
                'mysql_select_db'           => new MySQLConverterTool_Function_SelectDB(), 
                'mysql_stat'                => new MySQLConverterTool_Function_ConnParam('mysqli_stat'),
                'mysql_tablename'           => new MySQLConverterTool_Function_Tablename(),
                'mysql_table_name'          => new MySQLConverterTool_Function_Tablename(),
                'mysql_thread_id'           => new MySQLConverterTool_Function_ConnParam('mysqli_thread_id'),
                'mysql_unbuffered_query'    => new MySQLConverterTool_Function_UnbufferedQuery(),                
            );
            
    } // end func __construct
    
    
    /**
    * Converts the given source code
    *
    * @param    string  Source code to be converted
    * @return   array   Converted source code and status information
    */
    public function convertString($source) {
  
        $this->lineno   = 0;
        $this->output   = '';        
        $this->tokens   = token_get_all($source);
        $this->errors   = array();        
        $this->lineno   = 1;   
        
        $this->funcs_found      = 0;
        $this->funcs_converted  = 0;    

        $this->scanner(0); 
          
        return array(
            'output'    => $this->output,            
            'found'     => $this->funcs_found,
            'converted' => $this->funcs_converted,
            'errors'    => $this->errors,
         );
    } // end func convertString
        
    
    /**
    * Reads a file and returns the converted source code
    * 
    * @param    strng   filename
    * @param    array   Converted source and status information
    */
    public function convertFile($filename) {
        
        if (!file_exists($filename) || !is_readable($filename) || !is_file($filename)) {            
            $ret = $this->convertString('');
            $ret['errors'][] = array('line' => -1, 'msg' => 'Cannot open file "' . $filename . '".');
            return $ret;
        }            
            
        return $this->convertString(file_get_contents($filename));      
    }
    
    
    /**
    * Returns all files of a directory that have a certain name
    *
    *
    */
    public function getFilesOfDirectory($dir, $file_pattern = '*', Array $files = array()) {            
        
        if (!is_dir($dir) || !is_readable($dir))
            return $files;
            
        $patterns = $this->buildRegularExpression($file_pattern);              
        if (empty($patterns))
            return $files;
            
        $dh = opendir($dir);
        if (!$dh)
            return $files;
            
        while ($file = readdir($dh)) {
            if ('.' == $file || '..' == $file)
                continue;

            $ffile = $dir . '/' . $file;                
            if (is_dir($ffile))
                $files = $this->getFilesOfDirectory($ffile, $file_pattern, $files);
                
            if (!is_file($ffile))
                continue;                
            
            $accept = false;                
            foreach ($patterns as $k => $pattern) {
                if (preg_match('@' . $pattern . '$@i', $file)) {
                    $accept = true;
                    break;
                }
            }                    
            
            if ($accept)        
                $files[] = $ffile;
        }
        closedir($dh);
        
        return $files;
    }   
    
    
    /**
    * Unsets the variable which stores the global (default) connection of ext/mysql
    *
    * This is a hack required by the test framework.
    * 
    */
    public function unsetGlobalConnection() {
        
        $obj = new MySQLConverterTool_Function_Generic('mysqli_query');
        eval(sprintf('@mysqli_close(%s);', $obj->ston_name));        
        eval(sprintf('if (isset(%s)) unset(%s);', $obj->ston_name, $obj->ston_name));       
                
    }
    
    
    /**
    * Returns a list of functions that can be converted automatically
    *
    * @return   array
    */
    public function getSupportedFunctions() {
        
        $ret = array_keys($this->mysql_funcs);
        sort($ret);
        
        return $ret;
    }
    
    
    /**
    * Returns a list of functions that cannot be converted automatically
    *
    * @return   array
    */
    public function getUnsupportedFunctions() {
        
        $ret = array_keys($this->mysql_funcs_not_supported);
        sort($ret);
        
        return $ret;
    }
    
    //
    // protected
    //
    
    
    /**
    * Scans the source and rebuilds a converted version of it
    *
    * @param    int
    */
    protected function scanner($level) {     
 
        // current parser state
        $state = self::STATE_NORMAL;
        
        // list of function parameters
        $func_params    = array();
        // current parameter value
        $curr_param     = '';
        // current bracket nesting level
        $bracket_level  = 0;
        // name of the currently processed function
        $func_name      = '';
        // flag: does the currently parameter contain variables or constants?
        $param_dynamic  = false;
        // flag for something that looks like a mysql_func call but is not followed by parameters
        $expect_param_brace_open   = false;
              

        while (list( , $token) = each($this->tokens)) {
            
            if (is_string($token)) {
                $id     = T_SIMPLE_TOKEN;
                $token_name = 'T_SIMPLE_TOKEN';
                $text   = $token;
            } else {
                list($id, $text) = $token;
                $token_name = token_name($id);                
            }
            
            // remember the current line number
            $lineno = $this->lineno;            
            $this->lineno += $this->countLines($text);
            
            if ($this->debug_dump_tokens) {
                          
                $this->debug_print('dump token',
                    sprintf("[%-05d - %10s - %d - %-10s - %03d - %05d] %s", 
                        $lineno,
                        $token_name,
                        $expect_param_brace_open,
                        $state,
                        $bracket_level,
                        strlen($text),
                        htmlspecialchars($text))
                );
                    
            }            
            
            switch ($id) {               
                  
            case T_COMMENT:
            case T_ML_COMMENT:
            case T_DOC_COMMENT:
                                                
                switch ($state) {                        
                case self::STATE_NORMAL:
                    $this->output .= $text;
                    break;
                            
                case self::STATE_FUNC_FOUND:
                    // comment between func_name and comma
                    break;
                            
                case self::STATE_PARAM_LIST:
                    $curr_param .= $text;
                    break;
                }
                
                break;
                
            case T_SIMPLE_TOKEN:
                            
                switch ($state) {

                case self::STATE_NORMAL:
                    $this->output .= $text;
                    break;
                    
                case self::STATE_FUNC_FOUND:
                
                    switch ($text) {
                    case '(':
                        $state = self::STATE_PARAM_LIST;
                        $func_params    = array();
                        $curr_param     = NULL;
                        $param_dynamic  = false;
                        $expect_param_brace_open   = false;
                        break;
                        
                    case ')':
                    default:
                        if ($expect_param_brace_open) {
                            // something that looks like <mysql_func[...]> is not followed by an opening brace for <mysql_func([...]> 
                            $state = self::STATE_NORMAL;
                            $this->funcs_found--; 
                            $expect_param_brace_open = 0;
                            $steps = 0;
                            $tmp = '';
                            while (($token = prev($this->tokens)) && ($tmp != $func_name)) {
                                if (is_array($token)) {
                                    $tmp = $token[1];
                                } else {
                                    $tmp = $token;
                                }                                
                                $steps++;                                
                            }
                            while ($steps-- > 1) {
                                $token = next($this->tokens);
                                if (is_array($token))
                                    $tmp = $token[1];
                                else 
                                    $tmp = $token;                                
                                $this->output .= $tmp;                                    
                            }    
                            next($this->tokens);                            
                            break 3;                           
                        }
                        break;
                    }
                    break;
                    
                case self::STATE_PARAM_LIST:
                
                    switch ($text) {
                    case ',':
                        if ($bracket_level == 1) {                            
                            $func_params[]  = array('value' => $curr_param, 'dynamic' => $param_dynamic);
                            $curr_param     = '';
                            $param_dynamic  = false;
                        } else {                            
                            $curr_param .= $text;
                        }
                        // don't add to the curr_param                        
                        break(2);
                        
                    case '(':
                        $bracket_level++;                        
                        break;
                        
                    case ')':
                        $bracket_level--;
                        if ($bracket_level == 0) { 
                            // end of the parameter specification
                            
                            if (!is_null($curr_param))
                                $func_params[]  = array('value' => $curr_param, 'dynamic' => $param_dynamic);
                                
                            $curr_param     = NULL;
                            $param_dynamic  = false;
                            $state          = self::STATE_NORMAL;
                                                        
                            if ($this->debug_dump_params) {
                                $this->debug_print(
                                    'params',
                                    array('name' => $func_name, 'params' => $func_params)
                                );
                            }
                                                        
                            if (!$level) {                         
                                
                                list($handler_warning, $handler_code) = $this->mysql_funcs[$func_name]->handle($func_params);
                                if (!is_null($handler_warning))
                                    $this->errors[] = array('line' => $lineno, 'msg' => sprintf('[Line %d] %s', $lineno, $handler_warning));
                                
                                if (is_null($handler_code)) {
                                    $this->output .= $this->rebuildFunctionCode($func_name, $func_params, $handler_warning);                                    
                                } else {                                                                    
                                    $this->funcs_converted++;
                                    $this->output .= $handler_code;
                                }
                                
                            } else {
                                // we are in recursive call - return
                                
                                list($handler_warning, $handler_code) = $this->mysql_funcs[$func_name]->handle($func_params);
                                if (!is_null($handler_warning))
                                    $this->errors[] = array('line' => $lineno, 'msg' => sprintf('[Line %d] %s', $lineno, $handler_warning));
                                    
                                if (is_null($handler_code)) {
                                    return $this->rebuildFunctionCode($func_name, $func_params, $handler_warning);
                                } else {                                                                    
                                    $this->funcs_converted++;
                                    return $handler_code;
                                }                               
                                
                            }
                            
                        }
                        break;
                        
                    case '.':
                    case '&':
                    case '^':
                    case '|':
                    case '&&':
                    case '||':
                    case 'and':
                    case 'or':
                    case 'xor':
                    case '<<':
                    case '>>':
                    case '<':
                    case '<=':
                    case '>':
                    case '>=':
                    case '=':
                    case '*':
                    case '/':
                    case '%':
                    case '+':
                    case '-':
                    case '++':
                    case '--':
                    case '!':
                    case '~':
                    case '=':
                    case '+=':
                    case '-=':
                    case '*=':
                    case '/=':
                    case '.=':
                    case '%=':
                    case '&=':
                    case '|=':
                    case '^=':
                    case '<<=':
                    case '>>=':
                    case '?':
                    case '==':
                    case '!=':
                    case '===':
                    case '!==':
                    case '(':
                    case 'new':
                        // forget it - this parameter value is build dynamically
                        // we won't try to guess it's value using static code analysis
                        // this needs to be checked manually
                        $param_dynamic = true;
                        if ($this->debug_dump_params) {
                                $this->debug_print(
                                    'params',
                                    'Operator found in parameter. Assuming that the paramter value will be dynamic and cannot be foreseen.'
                                );
                            }
                        break;
                    }
                    
                    $curr_param .= $text;
                    break;
                }
                break;
                
            case T_STRING:
                            
                if (isset($this->mysql_ext_consts[$text])) {
                    
                    $text = $this->mysql_ext_consts[$text];
                    
                } else {
                    
                    switch ($state) {
                    case self::STATE_PARAM_LIST:
                        // maybe a function call or constant as part of a parameter value?
                        
                        if (isset($this->mysql_funcs_not_supported[$text])) {
                            
                            $this->errors[] = array('line' => $lineno, 'msg' => sprintf('[Line %d] Function "%s" is not supported for conversion! You must rewrite the converted code. The conversion is not complete. Consider rewriting your code first and rerunning the conversion tool"', $lineno, $text));
                            
                        }
                        
                        if (isset($this->mysql_funcs[$text])) {
                            // return the current token and reparse it
                            prev($this->tokens);
                            // in the default of the outter switch add this to $curr_param
                            $text = $this->scanner($level + 1);
                            $param_dynamic = true;
                        }
                        // fall to default                        
                        break;
                
                    case self::STATE_FUNC_FOUND:
                    
                        $this->errors[] = array('line' => $lineno, 'msg' => sprintf('[Line %d] We found a string between the function name "%s" and the parameter list. Looks like a syntax error in the source file. Please check!', $lineno, $func_name));
                        
                        break;             
                    
                    case self::STATE_NORMAL:
                    default:
                    
                        if (isset($this->mysql_funcs_not_supported[$text])) {
                            
                            $this->errors[] = array('line' => $lineno, 'msg' => sprintf('[Line %d] Function "%s" is not supported for conversion! You must rewrite the converted code code. The conversion is not complete. Consider rewriting your code first and rerunning the conversion tool."', $lineno, $text));
                            
                        }
                        
                        if (isset($this->mysql_funcs[$text])) {
                            $state          = self::STATE_FUNC_FOUND;
                            $func_name      = $text;
                            $bracket_level  = 1;                            
                            $this->funcs_found++; 
                            $expect_param_brace_open   = true;
                            
                            break(2);
                        }
                        
                        if ($text == 'is_resource') {                            
                            $this->errors[] = array('line' => $lineno, 'msg' => sprintf('[Line %d] You are using is_resource(). Make sure that you do not use it to test for the return value of mysql_query(). mysql_query() returns a resource or a boolean value. mysqli_query() returns an object or a boolean value. If you check the return value of mysql_query like < if (is_resource($res = mysql_query())) [...] > the converted code will fail, because $res will be an object in ext/mysqli."', $lineno, $text));                            
                        }
                        // here we fall-through
                    }
                }
                
                    
            default:
                            
                if ($id === T_CONSTANT_ENCAPSED_STRING) {
                    /* try to detect function_exists('some_mysql_func'); */
                    $prev_steps = 0;
                    
                    if (isset($this->mysql_funcs[substr($text, 1, -1)]) && 
                        $this->mysql_funcs[substr($text, 1, -1)]->new_name) { 
                        // strip quotes
                        // move back because now 'some_mysql_func' will be returned by prev()
                        $prev_steps = 1;
                        $tmp_token = prev($this->tokens);
                        
                        do {
                            $tmp_token = prev($this->tokens);
                            $prev_steps++;
                        } while ($tmp_token[0] === T_WHITESPACE);
                        
                        if ($tmp_token === '(') {
                            
                            $tmp_token = prev($this->tokens);
                            $prev_steps++;
                            
                            if ($tmp_token[0] === T_STRING && 
                                $tmp_token[1] === 'function_exists') {
                                    
                                $text = $text[0] . $this->mysql_funcs[substr($text, 1, -1)]->new_name . $text[0];
                            }
                            
                        }
                        
                        while ($prev_steps--)
                            each($this->tokens);
                    }
                }
                
                switch ($state) {
                case self::STATE_PARAM_LIST:                   
                 
                    switch ($id) {                     
                        
                    case T_VARIABLE:
                    case T_FUNCTION:
                    case T_CONST:                    
                        // this is a variable, we cannot guess value of the parameter
                        // using this static conversion approach
                        if ($this->debug_dump_params) {
                                $this->debug_print(
                                    'params',
                                    "Adding variable '$text' to current parameter."
                                );
                            }
                        $param_dynamic = true;    
                        $curr_param .= $text;
                        break;
                    
                    case T_WHITESPACE:       
                    default:
                        if ($this->debug_dump_params) {
                                $this->debug_print(
                                    'params',
                                    "Adding '$text' to current parameter."
                                );
                            }
                            
                        $curr_param .= $text;
                        break;                        
                    }                  
                    break;
                    
                case self::STATE_FUNC_FOUND:
                
                    $this->errors[] = array('line' => $lineno, 'msg' => sprintf('[Line %d] Please check your code for parse errors, we failed to parse "%s". Conversion will be incomplete!".', $lineno, $text));
                    break;
                    
                default:
                case self::STATE_NORMAL:
                    $this->output .= $text;
                    break;
                }
                break;                
            }
            
        }
        
    }


    /**
    * Print a debug message
    *
    * @param    string  Message prefix
    * @param    mixed   Array or literal to print
    */
    protected function debug_print($prefix, $var) {
        
        if (is_scalar($var)) {
            printf("[%s/%s] %s\n",
                get_class($this),
                $prefix,
                $var);
        } else {
            printf("[%s/%s] ", get_class($this), $prefix);
            var_dump($var);
            printf("\n");
        }
               
            
    } // end func debug_print
    
    
    /**
    * Returns the number of lines of a string
    *
    * @param    string  
    * @return   int
    */
    protected function countLines($text) {
        
        $last_pos   = 0;
        $lines      = 0;
        while (($pos = strpos($text, "\n", $last_pos)) !== FALSE) {
            $last_pos = $pos + 1;
            $lines++;                
        }
        
        return $lines;           
    }
    
    
    /**
    * Rebuilds the original function code based on function name and parameters and adds a comment with a warning after the last parameter
    *
    * @param    string  
    * @param    array   
    * @param    string  
    */
    protected function rebuildFunctionCode($name, $params, $warning) {
        
        $ret = $name . '(';
        if (count($params) > 0) {
            foreach ($params as $k => $param)
                $ret .= $param['value'] . ', ';
            $ret = substr($ret, 0, -2);
        }
        $ret .= ')';
        // $ret .= ' /* [MySQLConverterTool] ' . $warning . '*/)';
        
        return $ret;        
    }
    
    
    /**
    * Expands a user specified file pattern with * as the only pattern to a regular expression
    *
    * @param    string
    * @return   array
    */
    protected function buildRegularExpression($file_pattern) {
        
        $parts = explode(',', $file_pattern);
        if (empty($parts))
            return array();
            
        $ret = array();
        foreach ($parts as $k => $v)
            $ret[] = str_replace('\*', '.*', preg_quote($v, '@'));

        return $ret;
    }
    
}
?>