/src/typo3_src-4.2.0alpha1/t3lib/class.t3lib_extmgm.php

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2006 Kasper Skaarhoj (kasperYYYY@typo3.com)
*  All rights reserved
*
*  This script is part of the TYPO3 project. The TYPO3 project is
*  free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  The GNU General Public License can be found at
*  http://www.gnu.org/copyleft/gpl.html.
*  A copy is found in the textfile GPL.txt and important notices to the license
*  from the author is found in LICENSE.txt distributed with these scripts.
*
*
*  This script is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  This copyright notice MUST APPEAR in all copies of the script!
***************************************************************/
class t3lib_extMgm {


        /**************************************
         *
         * PATHS and other evaluation
         *
         ***************************************/

        function isLoaded($key,$exitOnError=0)  {
                global $TYPO3_LOADED_EXT;
                if ($exitOnError && !isset($TYPO3_LOADED_EXT[$key]))    die('Fatal Error: Extension "'.$key.'" was not loaded.');
                return isset($TYPO3_LOADED_EXT[$key]);
        }

        function extPath($key,$script='')       {
                global $TYPO3_LOADED_EXT;
                if (!isset($TYPO3_LOADED_EXT[$key]))    {
                        #debug(array(debug_backtrace()));
                        die('TYPO3 Fatal Error: Extension key "'.$key.'" was NOT loaded! (t3lib_extMgm::extPath)');
                }
                return PATH_site.$TYPO3_LOADED_EXT[$key]['siteRelPath'].$script;
        }

        function extRelPath($key)       {
                global $TYPO3_LOADED_EXT;
                if (!isset($TYPO3_LOADED_EXT[$key]))    {
                        die('TYPO3 Fatal Error: Extension key "'.$key.'" was NOT loaded! (t3lib_extMgm::extRelPath)');
                }
                return $TYPO3_LOADED_EXT[$key]['typo3RelPath'];
        }

        function siteRelPath($key)      {
                return substr(t3lib_extMgm::extPath($key),strlen(PATH_site));
        }

        function getCN($key)    {
                return substr($key,0,5)=='user_' ? 'user_'.str_replace('_','',substr($key,5)) : 'tx_'.str_replace('_','',$key);
        }










        /**************************************
         *
         *       Adding BACKEND features
         *       (related to core features)
         *
         ***************************************/

        function addTCAcolumns($table,$columnArray,$addTofeInterface=0) {
                global $TCA;
                t3lib_div::loadTCA($table);
                if (is_array($columnArray) && is_array($TCA[$table]) && is_array($TCA[$table]['columns']))      {
                        $TCA[$table]['columns'] = array_merge($TCA[$table]['columns'],$columnArray);    // Candidate for t3lib_div::array_merge() if integer-keys will some day make trouble...
                        if ($addTofeInterface)  $TCA[$table]['feInterface']['fe_admin_fieldList'].=','.implode(',',array_keys($columnArray));
                }
        }

        function addToAllTCAtypes($table,$str,$specificTypesList='',$position='')       {
                global $TCA;

                $positionArr=t3lib_div::trimExplode(',',$position,1);
                $insert=count($position);

                t3lib_div::loadTCA($table);
                $str = trim($str);
                if ($str && is_array($TCA[$table]) && is_array($TCA[$table]['types']))  {
                        foreach($TCA[$table]['types'] as $k => $v)      {
                                if (!$specificTypesList || t3lib_div::inList($specificTypesList,$k))    {
                                        if ($insert)    {
                                                if (count($positionArr)) {
                                                        $append=true;
                                                        $showItem = t3lib_div::trimExplode(',',$TCA[$table]['types'][$k]['showitem'],1);
                                                        foreach($showItem as $key => $fieldInfo)        {
        
                                                                $parts = explode(';',$fieldInfo);
                                                                $theField = trim($parts[0]);
                                                                $palette = trim($parts[0]).';;'.trim($parts[2]);
        
                                                                        // insert before: find exact field name or palette with number
                                                                if (in_array($theField, $positionArr) || in_array($palette, $positionArr) || in_array('before:'.$theField, $positionArr) || in_array('before:'.$palette, $positionArr)) {
                                                                        $showItem[$key]=$str.', '.$fieldInfo;
                                                                        $append=false;
                                                                        break;
                                                                }
                                                                        // insert after
                                                                if (in_array('after:'.$theField, $positionArr) || in_array('after:'.$palette, $positionArr))    {
                                                                        $showItem[$key]=$fieldInfo.', '.$str;
                                                                        $append=false;
                                                                        break;
                                                                }
                                                        }
        
                                                                // Not found? Then append.
                                                        if($append) {
                                                                $showItem[]=$str;
                                                        }
        
                                                        $TCA[$table]['types'][$k]['showitem']=implode(', ', $showItem);
                                                }
                                                else {
                                                        $TCA[$table]['types'][$k]['showitem'] .= ', ' . $str;
                                                }

                                        } else {
                                                $TCA[$table]['types'][$k]['showitem'].=', ' . $str;
                                        }
                                }
                        }
                }
        }


        function allowTableOnStandardPages($table)      {
                global $PAGES_TYPES;

                $PAGES_TYPES['default']['allowedTables'].=','.$table;
        }

        function addModule($main,$sub='',$position='',$path='') {
                global $TBE_MODULES;

                if (isset($TBE_MODULES[$main]) && $sub) {       // If there is already a main module by this name:

                                // Adding the submodule to the correct position:
                        list($place,$modRef)=t3lib_div::trimExplode(':',$position,1);
                        $mods = t3lib_div::trimExplode(',',$TBE_MODULES[$main],1);
                        if (!in_array($sub,$mods))      {
                                switch(strtolower($place))      {
                                        case 'after':
                                        case 'before':
                                                $pointer=0;
                                                reset($mods);
                                                while(list($k,$m)=each($mods))  {
                                                        if (!strcmp($m,$modRef))        {
                                                                $pointer=strtolower($place)=='after'?$k+1:$k;
                                                        }
                                                }
                                                array_splice(
                                                        $mods,  // The modules array
                                                        $pointer,               // To insert one position from the end of the list
                                                        0,              // Don't remove any items, just insert
                                                        $sub    // Module to insert
                                                );
                                        break;
                                        default:
                                                if (strtolower($place)=='top')  {
                                                        array_unshift($mods,$sub);
                                                } else {
                                                        array_push($mods,$sub);
                                                }
                                        break;
                                }
                        }
                                // Re-inserting the submodule list:
                        $TBE_MODULES[$main]=implode(',',$mods);
                } else {        // Create new main modules with only one submodule, $sub (or none if $sub is blank)
                        $TBE_MODULES[$main]=$sub;
                }

                        // Adding path:
                if ($path)      {
                        $TBE_MODULES['_PATHS'][$main.($sub?'_'.$sub:'')]=$path;
                }
        }

        function addModulePath($name,$path)     {
                global $TBE_MODULES;

                $TBE_MODULES['_PATHS'][$name] = $path;
        }

        function addTopApp($name,$path,$iconPane=FALSE,$options=array())        {
                global $TBE_MODULES,$TYPO3_CONF_VARS;

                $TYPO3_CONF_VARS['SC_OPTIONS']['GLOBAL']['topApps'][$iconPane?'icons':'menu'][$name] = $options;

                        // Set path for TBE-modules:
                $TBE_MODULES['_PATHS'][$name] = $path;
        }

        function insertModuleFunction($modname,$className,$classPath,$title,$MM_key='function',$WS='')  {
                global $TBE_MODULES_EXT;
                $TBE_MODULES_EXT[$modname]['MOD_MENU'][$MM_key][$className]=array(
                        'name' => $className,
                        'path' => $classPath,
                        'title' => $title,
                        'ws' => $WS
                );
        }

        function addPageTSConfig($content)      {
                global $TYPO3_CONF_VARS;
                $TYPO3_CONF_VARS['BE']['defaultPageTSconfig'].="\n[GLOBAL]\n".$content;
        }

        function addUserTSConfig($content)      {
                global $TYPO3_CONF_VARS;
                $TYPO3_CONF_VARS['BE']['defaultUserTSconfig'].="\n[GLOBAL]\n".$content;
        }

        function addLLrefForTCAdescr($tca_descr_key,$file_ref)  {
                global $TCA_DESCR;
                if ($tca_descr_key)     {
                        if (!is_array($TCA_DESCR[$tca_descr_key]))      {
                                $TCA_DESCR[$tca_descr_key]=array();
                        }
                        if (!is_array($TCA_DESCR[$tca_descr_key]['refs']))      {
                                $TCA_DESCR[$tca_descr_key]['refs']=array();
                        }
                        $TCA_DESCR[$tca_descr_key]['refs'][]=$file_ref;
                }
        }












        /**************************************
         *
         *       Adding SERVICES features
         *
         *   @author    René Fritz <r.fritz@colorcube.de>
         *
         ***************************************/

        function addService($extKey, $serviceType, $serviceKey, $info)  {
                global $T3_SERVICES,$TYPO3_CONF_VARS;

                // even not available services will be included to make it possible to give the admin a feedback of non-available services.
                // but maybe it's better to move non-available services to a different array??

                if ($serviceType &&
                        !t3lib_div::isFirstPartOfStr($serviceType, 'tx_') &&
                        (t3lib_div::isFirstPartOfStr($serviceKey, 'tx_') || t3lib_div::isFirstPartOfStr($serviceKey, 'user_')) &&
                        is_array($info))        {

                        $info['priority'] = max(0,min(100,$info['priority']));

                        $T3_SERVICES[$serviceType][$serviceKey]=$info;

                        $T3_SERVICES[$serviceType][$serviceKey]['extKey'] = $extKey;
                        $T3_SERVICES[$serviceType][$serviceKey]['serviceKey'] = $serviceKey;
                        $T3_SERVICES[$serviceType][$serviceKey]['serviceType'] = $serviceType;


                                // mapping a service key to a service type
                                // all service keys begin with tx_ - service types don't
                                // this way a selection of a special service key as service type is easy
                        $T3_SERVICES[$serviceKey][$serviceKey] = &$T3_SERVICES[$serviceType][$serviceKey];


                                // change the priority (and other values) from TYPO3_CONF_VARS
                                // $TYPO3_CONF_VARS['T3_SERVICES'][$serviceType][$serviceKey]['priority']
                                // even the activation is possible (a unix service might be possible on windows for some reasons)
                        if (is_array($TYPO3_CONF_VARS['T3_SERVICES'][$serviceType][$serviceKey])) {

                                        // no check is done here - there might be configuration values only the service type knows about, so we pass everything
                                $T3_SERVICES[$serviceType][$serviceKey] = array_merge ($T3_SERVICES[$serviceType][$serviceKey],$TYPO3_CONF_VARS['T3_SERVICES'][$serviceType][$serviceKey]);
                        }


                                // OS check
                                // empty $os means 'not limited to one OS', therefore a check is not needed
                        if ($T3_SERVICES[$serviceType][$serviceKey]['available'] && $T3_SERVICES[$serviceType][$serviceKey]['os']!='') {

                                        // TYPO3_OS is not yet defined
                                $os_type = stristr(PHP_OS,'win')&&!stristr(PHP_OS,'darwin')?'WIN':'UNIX';

                                $os = t3lib_div::trimExplode(',',strtoupper($T3_SERVICES[$serviceType][$serviceKey]['os']));

                                if (!in_array($os_type,$os)) {
                                        t3lib_extMgm::deactivateService($serviceType, $serviceKey);
                                }
                        }

                                // convert subtype list to array for quicker access
                        $T3_SERVICES[$serviceType][$serviceKey]['serviceSubTypes'] = array();
                        $serviceSubTypes = t3lib_div::trimExplode(',',$info['subtype']);
                        foreach ($serviceSubTypes as $subtype) {
                                $T3_SERVICES[$serviceType][$serviceKey]['serviceSubTypes'][$subtype] = $subtype;
                        }
                }
        }

        function findService($serviceType, $serviceSubType='', $excludeServiceKeys=array()) {
                global $T3_SERVICES, $T3_VAR, $TYPO3_CONF_VARS;

                $serviceKey = FALSE;
                $serviceInfo = FALSE;
                $priority = 0;
                $quality = 0;

                if (!is_array($excludeServiceKeys) ) {
                        $excludeServiceKeys = t3lib_div::trimExplode(',', $excludeServiceKeys, 1);
                }

                if (is_array($T3_SERVICES[$serviceType]))       {
                        foreach($T3_SERVICES[$serviceType] as $key => $info)    {

                                if (in_array($key, $excludeServiceKeys)) {
                                        continue;
                                }

                                        // select a subtype randomly
                                        // usefull to start a service by service key without knowing his subtypes - for testing purposes
                                if ($serviceSubType=='*') {
                                        $serviceSubType = key($info['serviceSubTypes']);
                                }

                                        // this matches empty subtype too
                                if ($info['available'] && ($info['subtype']==$serviceSubType || $info['serviceSubTypes'][$serviceSubType]) && $info['priority']>=$priority )    {

                                                // has a lower quality than the already found, therefore we skip this service
                                        if($info['priority']==$priority && $info['quality']<$quality) {
                                                continue;
                                        }

                                                // service depends on external programs - check if they exists
                                        if(trim($info['exec'])) {
                                                require_once(PATH_t3lib.'class.t3lib_exec.php');

                                                $executables = t3lib_div::trimExplode(',', $info['exec'],1);
                                                foreach($executables as $executable)    {
                                                        if(!t3lib_exec::checkCommand($executable)) {
                                                                t3lib_extMgm::deactivateService($serviceType, $key);
                                                                $info['available']=FALSE;
                                                                break;
                                                        }
                                                }
                                        }

                                                // still available after exec check?
                                        if($info['available']) {
                                                $serviceKey = $key;
                                                $priority = $info['priority'];
                                                $quality = $info['quality'];
                                        }
                                }
                        }
                }

                if ($serviceKey) {
                        $serviceInfo = $T3_SERVICES[$serviceType][$serviceKey];
                }
                return $serviceInfo;
        }

        function deactivateService($serviceType, $serviceKey) {
                global $T3_SERVICES;

                        // ... maybe it's better to move non-available services to a different array??
                $T3_SERVICES[$serviceType][$serviceKey]['available'] = FALSE;
        }














        /**************************************
         *
         *       Adding FRONTEND features
         *       (related specifically to "cms" extension)
         *
         ***************************************/

        function addPlugin($itemArray,$type='list_type')        {
                global $TCA;
                t3lib_div::loadTCA('tt_content');
                if (is_array($TCA['tt_content']['columns']) && is_array($TCA['tt_content']['columns'][$type]['config']['items']))       {
                        reset($TCA['tt_content']['columns'][$type]['config']['items']);
                        while(list($k,$v)=each($TCA['tt_content']['columns'][$type]['config']['items']))        {
                                if (!strcmp($v[1],$itemArray[1]))       {
                                        $TCA['tt_content']['columns'][$type]['config']['items'][$k]=$itemArray;
                                        return;
                                }
                        }
                        $TCA['tt_content']['columns'][$type]['config']['items'][]=$itemArray;
                }
        }

        function addPiFlexFormValue($piKeyToMatch,$value)       {
                global $TCA;
                t3lib_div::loadTCA('tt_content');

                if (is_array($TCA['tt_content']['columns']) && is_array($TCA['tt_content']['columns']['pi_flexform']['config']['ds']))  {
                        $TCA['tt_content']['columns']['pi_flexform']['config']['ds'][$piKeyToMatch] = $value;
                }
        }

        function addToInsertRecords($table,$content_table='tt_content',$content_field='records')        {
                global $TCA;
                t3lib_div::loadTCA($content_table);
                if (is_array($TCA[$content_table]['columns']) && isset($TCA[$content_table]['columns'][$content_field]['config']['allowed']))   {
                        $TCA[$content_table]['columns'][$content_field]['config']['allowed'].=','.$table;
                }
        }

        function addPItoST43($key,$classFile='',$prefix='',$type='list_type',$cached=0) {
                global $TYPO3_LOADED_EXT;
                $classFile = $classFile ? $classFile : 'pi/class.tx_'.str_replace('_','',$key).$prefix.'.php';
                $cN = t3lib_extMgm::getCN($key);

                        // General plugin:
                if ($cached)    {
                        $pluginContent = trim('
includeLibs.'.$cN.$prefix.' = '.$TYPO3_LOADED_EXT[$key]['siteRelPath'].$classFile.'
plugin.'.$cN.$prefix.' = USER
plugin.'.$cN.$prefix.' {
  userFunc = '.$cN.$prefix.'->main
}');
                } else {
                        $pluginContent = trim('
plugin.'.$cN.$prefix.' = USER_INT
plugin.'.$cN.$prefix.' {
  includeLibs = '.$TYPO3_LOADED_EXT[$key]['siteRelPath'].$classFile.'
  userFunc = '.$cN.$prefix.'->main
}');
                }
                t3lib_extMgm::addTypoScript($key,'setup','
# Setting '.$key.' plugin TypoScript
'.$pluginContent);

                        // After ST43:
                switch($type)   {
                        case 'list_type':
                                $addLine = 'tt_content.list.20.'.$key.$prefix.' = < plugin.'.$cN.$prefix;
                        break;
                        case 'menu_type':
                                $addLine = 'tt_content.menu.20.'.$key.$prefix.' = < plugin.'.$cN.$prefix;
                        break;
                        case 'splash_layout':
                                $addLine = 'tt_content.splash.'.$key.$prefix.' = < plugin.'.$cN.$prefix;
                        break;
                        case 'CType':
                                $addLine = trim('
tt_content.'.$key.$prefix.' = COA
tt_content.'.$key.$prefix.' {
        10 = < lib.stdheader
        20 = < plugin.'.$cN.$prefix.'
}
                                ');
                        break;
                        case 'header_layout':
                                $addLine = 'lib.stdheader.10.'.$key.$prefix.' = < plugin.'.$cN.$prefix;
                        break;
                        case 'includeLib':
                                $addLine = 'page.1000 = < plugin.'.$cN.$prefix;
                        break;
                        default:
                                $addLine = '';
                        break;
                }
                if ($addLine)   {
                        t3lib_extMgm::addTypoScript($key,'setup','
# Setting '.$key.' plugin TypoScript
'.$addLine.'
',43);
                }
        }

        function addStaticFile($extKey,$path,$title)    {
                global $TCA;
                t3lib_div::loadTCA('sys_template');
                if ($extKey && $path && is_array($TCA['sys_template']['columns']))      {
                        $value = str_replace(',','','EXT:'.$extKey.'/'.$path);
                        $itemArray=array(trim($title.' ('.$extKey.')'),$value);
                        $TCA['sys_template']['columns']['include_static_file']['config']['items'][]=$itemArray;
                }
        }

        function addTypoScriptSetup($content)   {
                global $TYPO3_CONF_VARS;
                $TYPO3_CONF_VARS['FE']['defaultTypoScript_setup'].="\n[GLOBAL]\n".$content;
        }

        function addTypoScriptConstants($content)       {
                global $TYPO3_CONF_VARS;
                $TYPO3_CONF_VARS['FE']['defaultTypoScript_constants'].="\n[GLOBAL]\n".$content;
        }

        function addTypoScript($key,$type,$content,$afterStaticUid=0)   {
                global $TYPO3_CONF_VARS;

                if ($type=='setup' || $type=='editorcfg' || $type=='constants')         {
                        $content = '

[GLOBAL]
#############################################
## TypoScript added by extension "'.$key.'"
#############################################

'.$content;
                        if ($afterStaticUid)    {
                                $TYPO3_CONF_VARS['FE']['defaultTypoScript_'.$type.'.'][$afterStaticUid].=$content;
                                if ($afterStaticUid==43)        {       // If 'content (default)' is targeted, also add to other 'content rendering templates', eg. css_styled_content
                                        $TYPO3_CONF_VARS['FE']['defaultTypoScript_'.$type.'.']['cssstyledcontent/static/'].=$content;
                                }
                        } else {
                                $TYPO3_CONF_VARS['FE']['defaultTypoScript_'.$type].=$content;
                        }
                }
        }


















        /**************************************
         *
         *       INTERNAL EXTENSION MANAGEMENT:
         *
         ***************************************/

        function typo3_loadExtensions() {
                global $TYPO3_CONF_VARS;

                        // Full list of extensions includes both required and extList:
                $rawExtList = $TYPO3_CONF_VARS['EXT']['requiredExt'].','.$TYPO3_CONF_VARS['EXT']['extList'];

                        // Empty array as a start.
                $extensions = array();

                        //
                if ($rawExtList)        {
                                // The cached File prefix.
                        $cacheFilePrefix = 'temp_CACHED';
                                // Setting the name for the cache files:
                        if (intval($TYPO3_CONF_VARS['EXT']['extCache'])==1)     $cacheFilePrefix.= '_ps'.substr(t3lib_div::shortMD5(PATH_site.'|'.$GLOBALS['TYPO_VERSION']),0,4);
                        if (intval($TYPO3_CONF_VARS['EXT']['extCache'])==2)     $cacheFilePrefix.= '_'.t3lib_div::shortMD5($rawExtList);

                                // If cache files available, set cache file prefix and return:
                        if ($TYPO3_CONF_VARS['EXT']['extCache'] && t3lib_extMgm::isCacheFilesAvailable($cacheFilePrefix))       {
                                        // Return cache file prefix:
                                $extensions['_CACHEFILE'] = $cacheFilePrefix;
                        } else {        // ... but if not, configure...

                                        // Prepare reserved filenames:
                                $files = t3lib_div::trimExplode(',','ext_localconf.php,ext_tables.php,ext_tables.sql,ext_tables_static+adt.sql,ext_typoscript_constants.txt,ext_typoscript_editorcfg.txt,ext_typoscript_setup.txt',1);

                                        // Traverse extensions and check their existence:
                                clearstatcache();       // Clear file state cache to make sure we get good results from is_dir()
                                $temp_extensions = array_unique(t3lib_div::trimExplode(',',$rawExtList,1));
                                foreach($temp_extensions as $temp_extKey)       {
                                                // Check local, global and system locations:
                                        if (@is_dir(PATH_typo3conf.'ext/'.$temp_extKey.'/'))    {
                                                $extensions[$temp_extKey] = array('type'=>'L', 'siteRelPath'=>'typo3conf/ext/'.$temp_extKey.'/', 'typo3RelPath'=>'../typo3conf/ext/'.$temp_extKey.'/');
                                        } elseif (@is_dir(PATH_typo3.'ext/'.$temp_extKey.'/'))  {
                                                $extensions[$temp_extKey] = array('type'=>'G', 'siteRelPath'=>TYPO3_mainDir.'ext/'.$temp_extKey.'/', 'typo3RelPath'=>'ext/'.$temp_extKey.'/');
                                        } elseif (@is_dir(PATH_typo3.'sysext/'.$temp_extKey.'/'))       {
                                                $extensions[$temp_extKey] = array('type'=>'S', 'siteRelPath'=>TYPO3_mainDir.'sysext/'.$temp_extKey.'/', 'typo3RelPath'=>'sysext/'.$temp_extKey.'/');
                                        }

                                                // If extension was found, check for reserved filenames:
                                        if (isset($extensions[$temp_extKey]))   {
                                                foreach($files as $fName)       {
                                                        $temp_filename = PATH_site.$extensions[$temp_extKey]['siteRelPath'].trim($fName);
                                                        if (is_array($extensions[$temp_extKey]) && @is_file($temp_filename))    {
                                                                $extensions[$temp_extKey][$fName] = $temp_filename;
                                                        }
                                                }
                                        }
                                }
                                unset($extensions['_CACHEFILE']);

                                        // write cache?
                                if ($TYPO3_CONF_VARS['EXT']['extCache'] &&
                                                @is_dir(PATH_typo3.'sysext/') &&
                                                @is_dir(PATH_typo3.'ext/'))     {       // Must also find global and system extension directories to exist, otherwise caching cannot be allowed (since it is most likely a temporary server problem). This might fix a rare, unrepeatable bug where global/system extensions are not loaded resulting in fatal errors if that is cached!
                                        $wrError = t3lib_extMgm::cannotCacheFilesWritable($cacheFilePrefix);
                                        if ($wrError)   {
                                                $TYPO3_CONF_VARS['EXT']['extCache']=0;
                                        } else {
                                                        // Write cache files:
                                                $extensions = t3lib_extMgm::writeCacheFiles($extensions,$cacheFilePrefix);
                                        }
                                }
                        }
                }

                return $extensions;
        }

        function _makeIncludeHeader($key,$file) {
                return '<?php
###########################
## EXTENSION: '.$key.'
## FILE:      '.$file.'
###########################

$_EXTKEY = \''.$key.'\';
$_EXTCONF = $TYPO3_CONF_VARS[\'EXT\'][\'extConf\'][$_EXTKEY];

?>';
        }

        function isCacheFilesAvailable($cacheFilePrefix)        {
                return
                        @is_file(PATH_typo3conf.$cacheFilePrefix.'_ext_localconf.php') &&
                        @is_file(PATH_typo3conf.$cacheFilePrefix.'_ext_tables.php');
        }

        function isLocalconfWritable()  {
                return @is_writable(PATH_typo3conf) && @is_writable(PATH_typo3conf.'localconf.php');
        }

        function cannotCacheFilesWritable($cacheFilePrefix)     {
                $error=array();
                if (!@is_writable(PATH_typo3conf))      {
                        $error[]=PATH_typo3conf;
                }
                if (@is_file(PATH_typo3conf.$cacheFilePrefix.'_ext_localconf.php') &&
                        !@is_writable(PATH_typo3conf.$cacheFilePrefix.'_ext_localconf.php'))    {
                                $error[]=PATH_typo3conf.$cacheFilePrefix.'_ext_localconf.php';
                }
                if (@is_file(PATH_typo3conf.$cacheFilePrefix.'_ext_tables.php') &&
                        !@is_writable(PATH_typo3conf.$cacheFilePrefix.'_ext_tables.php'))       {
                                $error[]=PATH_typo3conf.$cacheFilePrefix.'_ext_tables.php';
                }
                return implode(', ',$error);
        }

        function currentCacheFiles()    {
                global $TYPO3_LOADED_EXT;

                if ($TYPO3_LOADED_EXT['_CACHEFILE'])    {
                        if (t3lib_extMgm::isCacheFilesAvailable($TYPO3_LOADED_EXT['_CACHEFILE']))       {
                                return array(
                                        PATH_typo3conf.$TYPO3_LOADED_EXT['_CACHEFILE'].'_ext_localconf.php',
                                        PATH_typo3conf.$TYPO3_LOADED_EXT['_CACHEFILE'].'_ext_tables.php'
                                );
                        }
                }
        }

        function writeCacheFiles($extensions,$cacheFilePrefix)  {
                        // Making cache files:
                $extensions['_CACHEFILE'] = $cacheFilePrefix;
                $cFiles=array();
                $cFiles['ext_localconf'].='<?php

$TYPO3_LOADED_EXT = unserialize(stripslashes(\''.addslashes(serialize($extensions)).'\'));

?>';

                reset($extensions);
                while(list($key,$conf)=each($extensions))       {
                        if (is_array($conf))    {
                                if ($conf['ext_localconf.php']) {
                                        $cFiles['ext_localconf'].=t3lib_extMgm::_makeIncludeHeader($key,$conf['ext_localconf.php']);
                                        $cFiles['ext_localconf'].=trim(t3lib_div::getUrl($conf['ext_localconf.php']));
                                }
                                if ($conf['ext_tables.php'])    {
                                        $cFiles['ext_tables'].=t3lib_extMgm::_makeIncludeHeader($key,$conf['ext_tables.php']);
                                        $cFiles['ext_tables'].=trim(t3lib_div::getUrl($conf['ext_tables.php']));
                                }
                        }
                }

                t3lib_div::writeFile(PATH_typo3conf.$cacheFilePrefix.'_ext_localconf.php',$cFiles['ext_localconf']);
                t3lib_div::writeFile(PATH_typo3conf.$cacheFilePrefix.'_ext_tables.php',$cFiles['ext_tables']);

                $extensions=array();
                $extensions['_CACHEFILE'] = $cacheFilePrefix;

                return $extensions;
        }

        function removeCacheFiles()     {
                $cacheFiles = t3lib_extMgm::currentCacheFiles();
                $out = 0;
                if (is_array($cacheFiles))      {
                        reset($cacheFiles);
                        foreach($cacheFiles as $cfile)  {
                                @unlink($cfile);
                                clearstatcache();
                                $out++;
                        }
                }
                return $out;
        }
}

?>

---

This documentation has been generated automatically from TYPO3 source code using Doxygen and is provided as is by Cast Iron Coding as a courtesy to other TYPO3 developers and users. Please consider Cast Iron Coding — a full-service web development agency in Portland, Oregon specializing in TYPO3 extension development — for all of your TYPO3 development and consulting needs!