lang.php

Go to the documentation of this file.

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2004 Kasper Skaarhoj (kasperYYYY@typo3.com)
*  All rights reserved
*
*  This script is part of the TYPO3 project. TYPO3 is free software;
*  You can redistribute it and/or modify it under the terms of the
*  TYPO3 License as published from the www.typo3.com website.
*
*  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.
*
*  This copyright notice MUST APPEAR in all copies of this script
***************************************************************/
class language {
   var $lang='default';    // This is set to the language that is currently running for the user
   var $langSplit='default';  // Values like the labels in the tables.php-document are split by '|'. This values defines which language is represented by which position in the resulting array after splitting a value. (NOTICE: Obsolete concept!)

      // Default charset in backend
   var $charSet = 'iso-8859-1';

      // Array with alternative charsets for other languages. (Moved to t3lib_cs, Set from csConvObj!)
   var $charSetArray = array();

      // This is the url to the TYPO3 manual
   var $typo3_help_url= 'http://www.typo3.com/man_uk/';
      // Array with alternative URLs based on language.
   var $helpUrlArray = array(
      'dk' => 'http://www.typo3.com/man_dk/',
   );


   var $moduleLabels = Array();  // Can contain labels and image references from the backend modules. Relies on t3lib_loadmodules to initialize modules after a global instance of $LANG has been created.

      // Internal
   var $langSplitIndex=0;        // Points to the position of the current language key as found in constant TYPO3_languages
   var $LL_files_cache=array();  // Internal cache for read LL-files
   var $LL_labels_cache=array(); // Internal cache for ll-labels (filled as labels are requested)

      // Internal charset conversion:
   var $origCharSet='';    // If set, then it means that the this->charSet is set to a forced, common value for the WHOLE backend regardless of user language. And THIS variable will contain the original charset for the language labels. With ->csConvObj we must then convert the original charset to the charset used in the backend from now on.
   var $csConvObj;            // An instance of the "t3lib_cs" class. May be used by any application.








   function init($lang,$altPath='') {

         // Initialize the conversion object:
      $this->csConvObj = t3lib_div::makeInstance('t3lib_cs');
      $this->charSetArray = $this->csConvObj->charSetArray;

         // Internally setting the list of TYPO3 backend languages.
      $this->langSplit=TYPO3_languages;

         // Finding the requested language in this list based on the $lang key being inputted to this function.
      $ls = explode('|',$this->langSplit);
      while(list($i,$v)=each($ls))  {
         if ($v==$lang) {  // Language is found. Configure it:
            $this->langSplitIndex=$i;     // The index of the language as found in the TYPO3_languages list
            $this->lang = $lang;       // The current language key
            if ($this->helpUrlArray[$this->lang])  $this->typo3_help_url=$this->helpUrlArray[$this->lang];  // The help URL if different from the default.
            if ($this->charSetArray[$this->lang])  $this->charSet=$this->charSetArray[$this->lang];      // The charset if different from the default.
         }
      }

         // If a forced charset is used and different from the charset otherwise used:
      if ($GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset'] && $GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset']!=$this->charSet)   {
            // Set the forced charset:
         $this->origCharSet = $this->charSet;
         $this->charSet = $GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset'];

         if ($this->charSet!='utf-8' && !$this->csConvObj->initCharset($this->charSet))      {
            t3lib_BEfunc::typo3PrintError ('The forced character set "'.$this->charSet.'" was not found in t3lib/csconvtbl/','Forced charset not found');
            exit;
         }
         if ($this->origCharSet!='utf-8' && !$this->csConvObj->initCharset($this->origCharSet))    {
            t3lib_BEfunc::typo3PrintError ('The original character set "'.$this->origCharSet.'" was not found in t3lib/csconvtbl/','Forced charset not found');
            exit;
         }
      }
   }

   function addModuleLabels($arr,$prefix) {
      if (is_array($arr))  {
         reset($arr);
         while(list($k,$larr)=each($arr)) {
            if (!isset($this->moduleLabels[$k]))   {
               $this->moduleLabels[$k]=array();
            }
            if (is_array($larr)) {
               reset($larr);
               while(list($l,$v)=each($larr))   {
                  $this->moduleLabels[$k][$prefix.$l]=$v;
               }
            }
         }
      }
   }

   function hscAndCharConv($lStr,$hsc) {
      $lStr = $hsc ? htmlspecialchars($lStr) : $lStr;
      if ($this->origCharSet) {
         $lStr = $this->csConvObj->conv($lStr,$this->origCharSet,$this->charSet,1);
      }
      return $lStr;
   }

   function makeEntities($str)   {
         // Convert string to UTF-8:
      if ($this->charSet!='utf-8')  $str = $this->csConvObj->utf8_encode($str,$this->charSet);

         // Convert string back again, but using the full entity conversion:
      $str = $this->csConvObj->utf8_to_entities($str);
      return $str;
   }

   function JScharCode($str)  {

         // Convert string to UTF-8:
      if ($this->charSet!='utf-8')  $str = $this->csConvObj->utf8_encode($str,$this->charSet);

         // Convert the UTF-8 string into a array of char numbers:
      $nArr = $this->csConvObj->utf8_to_numberarray($str);

      return 'String.fromCharCode('.implode(',',$nArr).')';
   }

   function getLL($index,$hsc=0) {
      // Get Local Language
      if (strcmp($GLOBALS['LOCAL_LANG'][$this->lang][$index],'')) {
         return $this->hscAndCharConv($GLOBALS['LOCAL_LANG'][$this->lang][$index], $hsc); // Returns local label if not blank.
      } else {
         return $this->hscAndCharConv($GLOBALS['LOCAL_LANG']['default'][$index], $hsc);   // Returns default label
      }
   }

   function getLLL($index,$LOCAL_LANG,$hsc=0)   {
      // Get Local Language
      if (strcmp($LOCAL_LANG[$this->lang][$index],''))   {
         return $this->hscAndCharConv($LOCAL_LANG[$this->lang][$index], $hsc);   // Returns local label if not blank.
      } else {
         return $this->hscAndCharConv($LOCAL_LANG['default'][$index], $hsc);     // Returns default label
      }
   }

   function sL($input,$hsc=0) {
      if (strcmp(substr($input,0,4),'LLL:')) {  // Using obsolete 'language-splitted' labels:
         $t = explode('|',$input);
         $out = $t[$this->langSplitIndex] ? $t[$this->langSplitIndex] : $t[0];
         return $this->hscAndCharConv($out, $hsc);
      } else { // LOCAL_LANG:
         if (!isset($this->LL_labels_cache[$this->lang][$input])) {  // If cached label
            $restStr = trim(substr($input,4));
            $extPrfx='';
            if (!strcmp(substr($restStr,0,4),'EXT:')) {  // ll-file refered to is found in an extension.
               $restStr = trim(substr($restStr,4));
               $extPrfx='EXT:';
            }
            $parts = explode(':',$restStr);
            $parts[0]=$extPrfx.$parts[0];
            if (!isset($this->LL_files_cache[$parts[0]]))   {  // Getting data if not cached
               $this->LL_files_cache[$parts[0]] = $this->readLLfile($parts[0]);

                  // If the current language is found in another file, load that as well:
               $lFileRef = $this->localizedFileRef($parts[0]);
               if ($lFileRef && is_string($this->LL_files_cache[$parts[0]][$this->lang]) && $this->LL_files_cache[$parts[0]][$this->lang]=='EXT')  {
                  $tempLL = $this->readLLfile($lFileRef);
                  $this->LL_files_cache[$parts[0]][$this->lang] = $tempLL[$this->lang];
               }

                  // Overriding file?
               if (isset($GLOBALS['TYPO3_CONF_VARS']['BE']['XLLfile'][$parts[0]]))  {
                  $ORarray = $this->readLLfile($GLOBALS['TYPO3_CONF_VARS']['BE']['XLLfile'][$parts[0]]);
                  $this->LL_files_cache[$parts[0]] = t3lib_div::array_merge_recursive_overrule($this->LL_files_cache[$parts[0]],$ORarray);
               }
            }
            $this->LL_labels_cache[$this->lang][$input] = $this->getLLL($parts[1],$this->LL_files_cache[$parts[0]]);
         }
         return $hsc ? t3lib_div::deHSCentities(htmlspecialchars($this->LL_labels_cache[$this->lang][$input])) : $this->LL_labels_cache[$this->lang][$input]; // For the cached output charset conversion has already happend! So perform HSC right here.
      }
   }

   function loadSingleTableDescription($table)  {
      global $TCA_DESCR;

      if (is_array($TCA_DESCR[$table])
            && !isset($TCA_DESCR[$table]['columns'])
            && is_array($TCA_DESCR[$table]['refs']))   { // First the 'table' cannot already be loaded in [columns] and secondly there must be a references to locallang files available in [refs]

            // Init $TCA_DESCR for $table-key
         $TCA_DESCR[$table]['columns']=array();

            // Get local-lang for each file in $TCA_DESCR[$table]['refs'] as they are ordered.
         foreach ($TCA_DESCR[$table]['refs'] as $llfile) {
            $LOCAL_LANG = $this->includeLLFile($llfile,0,1);

               // Traverse all keys
            if (is_array($LOCAL_LANG['default']))  {
               foreach($LOCAL_LANG['default'] as $lkey => $lVal)  {

                     // exploding by '.':
                     // 0 => fieldname,
                     // 1 => type from (alttitle,description,details,syntax,image_descr,image,seeAlso),
                     // 2 => special instruction, see switch construct
                  $kParts = explode('.',$lkey);

                     // Detecting 'hidden' labels, converting to normal fieldname
                  if ($kParts[0]=='_') $kParts[0]='';
                  if (substr($kParts[0],0,1)=='_') { $kParts[0] = substr($kParts[0],1); }

                     // Add label:
                  switch((string)$kParts[2]) {
                     case '+':   // adding
                        $TCA_DESCR[$table]['columns'][$kParts[0]][$kParts[1]].= chr(10).$lVal;
                     break;
                     default: // Substituting:
                        $TCA_DESCR[$table]['columns'][$kParts[0]][$kParts[1]] = $lVal;
                     break;
                  }
               }
            }
         }
      }
   }

   function includeLLFile($fileRef,$setGlobal=1,$mergeLocalOntoDefault=0)  {
         // Configure for global flag:
      if ($setGlobal)   {
         global $LOCAL_LANG;
      }

         // Get default file:
      $llang = $this->readLLfile($fileRef);

      if (count($llang))   {

         $LOCAL_LANG = t3lib_div::array_merge_recursive_overrule($LOCAL_LANG,$llang);

            // Localized addition?
         $lFileRef = $this->localizedFileRef($fileRef);
         if ($lFileRef && (string)$LOCAL_LANG[$this->lang]=='EXT')   {
            $llang = $this->readLLfile($lFileRef);
            $LOCAL_LANG = t3lib_div::array_merge_recursive_overrule($LOCAL_LANG,$llang);
         }

            // Overriding file?
         if (isset($GLOBALS['TYPO3_CONF_VARS']['BE']['XLLfile'][$fileRef]))   {
            $ORarray = $this->readLLfile($GLOBALS['TYPO3_CONF_VARS']['BE']['XLLfile'][$fileRef]);
            $LOCAL_LANG = t3lib_div::array_merge_recursive_overrule($LOCAL_LANG,$ORarray);
         }

            // Merge local onto default:
         if ($mergeLocalOntoDefault && strcmp($this->lang,'default') && is_array($LOCAL_LANG[$this->lang]) && is_array($LOCAL_LANG['default'])) {
            $LOCAL_LANG['default'] = array_merge($LOCAL_LANG['default'],$LOCAL_LANG[$this->lang]); // array_merge can be used so far the keys are not numeric - which we assume they are not...
            unset($LOCAL_LANG[$this->lang]);
         }
      }

         // Return value if not global is set.
      if (!$setGlobal)  {
         return $LOCAL_LANG;
      }
   }

   function readLLfile($fileRef) {
      $file = t3lib_div::getFileAbsFileName($fileRef);
      if ($file)  {
         $baseFile = ereg_replace('\.(php|xml)$', '', $file);

         if (@is_file($baseFile.'.xml'))  {
            $LOCAL_LANG = $this->readLLXMLfile($baseFile.'.xml', $this->lang);
         } elseif (@is_file($baseFile.'.php'))  {
            include($baseFile.'.php');
         } else die('Filereference, "'.$file.'", not found!');
      }
      return is_array($LOCAL_LANG)?$LOCAL_LANG:array();
   }

   function readLLXMLfile($fileRef,$langKey) {

      if (@is_file($fileRef) && $langKey) {

            // Set charset:
         $origCharset = $this->csConvObj->parse_charset($this->csConvObj->charSetArray[$langKey] ? $this->csConvObj->charSetArray[$langKey] : 'iso-8859-1');

            // Cache file name:
         $hashSource = substr($fileRef,strlen(PATH_site)).'|'.date('d-m-Y H:i:s',filemtime($fileRef));
         $cacheFileName = PATH_site.'typo3temp/llxml/'.
                     #str_replace('_','',ereg_replace('^.*\/','',dirname($fileRef))).
                     #'_'.basename($fileRef).
                     substr(basename($fileRef),10,15).
                     '_'.t3lib_div::shortMD5($hashSource).'.'.$langKey.'.'.$origCharset.'.cache';

            // Check if cache file exists...
         if (!@is_file($cacheFileName))   {  // ... if it doesn't, create content and write it:

               // Read XML, parse it.
            $xmlString = t3lib_div::getUrl($fileRef);
            $xmlContent = t3lib_div::xml2array($xmlString);

               // Set default LOCAL_LANG array content:
            $LOCAL_LANG = array();
            $LOCAL_LANG['default'] = $xmlContent['data']['default'];

               // Specific language, convert from utf-8 to backend language charset:
               // NOTICE: Converting from utf-8 back to "native" language may be a temporary solution until we can totally discard "locallang.php" files altogether (and use utf-8 for everything). But doing this conversion is the quickest way to migrate now and the source is in utf-8 anyway which is the main point.
            if ($langKey!='default')   {
               $LOCAL_LANG[$langKey] = $xmlContent['data'][$langKey];

                  // Checking if charset should be converted.
               if (is_array($LOCAL_LANG[$langKey]) && $origCharset!='utf-8')  {
                  foreach($LOCAL_LANG[$langKey] as $labelKey => $labelValue)  {
                     $LOCAL_LANG[$langKey][$labelKey] = $this->csConvObj->utf8_decode($labelValue,$origCharset);
                  }
               }
            }

               // Cache the content now:
            $serContent = array('origFile'=>$hashSource, 'LOCAL_LANG'=>$LOCAL_LANG);
            $res = t3lib_div::writeFileToTypo3tempDir($cacheFileName, serialize($serContent));
            if ($res)   die('ERROR: '.$res);
         } else {
               // Get content from cache:
            $serContent = unserialize(t3lib_div::getUrl($cacheFileName));
            $LOCAL_LANG = $serContent['LOCAL_LANG'];
         }

            // Checking for EXTERNAL file for non-default language:
         if ($langKey!='default' && is_string($LOCAL_LANG[$langKey]) && strlen($LOCAL_LANG[$langKey]))   {

               // Look for localized file:
            $localized_file = t3lib_div::getFileAbsFileName($LOCAL_LANG[$langKey]);
            if ($localized_file && @is_file($localized_file))  {

                  // Cache file name:
               $hashSource = substr($localized_file,strlen(PATH_site)).'|'.date('d-m-Y H:i:s',filemtime($localized_file));
               $cacheFileName = PATH_site.'typo3temp/llxml/ext_'.
                           substr(basename($localized_file),10,15).
                           '_'.t3lib_div::shortMD5($hashSource).'.'.$langKey.'.'.$origCharset.'.cache';

                  // Check if cache file exists...
               if (!@is_file($cacheFileName))   {  // ... if it doesn't, create content and write it:

                     // Read and parse XML content:
                  $local_xmlString = t3lib_div::getUrl($localized_file);
                  $local_xmlContent = t3lib_div::xml2array($local_xmlString);
                  $LOCAL_LANG[$langKey] = is_array($local_xmlContent['data'][$langKey]) ? $local_xmlContent['data'][$langKey] : array();

                     // Checking if charset should be converted.
                  if (is_array($LOCAL_LANG[$langKey]) && $origCharset!='utf-8')  {
                     foreach($LOCAL_LANG[$langKey] as $labelKey => $labelValue)  {
                        $LOCAL_LANG[$langKey][$labelKey] = $this->csConvObj->utf8_decode($labelValue,$origCharset);
                     }
                  }

                     // Cache the content now:
                  $serContent = array('extlang'=>$langKey, 'origFile'=>$LOCAL_LANG[$langKey], 'EXT_DATA'=>$LOCAL_LANG[$langKey]);
                  $res = t3lib_div::writeFileToTypo3tempDir($cacheFileName, serialize($serContent));
                  if ($res)   die('ERROR: '.$res);
               } else {
                     // Get content from cache:
                  $serContent = unserialize(t3lib_div::getUrl($cacheFileName));
                  $LOCAL_LANG[$langKey] = $serContent['EXT_DATA'];
               }
            }
         }

         return $LOCAL_LANG;
      }
   }

   function localizedFileRef($fileRef) {
      if ($this->lang!='default' && substr($fileRef,-4)=='.php')  {
         return substr($fileRef,0,-4).'.'.$this->lang.'.php';
      }
   }
}

// Include extension to the template class?
if (defined('TYPO3_MODE') && $TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['ext/lang/lang.php']) {
   include_once($TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['ext/lang/lang.php']);
}
?>

---