Barry Mieny avatar Barry Mieny committed 982b43c

Cleanup of stray spaces and tabs

Comments (0)

Files changed (171)

application/config/autoload.php

 |
 |	$autoload['language'] = array('lang1', 'lang2');
 |
-| NOTE: Do not include the "_lang" part of your file.  For example 
+| NOTE: Do not include the "_lang" part of your file.  For example
 | "codeigniter_lang.php" would be referenced as array('codeigniter');
 |
 */

application/config/config.php

 |
 */
 $config['enable_query_strings'] = FALSE;
-$config['controller_trigger'] 	= 'c';
-$config['function_trigger'] 	= 'm';
-$config['directory_trigger'] 	= 'd'; // experimental not currently in use
+$config['controller_trigger']	= 'c';
+$config['function_trigger']		= 'm';
+$config['directory_trigger']	= 'd'; // experimental not currently in use
 
 /*
 |--------------------------------------------------------------------------
 | Error Logging Threshold
 |--------------------------------------------------------------------------
 |
-| If you have enabled error logging, you can set an error threshold to 
+| If you have enabled error logging, you can set an error threshold to
 | determine what gets logged. Threshold options are:
 | You can enable error logging by setting a threshold over zero. The
 | threshold determines what gets logged. Threshold options are:
 |--------------------------------------------------------------------------
 |
 | 'sess_cookie_name'		= the name you want for the cookie
-| 'sess_expiration'  		= the number of SECONDS you want the session to last.
+| 'sess_expiration'			= the number of SECONDS you want the session to last.
 |   by default sessions last 7200 seconds (two hours).  Set to zero for no expiration.
 | 'sess_expire_on_close'	= Whether to cause the session to expire automatically
 |   when the browser window is closed
 $config['sess_table_name']		= 'ci_sessions';
 $config['sess_match_ip']		= FALSE;
 $config['sess_match_useragent']	= TRUE;
-$config['sess_time_to_update'] 	= 300;
+$config['sess_time_to_update']	= 300;
 
 /*
 |--------------------------------------------------------------------------

application/config/constants.php

 |
 */
 
-define('FOPEN_READ', 							'rb');
+define('FOPEN_READ',							'rb');
 define('FOPEN_READ_WRITE',						'r+b');
-define('FOPEN_WRITE_CREATE_DESTRUCTIVE', 		'wb'); // truncates existing file data, use with care
-define('FOPEN_READ_WRITE_CREATE_DESTRUCTIVE', 	'w+b'); // truncates existing file data, use with care
-define('FOPEN_WRITE_CREATE', 					'ab');
-define('FOPEN_READ_WRITE_CREATE', 				'a+b');
-define('FOPEN_WRITE_CREATE_STRICT', 			'xb');
+define('FOPEN_WRITE_CREATE_DESTRUCTIVE',		'wb'); // truncates existing file data, use with care
+define('FOPEN_READ_WRITE_CREATE_DESTRUCTIVE',	'w+b'); // truncates existing file data, use with care
+define('FOPEN_WRITE_CREATE',					'ab');
+define('FOPEN_READ_WRITE_CREATE',				'a+b');
+define('FOPEN_WRITE_CREATE_STRICT',				'xb');
 define('FOPEN_READ_WRITE_CREATE_STRICT',		'x+b');
 
 

application/config/foreign_chars.php

 |
 */
 $foreign_characters = array('223'	=>	"ss", // ß
-							'224'	=>  "a",  
-							'225'	=>  "a", 
-							'226'	=>	"a", 
+							'224'	=>	"a",
+							'225'	=>	"a",
+							'226'	=>	"a",
 							'229'	=>	"a",
-							'227'	=>	"ae", 
-							'230'	=>	"ae", 
+							'227'	=>	"ae",
+							'230'	=>	"ae",
 							'228'	=>	"ae",
 							'231'	=>	"c",
 							'232'	=>	"e",  // è
 							'233'	=>	"e",  // é
-							'234'	=>	"e",  // ê  								
+							'234'	=>	"e",  // ê
 							'235'	=>	"e",  // ë
-							'236'	=>  "i",
-							'237' 	=>  "i",
-							'238' 	=>	"i",
-							'239' 	=>	"i",
+							'236'	=>	"i",
+							'237'	=>	"i",
+							'238'	=>	"i",
+							'239'	=>	"i",
 							'241'	=>	"n",
-							'242'	=>  "o",
-							'243'	=>  "o",
-							'244' 	=>	"o", 
+							'242'	=>	"o",
+							'243'	=>	"o",
+							'244'	=>	"o",
 							'245'	=>	"o",
 							'246'	=>	"oe", // ö
-							'249'	=>  "u",
-							'250' 	=>  "u", 
-							'251' 	=>	"u",
+							'249'	=>	"u",
+							'250'	=>	"u",
+							'251'	=>	"u",
 							'252'	=>	"ue", // ü
 							'255'	=>	"y",
-							'257'	=>	"aa", 
-							'269'	=>	"ch", 
-							'275'	=>	"ee", 
-							'291'	=>	"gj", 
-							'299'	=>	"ii", 
-							'311'	=>	"kj", 
-							'316'	=>	"lj", 
-							'326'	=>	"nj", 
-							'353'	=>	"sh", 
-							'363'	=>	"uu", 
+							'257'	=>	"aa",
+							'269'	=>	"ch",
+							'275'	=>	"ee",
+							'291'	=>	"gj",
+							'299'	=>	"ii",
+							'311'	=>	"kj",
+							'316'	=>	"lj",
+							'326'	=>	"nj",
+							'353'	=>	"sh",
+							'363'	=>	"uu",
 							'382'	=>	"zh",
-							'256'	=>	"aa", 
-							'268'	=>	"ch", 
-							'274'	=>	"ee", 
-							'290'	=>	"gj", 
-							'298'	=>	"ii", 
-							'310'	=>	"kj", 
-							'315'	=>	"lj", 
-							'325'	=>	"nj", 
-							'352'	=>	"sh", 
-							'362'	=>	"uu", 
+							'256'	=>	"aa",
+							'268'	=>	"ch",
+							'274'	=>	"ee",
+							'290'	=>	"gj",
+							'298'	=>	"ii",
+							'310'	=>	"kj",
+							'315'	=>	"lj",
+							'325'	=>	"nj",
+							'352'	=>	"sh",
+							'362'	=>	"uu",
 							'381'	=>	"zh",
-							);				
+							);
 
 
 /* End of file foreign_chars.php */

application/config/routes.php

 | and its corresponding controller class/method. The segments in a
 | URL normally follow this pattern:
 |
-| 	example.com/class/method/id/
+|	example.com/class/method/id/
 |
 | In some instances, however, you may want to remap this relationship
 | so that a different class/function is called than the one

application/config/smileys.php

 | Individual images can be used to replace multiple simileys.  For example:
 | :-) and :) use the same image replacement.
 |
-| Please see user guide for more info: 
+| Please see user guide for more info:
 | http://codeigniter.com/user_guide/helpers/smiley_helper.html
 |
 */

application/config/user_agents.php

 					'benq'				=> "BenQ",
 					'ipaq'				=> "HP iPaq",
 					'mot-'				=> "Motorola",
-					'playstation portable' 	=> "PlayStation Portable",
+					'playstation portable'	=> "PlayStation Portable",
 					'hiptop'			=> "Danger Hiptop",
 					'nec-'				=> "NEC",
 					'panasonic'			=> "Panasonic",
 
 					// Operating Systems
 					'symbian'				=> "Symbian",
-					'SymbianOS'				=> "SymbianOS", 
+					'SymbianOS'				=> "SymbianOS",
 					'elaine'				=> "Palm",
 					'palm'					=> "Palm",
 					'series60'				=> "Symbian S60",
 
 					// Fallback
 					'mobile'				=> "Generic Mobile",
-					'wireless' 				=> "Generic Mobile",
+					'wireless'				=> "Generic Mobile",
 					'j2me'					=> "Generic Mobile",
 					'midp'					=> "Generic Mobile",
 					'cldc'					=> "Generic Mobile",

application/controllers/welcome.php

 
 	function Welcome()
 	{
-		parent::Controller();	
+		parent::Controller();
 	}
-	
+
 	function index()
 	{
 		$this->load->view('welcome_message');

application/errors/error_404.php

 font-weight:		normal;
 font-size:			14px;
 color:				#990000;
-margin: 			0 0 4px 0;
+margin:				0 0 4px 0;
 }
 </style>
 </head>

application/errors/error_db.php

 font-weight:		normal;
 font-size:			14px;
 color:				#990000;
-margin: 			0 0 4px 0;
+margin:				0 0 4px 0;
 }
 </style>
 </head>

application/errors/error_general.php

 font-weight:		normal;
 font-size:			14px;
 color:				#990000;
-margin: 			0 0 4px 0;
+margin:				0 0 4px 0;
 }
 </style>
 </head>
  *---------------------------------------------------------------
  *
  * If you want this front controller to use a different "application"
- * folder then the default one you can set its name here. The folder 
+ * folder then the default one you can set its name here. The folder
  * can also be renamed or relocated anywhere on your server.  If
  * you do, use a full server path. For more info please see the user guide:
  * http://codeigniter.com/user_guide/general/managing_apps.html
  * --------------------------------------------------------------------
  *
  * Normally you will set your default controller in the routes.php file.
- * You can, however, force a custom routing by hard-coding a 
+ * You can, however, force a custom routing by hard-coding a
  * specific controller class/function here.  For most applications, you
- * WILL NOT set your routing here, but it's an option for those 
+ * WILL NOT set your routing here, but it's an option for those
  * special instances where you might want to override the standard
  * routing in a specific front controller that shares a common CI installation.
  *
  * Un-comment the $routing array below to use this feature
  *
  */
- 	// The directory name, relative to the "controllers" folder.  Leave blank
- 	// if your controller is not in a sub-folder within the "controllers" folder
+	// The directory name, relative to the "controllers" folder.  Leave blank
+	// if your controller is not in a sub-folder within the "controllers" folder
 	// $routing['directory'] = '';
-	
+
 	// The controller class file name.  Example:  Mycontroller.php
 	// $routing['controller'] = '';
-	
-	// The controller function you wish to be called. 
+
+	// The controller function you wish to be called.
 	// $routing['function']	= '';
 
 
  * -------------------------------------------------------------------
  *
  * The $assign_to_config array below will be passed dynamically to the
- * config class when initialized. This allows you to set custom config 
- * items or override any default config values found in the config.php file.  
+ * config class when initialized. This allows you to set custom config
+ * items or override any default config values found in the config.php file.
  * This can be handy as it permits you to share one application between
- * multiple front controller files, with each file containing different 
+ * multiple front controller files, with each file containing different
  * config values.
  *
  * Un-comment the $assign_to_config array below to use this feature
 	{
 		$system_path = realpath($system_path).'/';
 	}
-	
+
 	// ensure there's a trailing slash
 	$system_path = rtrim($system_path, '/').'/';
 
 	// Is the system path correct?
 	if ( ! is_dir($system_path))
 	{
-		exit("Your system folder path does not appear to be set correctly. Please open the following file and correct this: ".pathinfo(__FILE__, PATHINFO_BASENAME));	
+		exit("Your system folder path does not appear to be set correctly. Please open the following file and correct this: ".pathinfo(__FILE__, PATHINFO_BASENAME));
 	}
 
 /*
  * -------------------------------------------------------------------
  *  Now that we know the path, set the main path constants
  * -------------------------------------------------------------------
- */		
+ */
 	// The name of THIS file
 	define('SELF', pathinfo(__FILE__, PATHINFO_BASENAME));
 
 	// The PHP file extension
 	define('EXT', '.php');
 
- 	// Path to the system folder
+	// Path to the system folder
 	define('BASEPATH', str_replace("\\", "/", $system_path));
-		
+
 	// Path to the front controller (this file)
 	define('FCPATH', str_replace(SELF, '', __FILE__));
-	
+
 	// Name of the "system folder"
-	define('SYSDIR', trim(strrchr(trim(BASEPATH, '/'), '/'), '/'));		
+	define('SYSDIR', trim(strrchr(trim(BASEPATH, '/'), '/'), '/'));
 
 
 	// The path to the "application" folder
 		define('APPPATH', $application_folder.'/');
 	}
 	else
-	{		
+	{
 		if ( ! is_dir(BASEPATH.$application_folder.'/'))
 		{
-			exit("Your application folder path does not appear to be set correctly. Please open the following file and correct this: ".SELF);	
+			exit("Your application folder path does not appear to be set correctly. Please open the following file and correct this: ".SELF);
 		}
-	
+
 		define('APPPATH', BASEPATH.$application_folder.'/');
 	}
 

system/core/Base4.php

  * Since PHP 5 doesn't suffer from this problem so we load one of
  * two files based on the version of PHP being run.
  * @PHP4
- * 
+ *
  * @package		CodeIgniter
  * @subpackage	codeigniter
  * @category	front-controller
 		// This allows syntax like $this->load->foo() to work
 		parent::CI_Loader();
 		$this->load =& $this;
-		
+
 		// This allows resources used within controller constructors to work
 		global $OBJ;
 		$OBJ = $this->load; // Do NOT use a reference.
 function &get_instance()
 {
 	global $CI, $OBJ;
-	
+
 	if (is_object($CI))
 	{
 		return $CI;
 	}
-	
+
 	return $OBJ->load;
 }
 

system/core/Base5.php

  * run under PHP 5.  It allows us to manage the CI super object more
  * gracefully than what is possible with PHP 4.
  * @PHP4 (no need for separate Bases after PHP 4 is gone)
- * 
+ *
  * @package		CodeIgniter
  * @subpackage	codeigniter
  * @category	front-controller

system/core/Benchmark.php

 		{
 			$this->marker[$point2] = microtime();
 		}
-	
+
 		list($sm, $ss) = explode(' ', $this->marker[$point1]);
 		list($em, $es) = explode(' ', $this->marker[$point2]);
 
 		return number_format(($em + $es) - ($sm + $ss), $decimals);
 	}
- 	
+
 	// --------------------------------------------------------------------
 
 	/**

system/core/CodeIgniter.php

  * ------------------------------------------------------
  */
 	set_error_handler('_exception_handler');
-	
+
 	if ( ! is_php('5.3'))
 	{
-		@set_magic_quotes_runtime(0); // Kill magic quotes		
+		@set_magic_quotes_runtime(0); // Kill magic quotes
 	}
 
 	// Set a liberal script execution time limit
  *  Set the subclass_prefix
  * ------------------------------------------------------
  *
- * Normally the "subclass_prefix" is set in the config file. 
- * The subclass prefix allows CI to know if a core class is 
+ * Normally the "subclass_prefix" is set in the config file.
+ * The subclass prefix allows CI to know if a core class is
  * being extended via a library in the local application
- * "libraries" folder. Since CI allows config items to be 
- * overriden via data set in the main index. php file, 
- * before proceeding we need to know if a subclass_prefix 
+ * "libraries" folder. Since CI allows config items to be
+ * overriden via data set in the main index. php file,
+ * before proceeding we need to know if a subclass_prefix
  * override exists.  If so, we will set this value now,
  * before any classes are loaded
- * Note: Since the config file data is cached it doesn't 
+ * Note: Since the config file data is cached it doesn't
  * hurt to load it here.
  */
-	if (isset($assign_to_config['subclass_prefix']) AND $assign_to_config['subclass_prefix'] != '') 
+	if (isset($assign_to_config['subclass_prefix']) AND $assign_to_config['subclass_prefix'] != '')
 	{
 		get_config(array('subclass_prefix' => $assign_to_config['subclass_prefix']));
 	}
  * ------------------------------------------------------
  *  Instantiate the config class
  * ------------------------------------------------------
- */ 
+ */
 	$CFG =& load_class('Config', 'core');
 
 	// Do we have any manually set config items in the index.php file?
 	if (isset($assign_to_config))
-	{	
+	{
 		$CFG->_assign_to_config($assign_to_config);
 	}
 
  * ------------------------------------------------------
  *  Instantiate the Unicode class
  * ------------------------------------------------------
- * 
+ *
  * Note: Order here is rather important as the Unicode
  * class needs to be used very early on, but it cannot
- * properly determine if UTf-8 can be supported until 
+ * properly determine if UTf-8 can be supported until
  * after the Config class is instantiated.
- * 
+ *
  */
 
 	$UNI =& load_class('Unicode', 'core');
-		
+
 /*
  * ------------------------------------------------------
  *  Instantiate the URI class
  * ------------------------------------------------------
  *  Instantiate the routing class and set the routing
  * ------------------------------------------------------
- */ 
+ */
 	$RTR =& load_class('Router', 'core');
 	$RTR->_set_routing();
-	
+
 	// Set any routing overrides that may exist in the main index file
 	if (isset($routing))
 	{
  *  Load the Input class and sanitize globals
  * ------------------------------------------------------
  */
-	$IN	=& load_class('Input', 'core');	
+	$IN	=& load_class('Input', 'core');
 
 /*
  * ------------------------------------------------------
  *  conditionally load different versions of the base
  *  class.  Retaining PHP 4 compatibility requires a bit of a hack.
  *  @PHP4
- * 
+ *
  */
- 	if (is_php('5.0.0') == TRUE)
+	if (is_php('5.0.0') == TRUE)
 	{
 		require(BASEPATH.'core/Base5'.EXT);
 	}
 		load_class('Loader', 'core');
 		require(BASEPATH.'core/Base4'.EXT);
 	}
-	
+
 	// Load the base controller class
 	require BASEPATH.'core/Controller'.EXT;
-	
+
 	if (file_exists(APPPATH.'core/'.$CFG->config['subclass_prefix'].'Controller'.EXT))
 	{
 		require APPPATH.'core/'.$CFG->config['subclass_prefix'].'Controller'.EXT;
 	}
-	
+
 	// Load the local application controller
-	// Note: The Router class automatically validates the controller path using the router->_validate_request().  
+	// Note: The Router class automatically validates the controller path using the router->_validate_request().
 	// If this include fails it means that the default controller in the Routes.php file is not resolving to something valid.
 	if ( ! file_exists(APPPATH.'controllers/'.$RTR->fetch_directory().$RTR->fetch_class().EXT))
 	{
 		show_error('Unable to load your default controller.  Please make sure the controller specified in your Routes.php file is valid.');
 	}
-	
+
 	include(APPPATH.'controllers/'.$RTR->fetch_directory().$RTR->fetch_class().EXT);
-	
+
 	// Set a mark point for benchmarking
 	$BM->mark('loading_time:_base_classes_end');
 
  */
 	$class  = $RTR->fetch_class();
 	$method = $RTR->fetch_method();
-	
+
 	if ( ! class_exists($class)
 		OR $method == 'controller'
 		OR strncmp($method, '_', 1) == 0
  */
 	// Mark a start point so we can benchmark the controller
 	$BM->mark('controller_execution_time_( '.$class.' / '.$method.' )_start');
-	
+
 	$CI = new $class();
 
 /*
 		}
 
 		// Call the requested method.
-		// Any URI segments present (besides the class/function) will be passed to the method for convenience		
-		call_user_func_array(array(&$CI, $method), array_slice($URI->rsegments, 2));		
+		// Any URI segments present (besides the class/function) will be passed to the method for convenience
+		call_user_func_array(array(&$CI, $method), array_slice($URI->rsegments, 2));
 	}
 
-	
+
 	// Mark a benchmark end point
 	$BM->mark('controller_execution_time_( '.$class.' / '.$method.' )_end');
 
 	{
 		$OUT->_display();
 	}
-	
+
 /*
  * ------------------------------------------------------
  *  Is there a "post_system" hook?

system/core/Common.php

 	{
 		static $_is_php;
 		$version = (string)$version;
-	
+
 		if ( ! isset($_is_php[$version]))
 		{
 			$_is_php[$version] = (version_compare(PHP_VERSION, $version) < 0) ? FALSE : TRUE;
 /**
  * Tests for file writability
  *
- * is_writable() returns TRUE on Windows servers when you really can't write to 
+ * is_writable() returns TRUE on Windows servers when you really can't write to
  * the file, based on the read-only attribute.  is_writable() is also unreliable
  * on Unix servers if safe_mode is on.
  *
  * @access	private
  * @return	void
- */	
+ */
 	function is_really_writable($file)
 	{
 		// If we're on a Unix server with safe_mode off we call is_writable
 	function &load_class($class, $directory = 'libraries', $prefix = 'CI_')
 	{
 		static $_classes = array();
-		
+
 		// Does the class exist?  If so, we're done...
 		if (isset($_classes[$class]))
 		{
 		// Look for the class first in the native system/libraries folder
 		// thenin the local application/libraries folder
 		foreach (array(BASEPATH, APPPATH) as $path)
-		{ 
+		{
 			if (file_exists($path.$directory.'/'.$class.EXT))
 			{
 				$name = $prefix.$class;
-		
+
 				if (class_exists($name) === FALSE)
 				{
 					require($path.$directory.'/'.$class.EXT);
 				}
-		
+
 				break;
 			}
 		}
 
 		// Is the request a class extension?  If so we load it too
 		if (file_exists(APPPATH.$directory.'/'.config_item('subclass_prefix').$class.EXT))
-		{	
+		{
 			$name = config_item('subclass_prefix').$class;
-	
+
 			if (class_exists($name) === FALSE)
 			{
 				require(APPPATH.$directory.'/'.config_item('subclass_prefix').$class.EXT);
 		// Did we find the class?
 		if ($name === FALSE)
 		{
-			// Note: We use exit() rather then show_error() in order to avoid a 
-			// self-referencing loop with the Excptions class 
+			// Note: We use exit() rather then show_error() in order to avoid a
+			// self-referencing loop with the Excptions class
 			exit('Unable to locate the specified class: '.$class.EXT);
 		}
 
  * Required to retain PHP 4 compatibility and also not make PHP 5.3 cry.
  *
  * Use: $obj =& instantiate_class(new Foo());
- * 
+ *
  * @access	public
  * @param	object
  * @return	object
 	function &get_config($replace = array())
 	{
 		static $_config;
-	
+
 		if (isset($_config))
 		{
 			return $_config[0];
-		}	
+		}
 
 		// Fetch the config file
 		if ( ! file_exists(APPPATH.'config/config'.EXT))
 				}
 			}
 		}
-	
+
 		return $_config[0] =& $config;
 	}
 
 	function config_item($item)
 	{
 		static $_config_item = array();
-	
+
 		if ( ! isset($_config_item[$item]))
 		{
 			$config =& get_config();
-	
+
 			if ( ! isset($config[$item]))
 			{
 				return FALSE;
 			}
 			$_config_item[$item] = $config[$item];
 		}
-	
+
 		return $_config_item[$item];
 	}
 
 		{
 			return;
 		}
-	
+
 		$_log =& load_class('Log');
 		$_log->write_log($level, $message, $php_error);
 	}
  * Set HTTP Status Header
  *
  * @access	public
- * @param	int 	the status code
- * @param	string	
+ * @param	int		the status code
+ * @param	string
  * @return	void
- */	
+ */
 	function set_status_header($code = 200, $text = '')
 	{
 		$stati = array(
 		}
 
 		if (isset($stati[$code]) AND $text == '')
-		{				
+		{
 			$text = $stati[$code];
 		}
-	
+
 		if ($text == '')
 		{
 			show_error('No status text available.  Please check your status code number or supply your own message text.', 500);
 		}
-	
+
 		$server_protocol = (isset($_SERVER['SERVER_PROTOCOL'])) ? $_SERVER['SERVER_PROTOCOL'] : FALSE;
 
 		if (substr(php_sapi_name(), 0, 3) == 'cgi')
 			header("HTTP/1.1 {$code} {$text}", TRUE, $code);
 		}
 	}
-	
+
 // --------------------------------------------------------------------
 
 /**
 * @return	void
 */
 	function _exception_handler($severity, $message, $filepath, $line)
-	{	
+	{
 		 // We don't bother with "strict" notices since they tend to fill up
 		 // the log file with excess information that isn't normally very helpful.
-		 // For example, if you are running PHP 5 and you use version 4 style 
-		 // class functions (without prefixes like "public", "private", etc.) 
+		 // For example, if you are running PHP 5 and you use version 4 style
+		 // class functions (without prefixes like "public", "private", etc.)
 		 // you'll get notices telling you that these have been deprecated.
 		if ($severity == E_STRICT)
 		{
 			return;
 		}
-	
+
 		$_error =& load_class('Exceptions', 'core');
-	
-		// Should we display the error? We'll get the current error_reporting 
+
+		// Should we display the error? We'll get the current error_reporting
 		// level and add its bits with the severity bits to find out.
 		if (($severity & error_reporting()) == $severity)
 		{
 		{
 			return;
 		}
-	
+
 		$_error->log_exception($severity, $message, $filepath, $line);
 	}
 
 	// --------------------------------------------------------------------
-	
+
 	/**
 	 * Remove Invisible Characters
 	 *
 	function remove_invisible_characters($str)
 	{
 		static $non_displayables;
-		
+
 		if ( ! isset($non_displayables))
 		{
 			// every control character except newline (dec 10), carriage return (dec 13), and horizontal tab (dec 09),

system/core/Compat.php

 
 /*
  * PHP versions prior to 5.0 don't support the E_STRICT constant
- * so we need to explicitly define it otherwise the Exception class 
+ * so we need to explicitly define it otherwise the Exception class
  * will generate errors when running under PHP 4
  * @PHP4
  *
 		{
 			return FALSE;
 		}
-		
+
 		return ! preg_match('/[^0-9]/', $str);
-	}	
+	}
 }
 
 // --------------------------------------------------------------------
 		{
 			return FALSE;
 		}
-		
+
 		return ! preg_match('/[^0-9a-z]/i', $str);
-	}	
+	}
 }
 
 // --------------------------------------------------------------------

system/core/Config.php

 	 */
 	function CI_Config()
 	{
-		$this->config =& get_config();	
+		$this->config =& get_config();
 		log_message('debug', "Config Class Initialized");
 	}
-  	
+
 	// --------------------------------------------------------------------
 
 	/**
 	 * @access	public
 	 * @param	string	the config file name
 	 * @return	boolean	if the file was loaded correctly
-	 */	
+	 */
 	function load($file = '', $use_sections = FALSE, $fail_gracefully = FALSE)
 	{
 		$file = ($file == '') ? 'config' : str_replace(EXT, '', $file);
 		$loaded = FALSE;
-	
+
 		foreach($this->_config_paths as $path)
 		{
 			$file_path = $path.'config/'.$file.EXT;
-			
+
 			if (in_array($file_path, $this->is_loaded, TRUE))
 			{
 				$loaded = TRUE;
 			{
 				continue;
 			}
-			
+
 			include($file_path);
 
 			if ( ! isset($config) OR ! is_array($config))
 				}
 				show_error('Your '.$file_path.' file does not appear to contain a valid configuration array.');
 			}
-			
+
 			if ($use_sections === TRUE)
 			{
 				if (isset($this->config[$file]))
 			{
 				$this->config = array_merge($this->config, $config);
 			}
-			
+
 			$this->is_loaded[] = $file_path;
 			unset($config);
-			
+
 			$loaded = TRUE;
 			log_message('debug', 'Config file loaded: '.$file_path);
 		}
-		
+
 		if ($loaded === FALSE)
 		{
 			if ($fail_gracefully === TRUE)
 
 		return TRUE;
 	}
-  	
+
 	// --------------------------------------------------------------------
 
 	/**
 	 * @return	string
 	 */
 	function item($item, $index = '')
-	{	
+	{
 		if ($index == '')
-		{	
+		{
 			if ( ! isset($this->config[$item]))
 			{
 				return FALSE;
 
 		return $pref;
 	}
-  	
-  	// --------------------------------------------------------------------
+
+	// --------------------------------------------------------------------
 
 	/**
 	 * Fetch a config file item - adds slash after item
 		$pref = $this->config[$item];
 
 		if ($pref != '' && substr($pref, -1) != '/')
-		{	
+		{
 			$pref .= '/';
 		}
 
 		return $pref;
 	}
-  	
+
 	// --------------------------------------------------------------------
 
 	/**
 			{
 				$uri = implode('/', $uri);
 			}
-	
+
 			$suffix = ($this->item('url_suffix') == FALSE) ? '' : $this->item('url_suffix');
-			return $this->slash_item('base_url').$this->slash_item('index_page').trim($uri, '/').$suffix; 
+			return $this->slash_item('base_url').$this->slash_item('index_page').trim($uri, '/').$suffix;
 		}
 		else
 		{
 			}
 		}
 	}
-	
+
 	// --------------------------------------------------------------------
 
 	/**
 		$x = explode("/", preg_replace("|/*(.+?)/*$|", "\\1", BASEPATH));
 		return $this->slash_item('base_url').end($x).'/';
 	}
-  	
+
 	// --------------------------------------------------------------------
 
 	/**
 	{
 		$this->config[$item] = $value;
 	}
-	
+
 	// --------------------------------------------------------------------
 
 	/**
 	 * @access	private
 	 * @param	array
 	 * @return	void
-	 */	
+	 */
 	function _assign_to_config($items = array())
 	{
 		if (is_array($items))
 			{
 				$this->set_item($key, $val);
 			}
-		}	
+		}
 	}
 }
 

system/core/Controller.php

  * @link		http://codeigniter.com/user_guide/general/controllers.html
  */
 class Controller extends CI_Base {
-	
+
 	/**
 	 * Constructor
 	 *
 	 * Calls the initialize() function
 	 */
 	function Controller()
-	{	
+	{
 		parent::CI_Base();
 
 		// Assign all the class objects that were instantiated by the
-		// bootstrap file (CodeIgniter.php) to local class variables 
+		// bootstrap file (CodeIgniter.php) to local class variables
 		// so that CI can run as one big super object.
 		foreach (is_loaded() as $var => $class)
 		{
 
 		// In PHP 5 the Loader class is run as a discreet
 		// class.  In PHP 4 it extends the Controller @PHP4
-	 	if (is_php('5.0.0') == TRUE)
+		if (is_php('5.0.0') == TRUE)
 		{
 			$this->load =& load_class('Loader', 'core');
-			
+
 			$this->load->_base_classes =& is_loaded();
-			
+
 			$this->load->_ci_autoloader();
 		}
 		else
 		{
 			$this->_ci_autoloader();
-			
+
 			// sync up the objects since PHP4 was working from a copy
 			foreach (array_keys(get_object_vars($this)) as $attribute)
 			{
 		}
 
 		log_message('debug', "Controller Class Initialized");
-		
+
 	}
 
 }

system/core/Exceptions.php

 	/**
 	 * Constructor
 	 *
-	 */	
+	 */
 	function CI_Exceptions()
 	{
 		$this->ob_level = ob_get_level();
 		// Note:  Do not log messages from this constructor.
 	}
-  	
+
 	// --------------------------------------------------------------------
 
 	/**
 	 * @return	string
 	 */
 	function log_exception($severity, $message, $filepath, $line)
-	{	
+	{
 		$severity = ( ! isset($this->levels[$severity])) ? $severity : $this->levels[$severity];
-		
+
 		log_message('error', 'Severity: '.$severity.'  --> '.$message. ' '.$filepath.' '.$line, TRUE);
 	}
 
 	 * @return	string
 	 */
 	function show_404($page = '', $log_error = TRUE)
-	{	
+	{
 		$heading = "404 Page Not Found";
 		$message = "The page you requested was not found.";
 
 		echo $this->show_error($heading, $message, 'error_404', 404);
 		exit;
 	}
-  	
+
 	// --------------------------------------------------------------------
 
 	/**
 	function show_error($heading, $message, $template = 'error_general', $status_code = 500)
 	{
 		set_status_header($status_code);
-		
+
 		$message = '<p>'.implode('</p><p>', ( ! is_array($message)) ? array($message) : $message).'</p>';
 
 		if (ob_get_level() > $this->ob_level + 1)
 		{
-			ob_end_flush();	
+			ob_end_flush();
 		}
 		ob_start();
 		include(APPPATH.'errors/'.$template.EXT);
 	 * @return	string
 	 */
 	function show_php_error($severity, $message, $filepath, $line)
-	{	
+	{
 		$severity = ( ! isset($this->levels[$severity])) ? $severity : $this->levels[$severity];
-	
+
 		$filepath = str_replace("\\", "/", $filepath);
-		
+
 		// For safety reasons we do not show the full file path
 		if (FALSE !== strpos($filepath, '/'))
 		{
 			$x = explode('/', $filepath);
 			$filepath = $x[count($x)-2].'/'.end($x);
 		}
-		
+
 		if (ob_get_level() > $this->ob_level + 1)
 		{
-			ob_end_flush();	
+			ob_end_flush();
 		}
 		ob_start();
 		include(APPPATH.'errors/error_php'.EXT);

system/core/Hooks.php

  */
 class CI_Hooks {
 
-	var $enabled 		= FALSE;
-	var $hooks   		= array();
+	var $enabled		= FALSE;
+	var $hooks			= array();
 	var $in_progress	= FALSE;
 
 	/**
 		$this->_initialize();
 		log_message('debug', "Hooks Class Initialized");
 	}
-  
+
 	// --------------------------------------------------------------------
 
 	/**
 	 *
 	 * @access	private
 	 * @return	void
-	 */  
-  	function _initialize()
-  	{
+	 */
+	function _initialize()
+	{
 		$CFG =& load_class('Config', 'core');
 
 		// If hooks are not enabled in the config file
 
 		$this->hooks =& $hook;
 		$this->enabled = TRUE;
-  	}
-  
+	}
+
 	// --------------------------------------------------------------------
 
 	/**

system/core/Input.php

 		{
 			return $this->ip_address;
 		}
-		
+
 		if (config_item('proxy_ips') != '' && $this->server('HTTP_X_FORWARDED_FOR') && $this->server('REMOTE_ADDR'))
 		{
 			$proxies = preg_split('/[\s,]/', config_item('proxy_ips'), -1, PREG_SPLIT_NO_EMPTY);
 	* Validate IP Address
 	*
 	* Updated version suggested by Geert De Deckere
-	* 
+	*
 	* @access	public
 	* @param	string
 	* @return	string
 		// Check each segment
 		foreach ($ip_segments as $segment)
 		{
-			// IP segments must be digits and can not be 
+			// IP segments must be digits and can not be
 			// longer than 3 digits or greater then 255
 			if ($segment == '' OR preg_match("/[^0-9]/", $segment) OR $segment > 255 OR strlen($segment) > 3)
 			{
 		$protected = array('_SERVER', '_GET', '_POST', '_FILES', '_REQUEST', '_SESSION', '_ENV', 'GLOBALS', 'HTTP_RAW_POST_DATA',
 							'system_folder', 'application_folder', 'BM', 'EXT', 'CFG', 'URI', 'RTR', 'OUT', 'IN');
 
-		// Unset globals for securiy. 
+		// Unset globals for securiy.
 		// This is effectively the same as register_globals = off
 		foreach (array($_GET, $_POST, $_COOKIE) as $global)
 		{

system/core/Lang.php

 	 * Fetch a single line of text from the language array
 	 *
 	 * @access	public
-	 * @param	string	$line 	the language line
+	 * @param	string	$line	the language line
 	 * @return	string
 	 */
 	function line($line = '')

system/core/Loader.php

 	var $_ci_library_paths	= array();
 	var $_ci_model_paths	= array();
 	var $_ci_helper_paths	= array();
-	var $_ci_is_instance 	= FALSE; // Whether we should use $this or $CI =& get_instance()
+	var $_ci_is_instance	= FALSE; // Whether we should use $this or $CI =& get_instance()
 	var $_base_classes		= array(); // Set by the controller class
 	var $_ci_cached_vars	= array();
 	var $_ci_classes		= array();
 	var $_ci_models			= array();
 	var $_ci_helpers		= array();
 	var $_ci_varmap			= array('unit_test' => 'unit', 'user_agent' => 'agent');
-	
+
 
 	/**
 	 * Constructor
 	 * @access	public
 	 */
 	function CI_Loader()
-	{	
+	{
 		$this->_ci_view_path = APPPATH.'views/';
 		$this->_ci_ob_level  = ob_get_level();
 		$this->_ci_library_paths = array(APPPATH, BASEPATH);
 		$this->_ci_helper_paths = array(APPPATH, BASEPATH);
 		$this->_ci_model_paths = array(APPPATH);
-			
+
 		log_message('debug', "Loader Class Initialized");
 	}
-	
+
 	// --------------------------------------------------------------------
-	
+
 	/**
 	 * Class Loader
 	 *
 	 * @param	mixed	the optional parameters
 	 * @param	string	an optional object name
 	 * @return	void
-	 */	
+	 */
 	function library($library = '', $params = NULL, $object_name = NULL)
 	{
 		if ($library == '' OR isset($this->_base_classes[$library]))
 		{
 			$this->_ci_load_class($library, $params, $object_name);
 		}
-		
+
 		$this->_ci_assign_to_models();
 	}
 
 	// --------------------------------------------------------------------
-	
+
 	/**
 	 * Model Loader
 	 *
 	 * @param	string	name for the model
 	 * @param	bool	database connection
 	 * @return	void
-	 */	
+	 */
 	function model($model, $name = '', $db_conn = FALSE)
-	{		
+	{
 		if (is_array($model))
 		{
 			foreach($model as $babe)
 			{
-				$this->model($babe);	
+				$this->model($babe);
 			}
 			return;
 		}
 		{
 			return;
 		}
-	
+
 		$path = '';
-	
+
 		// Is the model in a sub-folder? If so, parse out the filename and path.
 		if (($last_slash = strrpos($model, '/')) !== FALSE)
 		{
 			// And the model name behind it
 			$model = substr($model, $last_slash + 1);
 		}
-	
+
 		if ($name == '')
 		{
 			$name = $model;
 		}
-		
+
 		if (in_array($name, $this->_ci_models, TRUE))
 		{
 			return;
 		}
-		
+
 		$CI =& get_instance();
 		if (isset($CI->$name))
 		{
 			show_error('The model name you are loading is the name of a resource that is already being used: '.$name);
 		}
-	
+
 		$model = strtolower($model);
 
 		foreach ($this->_ci_model_paths as $mod_path)
 			$this->_ci_models[] = $name;
 			return;
 		}
-		
+
 		// couldn't find the model
 		show_error('Unable to locate the model you have specified: '.$model);
 	}
-		
+
 	// --------------------------------------------------------------------
-	
+
 	/**
 	 * Database Loader
 	 *
 	 * @param	bool	whether to return the DB object
 	 * @param	bool	whether to enable active record (this allows us to override the config setting)
 	 * @return	object
-	 */	
+	 */
 	function database($params = '', $return = FALSE, $active_record = NULL)
 	{
 		// Grab the super object
 		$CI =& get_instance();
-		
+
 		// Do we even need to load the database class?
 		if (class_exists('CI_DB') AND $return == FALSE AND $active_record == NULL AND isset($CI->db) AND is_object($CI->db))
 		{
 			return FALSE;
-		}	
-	
+		}
+
 		require_once(BASEPATH.'database/DB'.EXT);
 
 		if ($return === TRUE)
 		{
 			return DB($params, $active_record);
 		}
-		
-		// Initialize the db variable.  Needed to prevent   
+
+		// Initialize the db variable.  Needed to prevent
 		// reference errors with some configurations
 		$CI->db = '';
-		
+
 		// Load the DB class
-		$CI->db =& DB($params, $active_record);	
-		
+		$CI->db =& DB($params, $active_record);
+
 		// Assign the DB object to any existing models
 		$this->_ci_assign_to_models();
 	}
-	
+
 	// --------------------------------------------------------------------
 
 	/**
 	 * Load the Utilities Class
 	 *
 	 * @access	public
-	 * @return	string		
-	 */		
+	 * @return	string
+	 */
 	function dbutil()
 	{
 		if ( ! class_exists('CI_DB'))
 		{
 			$this->database();
 		}
-		
+
 		$CI =& get_instance();
 
 		// for backwards compatibility, load dbforge so we can extend dbutils off it
 		// this use is deprecated and strongly discouraged
 		$CI->load->dbforge();
-	
+
 		require_once(BASEPATH.'database/DB_utility'.EXT);
 		require_once(BASEPATH.'database/drivers/'.$CI->db->dbdriver.'/'.$CI->db->dbdriver.'_utility'.EXT);
 		$class = 'CI_DB_'.$CI->db->dbdriver.'_utility';
 
 		$CI->load->_ci_assign_to_models();
 	}
-	
+
 	// --------------------------------------------------------------------
 
 	/**
 	 * Load the Database Forge Class
 	 *
 	 * @access	public
-	 * @return	string		
-	 */		
+	 * @return	string
+	 */
 	function dbforge()
 	{
 		if ( ! class_exists('CI_DB'))
 		{
 			$this->database();
 		}
-		
+
 		$CI =& get_instance();
-	
+
 		require_once(BASEPATH.'database/DB_forge'.EXT);
 		require_once(BASEPATH.'database/drivers/'.$CI->db->dbdriver.'/'.$CI->db->dbdriver.'_forge'.EXT);
 		$class = 'CI_DB_'.$CI->db->dbdriver.'_forge';
 
 		$CI->dbforge = new $class();
-		
+
 		$CI->load->_ci_assign_to_models();
 	}
-	
+
 	// --------------------------------------------------------------------
-	
+
 	/**
 	 * Load View
 	 *
 	{
 		return $this->_ci_load(array('_ci_view' => $view, '_ci_vars' => $this->_ci_object_to_array($vars), '_ci_return' => $return));
 	}
-	
+
 	// --------------------------------------------------------------------
-	
+
 	/**
 	 * Load File
 	 *
 	{
 		return $this->_ci_load(array('_ci_path' => $path, '_ci_return' => $return));
 	}
-	
+
 	// --------------------------------------------------------------------
-	
+
 	/**
 	 * Set Variables
 	 *
 		{
 			$vars = array($vars => $val);
 		}
-	
+
 		$vars = $this->_ci_object_to_array($vars);
-	
+
 		if (is_array($vars) AND count($vars) > 0)
 		{
 			foreach ($vars as $key => $val)
 			}
 		}
 	}
-	
+
 	// --------------------------------------------------------------------
-	
+
 	/**
 	 * Load Helper
 	 *
 	 * @return	void
 	 */
 	function helper($helpers = array())
-	{	
+	{
 		foreach ($this->_ci_prep_filename($helpers, '_helper') as $helper)
-		{			
+		{
 			if (isset($this->_ci_helpers[$helper]))
 			{
 				continue;
 
 			$ext_helper = APPPATH.'helpers/'.config_item('subclass_prefix').$helper.EXT;
 
-			// Is this a helper extension request?			
+			// Is this a helper extension request?
 			if (file_exists($ext_helper))
 			{
 				$base_helper = BASEPATH.'helpers/'.$helper.EXT;
-				
+
 				if ( ! file_exists($base_helper))
 				{
 					show_error('Unable to load the requested file: helpers/'.$helper.EXT);
 				}
-				
+
 				include_once($ext_helper);
 				include_once($base_helper);
-				
+
 				$this->_ci_helpers[$helper] = TRUE;
 				log_message('debug', 'Helper loaded: '.$helper);
 				continue;
 			}
-			
+
 			// Try to load the helper
 			foreach ($this->_ci_helper_paths as $path)
 			{
 				if (file_exists($path.'helpers/'.$helper.EXT))
-				{ 
+				{
 					include_once($path.'helpers/'.$helper.EXT);
 
 					$this->_ci_helpers[$helper] = TRUE;
-					log_message('debug', 'Helper loaded: '.$helper);	
+					log_message('debug', 'Helper loaded: '.$helper);
 					break;
 				}
 			}
 			// unable to load the helper
 			if ( ! isset($this->_ci_helpers[$helper]))
 			{
-				show_error('Unable to load the requested file: helpers/'.$helper.EXT);				
+				show_error('Unable to load the requested file: helpers/'.$helper.EXT);
 			}
-		}		
+		}
 	}
-	
+
 	// --------------------------------------------------------------------
-	
+
 	/**
 	 * Load Helpers
 	 *
 	{
 		$this->helper($helpers);
 	}
-	
+
 	// --------------------------------------------------------------------
-	
+
 	/**
 	 * Loads a language file
 	 *
 		}
 
 		foreach ($file as $langfile)
-		{	
+		{
 			$CI->lang->load($langfile, $lang);
 		}
 	}
-	
+
 	// --------------------------------------------------------------------
-	
+
 	/**
 	 * Loads a config file
 	 *
 	 * @return	void
 	 */
 	function config($file = '', $use_sections = FALSE, $fail_gracefully = FALSE)
-	{			
+	{
 		$CI =& get_instance();
 		$CI->config->load($file, $use_sections, $fail_gracefully);
 	}
 			// we aren't instantiating an object here, that'll be done by the Library itself
 			require BASEPATH.'libraries/Driver'.EXT;
 		}
-		
+
 		// We can save the loader some time since Drivers will *always* be in a subfolder,
 		// and typically identically named to the library
 		if ( ! strpos($library, '/'))
 		{
 			$library = ucfirst($library).'/'.$library;
 		}
-		
+
 		return $this->library($library, $params, $object_name);
 	}
 
 	// --------------------------------------------------------------------
-	
+
 	/**
 	 * Add Package Path
 	 *
 		array_unshift($this->_ci_library_paths, $path);
 		array_unshift($this->_ci_model_paths, $path);
 		array_unshift($this->_ci_helper_paths, $path);
-		
+
 		// Add config file path
 		$config =& $this->_ci_get_component('config');
 		array_unshift($config->_config_paths, $path);
 	function remove_package_path($path = '', $remove_config_path = TRUE)
 	{
 		$config =& $this->_ci_get_component('config');
-		
+
 		if ($path == '')
 		{
 			$void = array_shift($this->_ci_library_paths);
 					unset($this->{$var}[$key]);
 				}
 			}
-			
+
 			if (($key = array_search($path, $config->_config_paths)) !== FALSE)
 			{
 				unset($config->_config_paths[$key]);
 			}
 		}
-		
+
 		// make sure the application default paths are still in the array
 		$this->_ci_library_paths = array_unique(array_merge($this->_ci_library_paths, array(APPPATH, BASEPATH)));
 		$this->_ci_helper_paths = array_unique(array_merge($this->_ci_helper_paths, array(APPPATH, BASEPATH)));
 	}
 
 	// --------------------------------------------------------------------
-	
+
 	/**
 	 * Loader
 	 *
 			$_ci_x = explode('/', $_ci_path);
 			$_ci_file = end($_ci_x);
 		}
-		
+
 		if ( ! file_exists($_ci_path))
 		{
 			show_error('Unable to load the requested file: '.$_ci_file);
 		}
-	
+
 		// This allows anything loaded using $this->load (views, files, etc.)
 		// to become accessible from within the Controller and Model functions.
 		// Only needed when running PHP 5
-		
+
 		if ($this->_ci_is_instance())
 		{
 			$_ci_CI =& get_instance();
 		 * function or via the second parameter of this function. We'll merge
 		 * the two types and cache them so that views that are embedded within
 		 * other views can have access to these variables.
-		 */	
+		 */
 		if (is_array($_ci_vars))
 		{
 			$this->_ci_cached_vars = array_merge($this->_ci_cached_vars, $_ci_vars);
 		}
 		extract($this->_ci_cached_vars);
-				
+
 		/*
 		 * Buffer the output
 		 *
 		 * the browser and then stop the timer it won't be accurate.
 		 */
 		ob_start();
-				
+
 		// If the PHP installation does not support short tags we'll
 		// do a little string replacement, changing the short tags
 		// to standard PHP echo statements.
-		
+
 		if ((bool) @ini_get('short_open_tag') === FALSE AND config_item('rewrite_short_tags') == TRUE)
 		{
 			echo eval('?>'.preg_replace("/;*\s*\?>/", "; ?>", str_replace('<?=', '<?php echo ', file_get_contents($_ci_path))));
 		{
 			include($_ci_path); // include() vs include_once() allows for multiple views with the same name
 		}
-		
+
 		log_message('debug', 'File loaded: '.$_ci_path);
-		
+
 		// Return the file data if requested
 		if ($_ci_return === TRUE)
-		{		
+		{
 			$buffer = ob_get_contents();
 			@ob_end_clean();
 			return $buffer;
 		 * it can be seen and included properly by the first included
 		 * template and any subsequent ones. Oy!
 		 *
-		 */	
+		 */
 		if (ob_get_level() > $this->_ci_ob_level + 1)
 		{
 			ob_end_flush();
 	 * This function loads the requested class.
 	 *
 	 * @access	private
-	 * @param 	string	the item that is being loaded
+	 * @param	string	the item that is being loaded
 	 * @param	mixed	any additional parameters
 	 * @param	string	an optional object name
-	 * @return 	void
+	 * @return	void
 	 */
 	function _ci_load_class($class, $params = NULL, $object_name = NULL)
-	{	
-		// Get the class name, and while we're at it trim any slashes.  
-		// The directory path can be included as part of the class name, 
+	{
+		// Get the class name, and while we're at it trim any slashes.
+		// The directory path can be included as part of the class name,
 		// but we don't want a leading slash
 		$class = str_replace(EXT, '', trim($class, '/'));
-	
+
 		// Was the path included with the class name?
 		// We look for a slash to determine this
 		$subdir = '';
 		{
 			// Extract the path
 			$subdir = substr($class, 0, $last_slash + 1);
-			
+
 			// Get the filename from the path
 			$class = substr($class, $last_slash + 1);
 		}
 		{
 			$subclass = APPPATH.'libraries/'.$subdir.config_item('subclass_prefix').$class.EXT;
 
-			// Is this a class extension request?			
+			// Is this a class extension request?
 			if (file_exists($subclass))
 			{
 				$baseclass = BASEPATH.'libraries/'.ucfirst($class).EXT;
-				
+
 				if ( ! file_exists($baseclass))
 				{
 					log_message('error', "Unable to load the requested class: ".$class);
 						$CI =& get_instance();
 						if ( ! isset($CI->$object_name))
 						{
-							return $this->_ci_init_class($class, config_item('subclass_prefix'), $params, $object_name);			
+							return $this->_ci_init_class($class, config_item('subclass_prefix'), $params, $object_name);
 						}
 					}
-					
+
 					$is_duplicate = TRUE;
 					log_message('debug', $class." class already loaded. Second attempt ignored.");
 					return;
 				}
-	
-				include_once($baseclass);				
+
+				include_once($baseclass);
 				include_once($subclass);
 				$this->_ci_loaded_files[] = $subclass;