<?php
/**
 * YiiBase class file.
 *
 * @author Qiang Xue <qiang.xue@gmail.com>
 * @link http://www.yiiframework.com/
 * @copyright 2008-2013 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 * @package system
 * @since 1.0
 */

/**
 * Gets the application start timestamp.
 */
defined ( 'YII_BEGIN_TIME' ) or define ( 'YII_BEGIN_TIME', microtime ( true ) );
/**
 * This constant defines whether the application should be in debug mode or not.
 * Defaults to false.
 */
defined ( 'YII_DEBUG' ) or define ( 'YII_DEBUG', false );
/**
 * This constant defines how much call stack information (file name and line number) should be logged by Yii::trace().
 * Defaults to 0, meaning no backtrace information. If it is greater than 0,
 * at most that number of call stacks will be logged. Note, only user application call stacks are considered.
 */
defined ( 'YII_TRACE_LEVEL' ) or define ( 'YII_TRACE_LEVEL', 0 );
/**
 * This constant defines whether exception handling should be enabled.
 * Defaults to true.
 */
defined ( 'YII_ENABLE_EXCEPTION_HANDLER' ) or define ( 'YII_ENABLE_EXCEPTION_HANDLER', true );
/**
 * This constant defines whether error handling should be enabled.
 * Defaults to true.
 */
defined ( 'YII_ENABLE_ERROR_HANDLER' ) or define ( 'YII_ENABLE_ERROR_HANDLER', true );
/**
 * Defines the Yii framework installation path.
 */
defined ( 'YII_PATH' ) or define ( 'YII_PATH', dirname ( __FILE__ ) );
/**
 * Defines the Zii library installation path.
 */
defined ( 'YII_ZII_PATH' ) or define ( 'YII_ZII_PATH', YII_PATH . DIRECTORY_SEPARATOR . 'zii' );

/**
 * YiiBase is a helper class serving common framework functionalities.
 *
 * Do not use YiiBase directly. Instead, use its child class {@link Yii} where
 * you can customize methods of YiiBase.
 *
 * @author Qiang Xue <qiang.xue@gmail.com>
 * @package system
 * @since 1.0
 */
class YiiBase {
	/**
	 *
	 * @var array class map used by the Yii autoloading mechanism.
	 *      The array keys are the class names and the array values are the corresponding class file paths.
	 * @since 1.1.5
	 */
	public static $classMap = array ();
	/**
	 *
	 * @var boolean whether to rely on PHP include path to autoload class files. Defaults to true.
	 *      You may set this to be false if your hosting environment doesn't allow changing the PHP
	 *      include path, or if you want to append additional autoloaders to the default Yii autoloader.
	 * @since 1.1.8
	 */
	public static $enableIncludePath = true;
	private static $_aliases = array (
			'system' => YII_PATH,
			'zii' => YII_ZII_PATH 
	); // alias => path
	private static $_imports = array (); // alias => class name or directory
	private static $_includePaths; // list of include paths
	private static $_app;
	private static $_logger;
	
	/**
	 *
	 * @return string the version of Yii framework
	 */
	public static function getVersion() {
		return '1.1.14';
	}
	
	/**
	 * Creates a Web application instance.
	 * 
	 * @param mixed $config
	 *        	application configuration.
	 *        	If a string, it is treated as the path of the file that contains the configuration;
	 *        	If an array, it is the actual configuration information.
	 *        	Please make sure you specify the {@link CApplication::basePath basePath} property in the configuration,
	 *        	which should point to the directory containing all application logic, template and data.
	 *        	If not, the directory will be defaulted to 'protected'.
	 * @return CWebApplication
	 */
	public static function createWebApplication($config = null) {
		return self::createApplication ( 'CWebApplication', $config );
	}
	
	/**
	 * Creates a console application instance.
	 * 
	 * @param mixed $config
	 *        	application configuration.
	 *        	If a string, it is treated as the path of the file that contains the configuration;
	 *        	If an array, it is the actual configuration information.
	 *        	Please make sure you specify the {@link CApplication::basePath basePath} property in the configuration,
	 *        	which should point to the directory containing all application logic, template and data.
	 *        	If not, the directory will be defaulted to 'protected'.
	 * @return CConsoleApplication
	 */
	public static function createConsoleApplication($config = null) {
		return self::createApplication ( 'CConsoleApplication', $config );
	}
	
	/**
	 * Creates an application of the specified class.
	 * 
	 * @param string $class
	 *        	the application class name
	 * @param mixed $config
	 *        	application configuration. This parameter will be passed as the parameter
	 *        	to the constructor of the application class.
	 * @return mixed the application instance
	 */
	public static function createApplication($class, $config = null) {
		return new $class ( $config );
	}
	
	/**
	 * Returns the application singleton or null if the singleton has not been created yet.
	 * 
	 * @return CApplication the application singleton, null if the singleton has not been created yet.
	 */
	public static function app() {
		return self::$_app;
	}
	
	/**
	 * Stores the application instance in the class static member.
	 * This method helps implement a singleton pattern for CApplication.
	 * Repeated invocation of this method or the CApplication constructor
	 * will cause the throw of an exception.
	 * To retrieve the application instance, use {@link app()}.
	 * 
	 * @param CApplication $app
	 *        	the application instance. If this is null, the existing
	 *        	application singleton will be removed.
	 * @throws CException if multiple application instances are registered.
	 */
	public static function setApplication($app) {
		if (self::$_app === null || $app === null)
			self::$_app = $app;
		else
			throw new CException ( Yii::t ( 'yii', 'Yii application can only be created once.' ) );
	}
	
	/**
	 *
	 * @return string the path of the framework
	 */
	public static function getFrameworkPath() {
		return YII_PATH;
	}
	
	/**
	 * Creates an object and initializes it based on the given configuration.
	 *
	 * The specified configuration can be either a string or an array.
	 * If the former, the string is treated as the object type which can
	 * be either the class name or {@link YiiBase::getPathOfAlias class path alias}.
	 * If the latter, the 'class' element is treated as the object type,
	 * and the rest of the name-value pairs in the array are used to initialize
	 * the corresponding object properties.
	 *
	 * Any additional parameters passed to this method will be
	 * passed to the constructor of the object being created.
	 *
	 * @param mixed $config
	 *        	the configuration. It can be either a string or an array.
	 * @return mixed the created object
	 * @throws CException if the configuration does not have a 'class' element.
	 */
	public static function createComponent($config) {
		if (is_string ( $config )) {
			$type = $config;
			$config = array ();
		} elseif (isset ( $config ['class'] )) {
			$type = $config ['class'];
			unset ( $config ['class'] );
		} else
			throw new CException ( Yii::t ( 'yii', 'Object configuration must be an array containing a "class" element.' ) );
		
		if (! class_exists ( $type, false ))
			$type = Yii::import ( $type, true );
		
		if (($n = func_num_args ()) > 1) {
			$args = func_get_args ();
			if ($n === 2)
				$object = new $type ( $args [1] );
			elseif ($n === 3)
				$object = new $type ( $args [1], $args [2] );
			elseif ($n === 4)
				$object = new $type ( $args [1], $args [2], $args [3] );
			else {
				unset ( $args [0] );
				$class = new ReflectionClass ( $type );
				// Note: ReflectionClass::newInstanceArgs() is available for PHP 5.1.3+
				// $object=$class->newInstanceArgs($args);
				$object = call_user_func_array ( array (
						$class,
						'newInstance' 
				), $args );
			}
		} else
			$object = new $type ();
		
		foreach ( $config as $key => $value )
			$object->$key = $value;
		
		return $object;
	}
	
	/**
	 * Imports a class or a directory.
	 *
	 * Importing a class is like including the corresponding class file.
	 * The main difference is that importing a class is much lighter because it only
	 * includes the class file when the class is referenced the first time.
	 *
	 * Importing a directory is equivalent to adding a directory into the PHP include path.
	 * If multiple directories are imported, the directories imported later will take
	 * precedence in class file searching (i.e., they are added to the front of the PHP include path).
	 *
	 * Path aliases are used to import a class or directory. For example,
	 * <ul>
	 * <li><code>application.components.GoogleMap</code>: import the <code>GoogleMap</code> class.</li>
	 * <li><code>application.components.*</code>: import the <code>components</code> directory.</li>
	 * </ul>
	 *
	 * The same path alias can be imported multiple times, but only the first time is effective.
	 * Importing a directory does not import any of its subdirectories.
	 *
	 * Starting from version 1.1.5, this method can also be used to import a class in namespace format
	 * (available for PHP 5.3 or above only). It is similar to importing a class in path alias format,
	 * except that the dot separator is replaced by the backslash separator. For example, importing
	 * <code>application\components\GoogleMap</code> is similar to importing <code>application.components.GoogleMap</code>.
	 * The difference is that the former class is using qualified name, while the latter unqualified.
	 *
	 * Note, importing a class in namespace format requires that the namespace corresponds to
	 * a valid path alias once backslash characters are replaced with dot characters.
	 * For example, the namespace <code>application\components</code> must correspond to a valid
	 * path alias <code>application.components</code>.
	 *
	 * @param string $alias
	 *        	path alias to be imported
	 * @param boolean $forceInclude
	 *        	whether to include the class file immediately. If false, the class file
	 *        	will be included only when the class is being used. This parameter is used only when
	 *        	the path alias refers to a class.
	 * @return string the class name or the directory that this alias refers to
	 * @throws CException if the alias is invalid
	 */
	public static function import($alias, $forceInclude = false) {
		if (isset ( self::$_imports [$alias] )) // previously imported
			return self::$_imports [$alias];
		
		if (class_exists ( $alias, false ) || interface_exists ( $alias, false ))
			return self::$_imports [$alias] = $alias;
		
		if (($pos = strrpos ( $alias, '\\' )) !== false) // a class name in PHP 5.3 namespace format
{
			$namespace = str_replace ( '\\', '.', ltrim ( substr ( $alias, 0, $pos ), '\\' ) );
			if (($path = self::getPathOfAlias ( $namespace )) !== false) {
				$classFile = $path . DIRECTORY_SEPARATOR . substr ( $alias, $pos + 1 ) . '.php';
				if ($forceInclude) {
					if (is_file ( $classFile ))
						require ($classFile);
					else
						throw new CException ( Yii::t ( 'yii', 'Alias "{alias}" is invalid. Make sure it points to an existing PHP file and the file is readable.', array (
								'{alias}' => $alias 
						) ) );
					self::$_imports [$alias] = $alias;
				} else
					self::$classMap [$alias] = $classFile;
				return $alias;
			} else {
				// try to autoload the class with an autoloader
				if (class_exists ( $alias, true ))
					return self::$_imports [$alias] = $alias;
				else
					throw new CException ( Yii::t ( 'yii', 'Alias "{alias}" is invalid. Make sure it points to an existing directory or file.', array (
							'{alias}' => $namespace 
					) ) );
			}
		}
		
		if (($pos = strrpos ( $alias, '.' )) === false) // a simple class name
{
			if ($forceInclude && self::autoload ( $alias ))
				self::$_imports [$alias] = $alias;
			return $alias;
		}
		
		$className = ( string ) substr ( $alias, $pos + 1 );
		$isClass = $className !== '*';
		
		if ($isClass && (class_exists ( $className, false ) || interface_exists ( $className, false )))
			return self::$_imports [$alias] = $className;
		
		if (($path = self::getPathOfAlias ( $alias )) !== false) {
			if ($isClass) {
				if ($forceInclude) {
					if (is_file ( $path . '.php' ))
						require ($path . '.php');
					else
						throw new CException ( Yii::t ( 'yii', 'Alias "{alias}" is invalid. Make sure it points to an existing PHP file and the file is readable.', array (
								'{alias}' => $alias 
						) ) );
					self::$_imports [$alias] = $className;
				} else
					self::$classMap [$className] = $path . '.php';
				return $className;
			} else // a directory
{
				if (self::$_includePaths === null) {
					self::$_includePaths = array_unique ( explode ( PATH_SEPARATOR, get_include_path () ) );
					if (($pos = array_search ( '.', self::$_includePaths, true )) !== false)
						unset ( self::$_includePaths [$pos] );
				}
				
				array_unshift ( self::$_includePaths, $path );
				
				if (self::$enableIncludePath && set_include_path ( '.' . PATH_SEPARATOR . implode ( PATH_SEPARATOR, self::$_includePaths ) ) === false)
					self::$enableIncludePath = false;
				
				return self::$_imports [$alias] = $path;
			}
		} else
			throw new CException ( Yii::t ( 'yii', 'Alias "{alias}" is invalid. Make sure it points to an existing directory or file.', array (
					'{alias}' => $alias 
			) ) );
	}
	
	/**
	 * Translates an alias into a file path.
	 * Note, this method does not ensure the existence of the resulting file path.
	 * It only checks if the root alias is valid or not.
	 * 
	 * @param string $alias
	 *        	alias (e.g. system.web.CController)
	 * @return mixed file path corresponding to the alias, false if the alias is invalid.
	 */
	public static function getPathOfAlias($alias) {
		if (isset ( self::$_aliases [$alias] ))
			return self::$_aliases [$alias];
		elseif (($pos = strpos ( $alias, '.' )) !== false) {
			$rootAlias = substr ( $alias, 0, $pos );
			if (isset ( self::$_aliases [$rootAlias] ))
				return self::$_aliases [$alias] = rtrim ( self::$_aliases [$rootAlias] . DIRECTORY_SEPARATOR . str_replace ( '.', DIRECTORY_SEPARATOR, substr ( $alias, $pos + 1 ) ), '*' . DIRECTORY_SEPARATOR );
			elseif (self::$_app instanceof CWebApplication) {
				if (self::$_app->findModule ( $rootAlias ) !== null)
					return self::getPathOfAlias ( $alias );
			}
		}
		return false;
	}
	
	/**
	 * Create a path alias.
	 * Note, this method neither checks the existence of the path nor normalizes the path.
	 * 
	 * @param string $alias
	 *        	alias to the path
	 * @param string $path
	 *        	the path corresponding to the alias. If this is null, the corresponding
	 *        	path alias will be removed.
	 */
	public static function setPathOfAlias($alias, $path) {
		if (empty ( $path ))
			unset ( self::$_aliases [$alias] );
		else
			self::$_aliases [$alias] = rtrim ( $path, '\\/' );
	}
	
	/**
	 * Class autoload loader.
	 * This method is provided to be invoked within an __autoload() magic method.
	 * 
	 * @param string $className
	 *        	class name
	 * @return boolean whether the class has been loaded successfully
	 */
	public static function autoload($className) {
		// use include so that the error PHP file may appear
		if (isset ( self::$classMap [$className] ))
			include (self::$classMap [$className]);
		elseif (isset ( self::$_coreClasses [$className] ))
			include (YII_PATH . self::$_coreClasses [$className]);
		else {
			// include class file relying on include_path
			if (strpos ( $className, '\\' ) === false) // class without namespace
{
				if (self::$enableIncludePath === false) {
					foreach ( self::$_includePaths as $path ) {
						$classFile = $path . DIRECTORY_SEPARATOR . $className . '.php';
						if (is_file ( $classFile )) {
							include ($classFile);
							if (YII_DEBUG && basename ( realpath ( $classFile ) ) !== $className . '.php')
								throw new CException ( Yii::t ( 'yii', 'Class name "{class}" does not match class file "{file}".', array (
										'{class}' => $className,
										'{file}' => $classFile 
								) ) );
							break;
						}
					}
				} else
					include ($className . '.php');
			} else // class name with namespace in PHP 5.3
{
				$namespace = str_replace ( '\\', '.', ltrim ( $className, '\\' ) );
				if (($path = self::getPathOfAlias ( $namespace )) !== false)
					include ($path . '.php');
				else
					return false;
			}
			return class_exists ( $className, false ) || interface_exists ( $className, false );
		}
		return true;
	}
	
	/**
	 * Writes a trace message.
	 * This method will only log a message when the application is in debug mode.
	 * 
	 * @param string $msg
	 *        	message to be logged
	 * @param string $category
	 *        	category of the message
	 * @see log
	 */
	public static function trace($msg, $category = 'application') {
		if (YII_DEBUG)
			self::log ( $msg, CLogger::LEVEL_TRACE, $category );
	}
	
	/**
	 * Logs a message.
	 * Messages logged by this method may be retrieved via {@link CLogger::getLogs}
	 * and may be recorded in different media, such as file, email, database, using
	 * {@link CLogRouter}.
	 * 
	 * @param string $msg
	 *        	message to be logged
	 * @param string $level
	 *        	level of the message (e.g. 'trace', 'warning', 'error'). It is case-insensitive.
	 * @param string $category
	 *        	category of the message (e.g. 'system.web'). It is case-insensitive.
	 */
	public static function log($msg, $level = CLogger::LEVEL_INFO, $category = 'application') {
		if (self::$_logger === null)
			self::$_logger = new CLogger ();
		if (YII_DEBUG && YII_TRACE_LEVEL > 0 && $level !== CLogger::LEVEL_PROFILE) {
			$traces = debug_backtrace ();
			$count = 0;
			foreach ( $traces as $trace ) {
				if (isset ( $trace ['file'], $trace ['line'] ) && strpos ( $trace ['file'], YII_PATH ) !== 0) {
					$msg .= "\nin " . $trace ['file'] . ' (' . $trace ['line'] . ')';
					if (++ $count >= YII_TRACE_LEVEL)
						break;
				}
			}
		}
		self::$_logger->log ( $msg, $level, $category );
	}
	
	/**
	 * Marks the beginning of a code block for profiling.
	 * This has to be matched with a call to {@link endProfile()} with the same token.
	 * The begin- and end- calls must also be properly nested, e.g.,
	 * <pre>
	 * Yii::beginProfile('block1');
	 * Yii::beginProfile('block2');
	 * Yii::endProfile('block2');
	 * Yii::endProfile('block1');
	 * </pre>
	 * The following sequence is not valid:
	 * <pre>
	 * Yii::beginProfile('block1');
	 * Yii::beginProfile('block2');
	 * Yii::endProfile('block1');
	 * Yii::endProfile('block2');
	 * </pre>
	 * 
	 * @param string $token
	 *        	token for the code block
	 * @param string $category
	 *        	the category of this log message
	 * @see endProfile
	 */
	public static function beginProfile($token, $category = 'application') {
		self::log ( 'begin:' . $token, CLogger::LEVEL_PROFILE, $category );
	}
	
	/**
	 * Marks the end of a code block for profiling.
	 * This has to be matched with a previous call to {@link beginProfile()} with the same token.
	 * 
	 * @param string $token
	 *        	token for the code block
	 * @param string $category
	 *        	the category of this log message
	 * @see beginProfile
	 */
	public static function endProfile($token, $category = 'application') {
		self::log ( 'end:' . $token, CLogger::LEVEL_PROFILE, $category );
	}
	
	/**
	 *
	 * @return CLogger message logger
	 */
	public static function getLogger() {
		if (self::$_logger !== null)
			return self::$_logger;
		else
			return self::$_logger = new CLogger ();
	}
	
	/**
	 * Sets the logger object.
	 * 
	 * @param CLogger $logger
	 *        	the logger object.
	 * @since 1.1.8
	 */
	public static function setLogger($logger) {
		self::$_logger = $logger;
	}
	
	/**
	 * Returns a string that can be displayed on your Web page showing Powered-by-Yii information
	 * 
	 * @return string a string that can be displayed on your Web page showing Powered-by-Yii information
	 */
	public static function powered() {
		return Yii::t ( 'yii', 'Powered by {yii}.', array (
				'{yii}' => '<a href="http://www.yiiframework.com/" rel="external">Yii Framework</a>' 
		) );
	}
	
	/**
	 * Translates a message to the specified language.
	 * This method supports choice format (see {@link CChoiceFormat}),
	 * i.e., the message returned will be chosen from a few candidates according to the given
	 * number value. This feature is mainly used to solve plural format issue in case
	 * a message has different plural forms in some languages.
	 * 
	 * @param string $category
	 *        	message category. Please use only word letters. Note, category 'yii' is
	 *        	reserved for Yii framework core code use. See {@link CPhpMessageSource} for
	 *        	more interpretation about message category.
	 * @param string $message
	 *        	the original message
	 * @param array $params
	 *        	parameters to be applied to the message using <code>strtr</code>.
	 *        	The first parameter can be a number without key.
	 *        	And in this case, the method will call {@link CChoiceFormat::format} to choose
	 *        	an appropriate message translation.
	 *        	Starting from version 1.1.6 you can pass parameter for {@link CChoiceFormat::format}
	 *        	or plural forms format without wrapping it with array.
	 *        	This parameter is then available as <code>{n}</code> in the message translation string.
	 * @param string $source
	 *        	which message source application component to use.
	 *        	Defaults to null, meaning using 'coreMessages' for messages belonging to
	 *        	the 'yii' category and using 'messages' for the rest messages.
	 * @param string $language
	 *        	the target language. If null (default), the {@link CApplication::getLanguage application language} will be used.
	 * @return string the translated message
	 * @see CMessageSource
	 */
	public static function t($category, $message, $params = array(), $source = null, $language = null) {
		if (self::$_app !== null) {
			if ($source === null)
				$source = ($category === 'yii' || $category === 'zii') ? 'coreMessages' : 'messages';
			if (($source = self::$_app->getComponent ( $source )) !== null)
				$message = $source->translate ( $category, $message, $language );
		}
		if ($params === array ())
			return $message;
		if (! is_array ( $params ))
			$params = array (
					$params 
			);
		if (isset ( $params [0] )) // number choice
{
			if (strpos ( $message, '|' ) !== false) {
				if (strpos ( $message, '#' ) === false) {
					$chunks = explode ( '|', $message );
					$expressions = self::$_app->getLocale ( $language )->getPluralRules ();
					if ($n = min ( count ( $chunks ), count ( $expressions ) )) {
						for($i = 0; $i < $n; $i ++)
							$chunks [$i] = $expressions [$i] . '#' . $chunks [$i];
						
						$message = implode ( '|', $chunks );
					}
				}
				$message = CChoiceFormat::format ( $message, $params [0] );
			}
			if (! isset ( $params ['{n}'] ))
				$params ['{n}'] = $params [0];
			unset ( $params [0] );
		}
		return $params !== array () ? strtr ( $message, $params ) : $message;
	}
	
	/**
	 * Registers a new class autoloader.
	 * The new autoloader will be placed before {@link autoload} and after
	 * any other existing autoloaders.
	 * 
	 * @param callback $callback
	 *        	a valid PHP callback (function name or array($className,$methodName)).
	 * @param boolean $append
	 *        	whether to append the new autoloader after the default Yii autoloader.
	 *        	Be careful using this option as it will disable {@link enableIncludePath autoloading via include path}
	 *        	when set to true. After this the Yii autoloader can not rely on loading classes via simple include anymore
	 *        	and you have to {@link import} all classes explicitly.
	 */
	public static function registerAutoloader($callback, $append = false) {
		if ($append) {
			self::$enableIncludePath = false;
			spl_autoload_register ( $callback );
		} else {
			spl_autoload_unregister ( array (
					'YiiBase',
					'autoload' 
			) );
			spl_autoload_register ( $callback );
			spl_autoload_register ( array (
					'YiiBase',
					'autoload' 
			) );
		}
	}
	
	/**
	 *
	 * @var array class map for core Yii classes.
	 *      NOTE, DO NOT MODIFY THIS ARRAY MANUALLY. IF YOU CHANGE OR ADD SOME CORE CLASSES,
	 *      PLEASE RUN 'build autoload' COMMAND TO UPDATE THIS ARRAY.
	 */
	private static $_coreClasses = array (
			'CApplication' => '/base/CApplication.php',
			'CApplicationComponent' => '/base/CApplicationComponent.php',
			'CBehavior' => '/base/CBehavior.php',
			'CComponent' => '/base/CComponent.php',
			'CErrorEvent' => '/base/CErrorEvent.php',
			'CErrorHandler' => '/base/CErrorHandler.php',
			'CException' => '/base/CException.php',
			'CExceptionEvent' => '/base/CExceptionEvent.php',
			'CHttpException' => '/base/CHttpException.php',
			'CModel' => '/base/CModel.php',
			'CModelBehavior' => '/base/CModelBehavior.php',
			'CModelEvent' => '/base/CModelEvent.php',
			'CModule' => '/base/CModule.php',
			'CSecurityManager' => '/base/CSecurityManager.php',
			'CStatePersister' => '/base/CStatePersister.php',
			'CApcCache' => '/caching/CApcCache.php',
			'CCache' => '/caching/CCache.php',
			'CDbCache' => '/caching/CDbCache.php',
			'CDummyCache' => '/caching/CDummyCache.php',
			'CEAcceleratorCache' => '/caching/CEAcceleratorCache.php',
			'CFileCache' => '/caching/CFileCache.php',
			'CMemCache' => '/caching/CMemCache.php',
			'CRedisCache' => '/caching/CRedisCache.php',
			'CWinCache' => '/caching/CWinCache.php',
			'CXCache' => '/caching/CXCache.php',
			'CZendDataCache' => '/caching/CZendDataCache.php',
			'CCacheDependency' => '/caching/dependencies/CCacheDependency.php',
			'CChainedCacheDependency' => '/caching/dependencies/CChainedCacheDependency.php',
			'CDbCacheDependency' => '/caching/dependencies/CDbCacheDependency.php',
			'CDirectoryCacheDependency' => '/caching/dependencies/CDirectoryCacheDependency.php',
			'CExpressionDependency' => '/caching/dependencies/CExpressionDependency.php',
			'CFileCacheDependency' => '/caching/dependencies/CFileCacheDependency.php',
			'CGlobalStateCacheDependency' => '/caching/dependencies/CGlobalStateCacheDependency.php',
			'CAttributeCollection' => '/collections/CAttributeCollection.php',
			'CConfiguration' => '/collections/CConfiguration.php',
			'CList' => '/collections/CList.php',
			'CListIterator' => '/collections/CListIterator.php',
			'CMap' => '/collections/CMap.php',
			'CMapIterator' => '/collections/CMapIterator.php',
			'CQueue' => '/collections/CQueue.php',
			'CQueueIterator' => '/collections/CQueueIterator.php',
			'CStack' => '/collections/CStack.php',
			'CStackIterator' => '/collections/CStackIterator.php',
			'CTypedList' => '/collections/CTypedList.php',
			'CTypedMap' => '/collections/CTypedMap.php',
			'CConsoleApplication' => '/console/CConsoleApplication.php',
			'CConsoleCommand' => '/console/CConsoleCommand.php',
			'CConsoleCommandBehavior' => '/console/CConsoleCommandBehavior.php',
			'CConsoleCommandEvent' => '/console/CConsoleCommandEvent.php',
			'CConsoleCommandRunner' => '/console/CConsoleCommandRunner.php',
			'CHelpCommand' => '/console/CHelpCommand.php',
			'CDbCommand' => '/db/CDbCommand.php',
			'CDbConnection' => '/db/CDbConnection.php',
			'CDbDataReader' => '/db/CDbDataReader.php',
			'CDbException' => '/db/CDbException.php',
			'CDbMigration' => '/db/CDbMigration.php',
			'CDbTransaction' => '/db/CDbTransaction.php',
			'CActiveFinder' => '/db/ar/CActiveFinder.php',
			'CActiveRecord' => '/db/ar/CActiveRecord.php',
			'CActiveRecordBehavior' => '/db/ar/CActiveRecordBehavior.php',
			'CDbColumnSchema' => '/db/schema/CDbColumnSchema.php',
			'CDbCommandBuilder' => '/db/schema/CDbCommandBuilder.php',
			'CDbCriteria' => '/db/schema/CDbCriteria.php',
			'CDbExpression' => '/db/schema/CDbExpression.php',
			'CDbSchema' => '/db/schema/CDbSchema.php',
			'CDbTableSchema' => '/db/schema/CDbTableSchema.php',
			'CMssqlColumnSchema' => '/db/schema/mssql/CMssqlColumnSchema.php',
			'CMssqlCommandBuilder' => '/db/schema/mssql/CMssqlCommandBuilder.php',
			'CMssqlPdoAdapter' => '/db/schema/mssql/CMssqlPdoAdapter.php',
			'CMssqlSchema' => '/db/schema/mssql/CMssqlSchema.php',
			'CMssqlSqlsrvPdoAdapter' => '/db/schema/mssql/CMssqlSqlsrvPdoAdapter.php',
			'CMssqlTableSchema' => '/db/schema/mssql/CMssqlTableSchema.php',
			'CMysqlColumnSchema' => '/db/schema/mysql/CMysqlColumnSchema.php',
			'CMysqlCommandBuilder' => '/db/schema/mysql/CMysqlCommandBuilder.php',
			'CMysqlSchema' => '/db/schema/mysql/CMysqlSchema.php',
			'CMysqlTableSchema' => '/db/schema/mysql/CMysqlTableSchema.php',
			'COciColumnSchema' => '/db/schema/oci/COciColumnSchema.php',
			'COciCommandBuilder' => '/db/schema/oci/COciCommandBuilder.php',
			'COciSchema' => '/db/schema/oci/COciSchema.php',
			'COciTableSchema' => '/db/schema/oci/COciTableSchema.php',
			'CPgsqlColumnSchema' => '/db/schema/pgsql/CPgsqlColumnSchema.php',
			'CPgsqlCommandBuilder' => '/db/schema/pgsql/CPgsqlCommandBuilder.php',
			'CPgsqlSchema' => '/db/schema/pgsql/CPgsqlSchema.php',
			'CPgsqlTableSchema' => '/db/schema/pgsql/CPgsqlTableSchema.php',
			'CSqliteColumnSchema' => '/db/schema/sqlite/CSqliteColumnSchema.php',
			'CSqliteCommandBuilder' => '/db/schema/sqlite/CSqliteCommandBuilder.php',
			'CSqliteSchema' => '/db/schema/sqlite/CSqliteSchema.php',
			'CChoiceFormat' => '/i18n/CChoiceFormat.php',
			'CDateFormatter' => '/i18n/CDateFormatter.php',
			'CDbMessageSource' => '/i18n/CDbMessageSource.php',
			'CGettextMessageSource' => '/i18n/CGettextMessageSource.php',
			'CLocale' => '/i18n/CLocale.php',
			'CMessageSource' => '/i18n/CMessageSource.php',
			'CNumberFormatter' => '/i18n/CNumberFormatter.php',
			'CPhpMessageSource' => '/i18n/CPhpMessageSource.php',
			'CGettextFile' => '/i18n/gettext/CGettextFile.php',
			'CGettextMoFile' => '/i18n/gettext/CGettextMoFile.php',
			'CGettextPoFile' => '/i18n/gettext/CGettextPoFile.php',
			'CChainedLogFilter' => '/logging/CChainedLogFilter.php',
			'CDbLogRoute' => '/logging/CDbLogRoute.php',
			'CEmailLogRoute' => '/logging/CEmailLogRoute.php',
			'CFileLogRoute' => '/logging/CFileLogRoute.php',
			'CLogFilter' => '/logging/CLogFilter.php',
			'CLogRoute' => '/logging/CLogRoute.php',
			'CLogRouter' => '/logging/CLogRouter.php',
			'CLogger' => '/logging/CLogger.php',
			'CProfileLogRoute' => '/logging/CProfileLogRoute.php',
			'CWebLogRoute' => '/logging/CWebLogRoute.php',
			'CDateTimeParser' => '/utils/CDateTimeParser.php',
			'CFileHelper' => '/utils/CFileHelper.php',
			'CFormatter' => '/utils/CFormatter.php',
			'CLocalizedFormatter' => '/utils/CLocalizedFormatter.php',
			'CMarkdownParser' => '/utils/CMarkdownParser.php',
			'CPasswordHelper' => '/utils/CPasswordHelper.php',
			'CPropertyValue' => '/utils/CPropertyValue.php',
			'CTimestamp' => '/utils/CTimestamp.php',
			'CVarDumper' => '/utils/CVarDumper.php',
			'CBooleanValidator' => '/validators/CBooleanValidator.php',
			'CCaptchaValidator' => '/validators/CCaptchaValidator.php',
			'CCompareValidator' => '/validators/CCompareValidator.php',
			'CDateValidator' => '/validators/CDateValidator.php',
			'CDefaultValueValidator' => '/validators/CDefaultValueValidator.php',
			'CEmailValidator' => '/validators/CEmailValidator.php',
			'CExistValidator' => '/validators/CExistValidator.php',
			'CFileValidator' => '/validators/CFileValidator.php',
			'CFilterValidator' => '/validators/CFilterValidator.php',
			'CInlineValidator' => '/validators/CInlineValidator.php',
			'CNumberValidator' => '/validators/CNumberValidator.php',
			'CRangeValidator' => '/validators/CRangeValidator.php',
			'CRegularExpressionValidator' => '/validators/CRegularExpressionValidator.php',
			'CRequiredValidator' => '/validators/CRequiredValidator.php',
			'CSafeValidator' => '/validators/CSafeValidator.php',
			'CStringValidator' => '/validators/CStringValidator.php',
			'CTypeValidator' => '/validators/CTypeValidator.php',
			'CUniqueValidator' => '/validators/CUniqueValidator.php',
			'CUnsafeValidator' => '/validators/CUnsafeValidator.php',
			'CUrlValidator' => '/validators/CUrlValidator.php',
			'CValidator' => '/validators/CValidator.php',
			'CActiveDataProvider' => '/web/CActiveDataProvider.php',
			'CArrayDataProvider' => '/web/CArrayDataProvider.php',
			'CAssetManager' => '/web/CAssetManager.php',
			'CBaseController' => '/web/CBaseController.php',
			'CCacheHttpSession' => '/web/CCacheHttpSession.php',
			'CClientScript' => '/web/CClientScript.php',
			'CController' => '/web/CController.php',
			'CDataProvider' => '/web/CDataProvider.php',
			'CDataProviderIterator' => '/web/CDataProviderIterator.php',
			'CDbHttpSession' => '/web/CDbHttpSession.php',
			'CExtController' => '/web/CExtController.php',
			'CFormModel' => '/web/CFormModel.php',
			'CHttpCookie' => '/web/CHttpCookie.php',
			'CHttpRequest' => '/web/CHttpRequest.php',
			'CHttpSession' => '/web/CHttpSession.php',
			'CHttpSessionIterator' => '/web/CHttpSessionIterator.php',
			'COutputEvent' => '/web/COutputEvent.php',
			'CPagination' => '/web/CPagination.php',
			'CSort' => '/web/CSort.php',
			'CSqlDataProvider' => '/web/CSqlDataProvider.php',
			'CTheme' => '/web/CTheme.php',
			'CThemeManager' => '/web/CThemeManager.php',
			'CUploadedFile' => '/web/CUploadedFile.php',
			'CUrlManager' => '/web/CUrlManager.php',
			'CWebApplication' => '/web/CWebApplication.php',
			'CWebModule' => '/web/CWebModule.php',
			'CWidgetFactory' => '/web/CWidgetFactory.php',
			'CAction' => '/web/actions/CAction.php',
			'CInlineAction' => '/web/actions/CInlineAction.php',
			'CViewAction' => '/web/actions/CViewAction.php',
			'CAccessControlFilter' => '/web/auth/CAccessControlFilter.php',
			'CAuthAssignment' => '/web/auth/CAuthAssignment.php',
			'CAuthItem' => '/web/auth/CAuthItem.php',
			'CAuthManager' => '/web/auth/CAuthManager.php',
			'CBaseUserIdentity' => '/web/auth/CBaseUserIdentity.php',
			'CDbAuthManager' => '/web/auth/CDbAuthManager.php',
			'CPhpAuthManager' => '/web/auth/CPhpAuthManager.php',
			'CUserIdentity' => '/web/auth/CUserIdentity.php',
			'CWebUser' => '/web/auth/CWebUser.php',
			'CFilter' => '/web/filters/CFilter.php',
			'CFilterChain' => '/web/filters/CFilterChain.php',
			'CHttpCacheFilter' => '/web/filters/CHttpCacheFilter.php',
			'CInlineFilter' => '/web/filters/CInlineFilter.php',
			'CForm' => '/web/form/CForm.php',
			'CFormButtonElement' => '/web/form/CFormButtonElement.php',
			'CFormElement' => '/web/form/CFormElement.php',
			'CFormElementCollection' => '/web/form/CFormElementCollection.php',
			'CFormInputElement' => '/web/form/CFormInputElement.php',
			'CFormStringElement' => '/web/form/CFormStringElement.php',
			'CGoogleApi' => '/web/helpers/CGoogleApi.php',
			'CHtml' => '/web/helpers/CHtml.php',
			'CJSON' => '/web/helpers/CJSON.php',
			'CJavaScript' => '/web/helpers/CJavaScript.php',
			'CJavaScriptExpression' => '/web/helpers/CJavaScriptExpression.php',
			'CPradoViewRenderer' => '/web/renderers/CPradoViewRenderer.php',
			'CViewRenderer' => '/web/renderers/CViewRenderer.php',
			'CWebService' => '/web/services/CWebService.php',
			'CWebServiceAction' => '/web/services/CWebServiceAction.php',
			'CWsdlGenerator' => '/web/services/CWsdlGenerator.php',
			'CActiveForm' => '/web/widgets/CActiveForm.php',
			'CAutoComplete' => '/web/widgets/CAutoComplete.php',
			'CClipWidget' => '/web/widgets/CClipWidget.php',
			'CContentDecorator' => '/web/widgets/CContentDecorator.php',
			'CFilterWidget' => '/web/widgets/CFilterWidget.php',
			'CFlexWidget' => '/web/widgets/CFlexWidget.php',
			'CHtmlPurifier' => '/web/widgets/CHtmlPurifier.php',
			'CInputWidget' => '/web/widgets/CInputWidget.php',
			'CMarkdown' => '/web/widgets/CMarkdown.php',
			'CMaskedTextField' => '/web/widgets/CMaskedTextField.php',
			'CMultiFileUpload' => '/web/widgets/CMultiFileUpload.php',
			'COutputCache' => '/web/widgets/COutputCache.php',
			'COutputProcessor' => '/web/widgets/COutputProcessor.php',
			'CStarRating' => '/web/widgets/CStarRating.php',
			'CTabView' => '/web/widgets/CTabView.php',
			'CTextHighlighter' => '/web/widgets/CTextHighlighter.php',
			'CTreeView' => '/web/widgets/CTreeView.php',
			'CWidget' => '/web/widgets/CWidget.php',
			'CCaptcha' => '/web/widgets/captcha/CCaptcha.php',
			'CCaptchaAction' => '/web/widgets/captcha/CCaptchaAction.php',
			'CBasePager' => '/web/widgets/pagers/CBasePager.php',
			'CLinkPager' => '/web/widgets/pagers/CLinkPager.php',
			'CListPager' => '/web/widgets/pagers/CListPager.php' 
	);
}

spl_autoload_register ( array (
		'YiiBase',
		'autoload' 
) );
require (YII_PATH . '/base/interfaces.php');