YiiBase

public static function app()
{
    return self::$_app;
}

public static function autoload($className,$classMapOnly=false)
{
    // 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]);
    elseif($classMapOnly)
        return false;
    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 && is_file($path.'.php'))
                include($path.'.php');
            else
                return false;
        }
        return class_exists($className,false) || interface_exists($className,false);
    }
    return true;
}

public static function beginProfile($token,$category='application')
{
    self::log('begin:'.$token,CLogger::LEVEL_PROFILE,$category);
}

public static function createApplication($class,$config=null)
{
    return new $class($config);
}

public static function createComponent($config)
{
    $args = func_get_args();
    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)
    {
        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;
}

public static function createConsoleApplication($config=null)
{
    return self::createApplication('CConsoleApplication',$config);
}

public static function createWebApplication($config=null)
{
    return self::createApplication('CWebApplication',$config);
}

public static function endProfile($token,$category='application')
{
    self::log('end:'.$token,CLogger::LEVEL_PROFILE,$category);
}

public static function getFrameworkPath()
{
    return YII_PATH;
}

public static function getLogger()
{
    if(self::$_logger!==null)
        return self::$_logger;
    else
        return self::$_logger=new CLogger;
}

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

public static function getVersion()
{
    return '1.1.19';
}

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
    {
        // try to autoload the class with an autoloader if $forceInclude is true
        if($forceInclude && (Yii::autoload($alias,true) || class_exists($alias,true)))
            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)));
}

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

public static function powered()
{
    return Yii::t('yii','Powered by {yii}.', array('{yii}'=>'<a href="http://www.yiiframework.com/" rel="external">Yii Framework</a>'));
}

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

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.'));
}

public static function setLogger($logger)
{
    self::$_logger=$logger;
}

public static function setPathOfAlias($alias,$path)
{
    if(empty($path))
        unset(self::$_aliases[$alias]);
    else
        self::$_aliases[$alias]=rtrim($path,'\\/');
}

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

public static function trace($msg,$category='application')
{
    if(YII_DEBUG)
        self::log($msg,CLogger::LEVEL_TRACE,$category);
}