Documentation TYPO3 par Ameos

Disponible dans d'autres versions de TYPO3 -> 3.7.0  3.8.1  4.0.0  4.0.1  4.1.0   <- Available in other TYPO3 versions

class.t3lib_div.php

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2004 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_div {





        /*************************
         *
         * GET/POST Variables
         *
         * Background:
         * Input GET/POST variables in PHP may have their quotes escaped with "\" or not depending on configuration.
         * TYPO3 has always converted quotes to BE escaped if the configuration told that they would not be so.
         * But the clean solution is that quotes are never escaped and that is what the functions below offers.
         * Eventually TYPO3 should provide this in the global space as well.
         * In the transitional phase (or forever..?) we need to encourage EVERY to read and write GET/POST vars through the API functions below.
         *
         *************************/

        function _GP($var)      {
                if(empty($var)) return;
                $value = isset($_POST[$var]) ? $_POST[$var] : $_GET[$var];
                if (isset($value))      {
                        if (is_array($value))   { t3lib_div::stripSlashesOnArray($value); } else { $value = stripslashes($value); }
                }
                return $value;
        }

        function _GET($var=NULL)        {
                $value = ($var === NULL) ? $_GET : (empty($var) ? NULL : $_GET[$var]);
                if (isset($value))      {       // Removes slashes since TYPO3 has added them regardless of magic_quotes setting.
                        if (is_array($value))   { t3lib_div::stripSlashesOnArray($value); } else { $value = stripslashes($value); }
                }
                return $value;
        }

        function _POST($var=NULL)       {
                $value = ($var === NULL) ? $_POST : (empty($var) ? NULL : $_POST[$var]);
                if (isset($value))      {       // Removes slashes since TYPO3 has added them regardless of magic_quotes setting.
                        if (is_array($value))   { t3lib_div::stripSlashesOnArray($value); } else { $value = stripslashes($value); }
                }
                return $value;
        }

        function _GETset($inputGet,$key='')     {
                        // ADDS slashes since TYPO3 standard currently is that slashes MUST be applied (regardless of magic_quotes setting).
                if (strcmp($key,''))    {
                        if (is_array($inputGet))        { t3lib_div::addSlashesOnArray($inputGet); } else { $inputGet = addslashes($inputGet); }
                        $GLOBALS['HTTP_GET_VARS'][$key] = $_GET[$key] = $inputGet;
                } elseif (is_array($inputGet)){
                        t3lib_div::addSlashesOnArray($inputGet);
                        $GLOBALS['HTTP_GET_VARS'] = $_GET = $inputGet;
                }
        }

        function GPvar($var,$strip=0)   {
                if(empty($var)) return;
                $value = isset($_POST[$var]) ? $_POST[$var] : $_GET[$var];
                if (isset($value) && is_string($value)) { $value = stripslashes($value); }      // Originally check '&& get_magic_quotes_gpc() ' but the values of $_GET are always slashed regardless of get_magic_quotes_gpc() because HTTP_POST/GET_VARS are run through addSlashesOnArray in the very beginning of index_ts.php eg.
                if ($strip && isset($value) && is_array($value)) { t3lib_div::stripSlashesOnArray($value); }
                return $value;
        }

        function GParrayMerged($var)    {
                $postA = is_array($_POST[$var]) ? $_POST[$var] : array();
                $getA = is_array($_GET[$var]) ? $_GET[$var] : array();
                $mergedA = t3lib_div::array_merge_recursive_overrule($getA,$postA);
                t3lib_div::stripSlashesOnArray($mergedA);
                return $mergedA;
        }










        /*************************
         *
         * IMAGE FUNCTIONS
         *
         *************************/


        function gif_compress($theFile, $type)  {
                $gfxConf = $GLOBALS['TYPO3_CONF_VARS']['GFX'];
                $returnCode='';
                if ($gfxConf['gif_compress'] && strtolower(substr($theFile,-4,4))=='.gif')      {       // GIF...
                        if (($type=='IM' || !$type) && $GLOBALS['TYPO3_CONF_VARS']['GFX']['im'] && $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw'])   {       // IM
                                exec($GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw'].'convert "'.$theFile.'" "'.$theFile.'"');
                                $returnCode='IM';
                        } elseif (($type=='GD' || !$type) && $gfxConf['gdlib'] && !$gfxConf['gdlib_png'])       {       // GD
                                $tempImage = imageCreateFromGif($theFile);
                                imageGif($tempImage, $theFile);
                                imageDestroy($tempImage);
                                $returnCode='GD';
                        }
                }
                return $returnCode;
        }

        function png_to_gif_by_imagemagick($theFile)    {
                if ($GLOBALS['TYPO3_CONF_VARS']['FE']['png_to_gif']
                        && $GLOBALS['TYPO3_CONF_VARS']['GFX']['im']
                        && $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw']
                        && strtolower(substr($theFile,-4,4))=='.png'
                        && @is_file($theFile))  {       // IM
                                $newFile = substr($theFile,0,-4).'.gif';
                                exec($GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw'].'convert "'.$theFile.'" "'.$newFile.'"');
                                $theFile = $newFile;
                                        // unlink old file?? May be bad idea bacause TYPO3 would then recreate the file every time as TYPO3 thinks the file is not generated because it's missing!! So do not unlink $theFile here!!
                }
                return $theFile;
        }

        function read_png_gif($theFile,$output_png=0)   {
                if ($GLOBALS['TYPO3_CONF_VARS']['GFX']['im'] && @is_file($theFile))     {
                        $ext = strtolower(substr($theFile,-4,4));
                        if (
                                        ((string)$ext=='.png' && $output_png)   ||
                                        ((string)$ext=='.gif' && !$output_png)
                                )       {
                                return $theFile;
                        } else {
                                $newFile = PATH_site.'typo3temp/readPG_'.md5($theFile.'|'.filemtime($theFile)).($output_png?'.png':'.gif');
                                exec($GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path'].'convert "'.$theFile.'" "'.$newFile.'"');
                                if (@is_file($newFile)) return $newFile;
                        }
                }
        }















        /*************************
         *
         * STRING FUNCTIONS
         *
         *************************/

        function fixed_lgd($string,$origChars,$preStr='...')    {
                $chars = abs($origChars);
                if ($chars >= 4)        {
                        if(strlen($string)>$chars)  {
                                return $origChars < 0 ?
                                        $preStr.trim(substr($string, -($chars-3))) :
                                        trim(substr($string, 0, $chars-3)).$preStr;
                        }
                }
                return $string;
        }

        function fixed_lgd_pre($string,$chars)  {
                return strrev(t3lib_div::fixed_lgd(strrev($string),$chars));
        }

        function fixed_lgd_cs($string,$chars)   {
                if (is_object($GLOBALS['LANG']))        {
                        return $GLOBALS['LANG']->csConvObj->crop($GLOBALS['LANG']->charSet,$string,$chars,'...');
                } else {
                        return t3lib_div::fixed_lgd($string, $chars);
                }
        }

        function breakTextForEmail($str,$implChar="\n",$charWidth=76)   {
                $lines = explode(chr(10),$str);
                $outArr=array();
                while(list(,$lStr)=each($lines))        {
                        $outArr = array_merge($outArr,t3lib_div::breakLinesForEmail($lStr,$implChar,$charWidth));
                }
                return implode(chr(10),$outArr);
        }

        function breakLinesForEmail($str,$implChar="\n",$charWidth=76)  {
                $lines=array();
                $l=$charWidth;
                $p=0;
                while(strlen($str)>$p)  {
                        $substr=substr($str,$p,$l);
                        if (strlen($substr)==$l)        {
                                $count = count(explode(' ',trim(strrev($substr))));
                                if ($count>1)   {       // OK...
                                        $parts = explode(' ',strrev($substr),2);
                                        $theLine = strrev($parts[1]);
                                } else {
                                        $afterParts = explode(' ',substr($str,$l+$p),2);
                                        $theLine = $substr.$afterParts[0];
                                }
                                if (!strlen($theLine))  {break; }       // Error, because this would keep us in an endless loop.
                        } else {
                                $theLine=$substr;
                        }

                        $lines[]=trim($theLine);
                        $p+=strlen($theLine);
                        if (!trim(substr($str,$p,$l)))  break;  // added...
                }
                return implode($implChar,$lines);
        }

        function cmpIP($baseIP, $list)  {
                $IPpartsReq = explode('.',$baseIP);
                if (count($IPpartsReq)==4)      {
                        $values = t3lib_div::trimExplode(',',$list,1);

                        foreach($values as $test)       {
                                list($test,$mask) = explode('/',$test);

                                if(intval($mask)) {
                                                // "192.168.3.0/24"
                                        $lnet = ip2long($test);
                                        $lip = ip2long($baseIP);
                                        $binnet = str_pad( decbin($lnet),32,'0','STR_PAD_LEFT');
                                        $firstpart = substr($binnet,0,$mask);
                                        $binip = str_pad( decbin($lip),32,'0','STR_PAD_LEFT');
                                        $firstip = substr($binip,0,$mask);
                                        $yes = (strcmp($firstpart,$firstip)==0);
                                } else {
                                                // "192.168.*.*"
                                        $IPparts = explode('.',$test);
                                        $yes = 1;
                                        reset($IPparts);
                                        while(list($index,$val)=each($IPparts)) {
                                                $val = trim($val);
                                                if (strcmp($val,'*') && strcmp($IPpartsReq[$index],$val))       {
                                                        $yes=0;
                                                }
                                        }
                                }
                                if ($yes) return true;
                        }
                }
                return false;
        }

        function cmpFQDN($baseIP, $list)        {
                if (count(explode('.',$baseIP))==4)     {
                        $resolvedHostName = explode('.', gethostbyaddr($baseIP));
                        $values = t3lib_div::trimExplode(',',$list,1);

                        foreach($values as $test)       {
                                $hostNameParts = explode('.',$test);
                                $yes = 1;

                                foreach($hostNameParts as $index => $val)       {
                                        $val = trim($val);
                                        if (strcmp($val,'*') && strcmp($resolvedHostName[$index],$val)) {
                                                $yes=0;
                                        }
                                }
                                if ($yes) return true;
                        }
                }
                return false;
        }

        function inList($in_list,$item) {
                return strstr(','.$in_list.',', ','.$item.',');
        }

        function rmFromList($element,$list)     {
                $items = explode(',',$list);
                while(list($k,$v)=each($items)) {
                        if ($v==$element)       {unset($items[$k]);}
                }
                return implode(',',$items);
        }

        function intInRange($theInt,$min,$max=2000000000,$zeroValue=0)  {
                // Returns $theInt as an integer in the integerspace from $min to $max
                $theInt = intval($theInt);
                if ($zeroValue && !$theInt)     {$theInt=$zeroValue;}   // If the input value is zero after being converted to integer, zeroValue may set another default value for it.
                if ($theInt<$min){$theInt=$min;}
                if ($theInt>$max){$theInt=$max;}
                return $theInt;
        }

        function intval_positive($theInt)       {
                $theInt = intval($theInt);
                if ($theInt<0){$theInt=0;}
                return $theInt;
        }

        function int_from_ver($verNumberStr)    {
                $verParts = explode('.',$verNumberStr);
                return intval((int)$verParts[0].str_pad((int)$verParts[1],3,'0',STR_PAD_LEFT).str_pad((int)$verParts[2],3,'0',STR_PAD_LEFT));
        }

        function md5int($str)   {
                return hexdec(substr(md5($str),0,7));
        }

        function shortMD5($input, $len=10)      {
                return substr(md5($input),0,$len);
        }

        function uniqueList($in_list, $secondParameter=NULL)    {
                if (is_array($in_list)) die('t3lib_div::uniqueList() does NOT support array arguments anymore! Only string comma lists!');
                if (isset($secondParameter))    die('t3lib_div::uniqueList() does NOT support more than a single argument value anymore. You have specified more than one.');

                return implode(',',array_unique(t3lib_div::trimExplode(',',$in_list,1)));
        }

        function split_fileref($fileref)        {
                if (    ereg('(.*/)(.*)$',$fileref,$reg)        )       {
                        $info['path'] = $reg[1];
                        $info['file'] = $reg[2];
                } else {
                        $info['path'] = '';
                        $info['file'] = $fileref;
                }
                $reg='';
                if (    ereg('(.*)\.([^\.]*$)',$info['file'],$reg)      )       {
                        $info['filebody'] = $reg[1];
                        $info['fileext'] = strtolower($reg[2]);
                        $info['realFileext'] = $reg[2];
                } else {
                        $info['filebody'] = $info['file'];
                        $info['fileext'] = '';
                }
                reset($info);
                return $info;
        }

        function dirname($path) {
                $p=t3lib_div::revExplode('/',$path,2);
                return count($p)==2?$p[0]:'';
        }

        function modifyHTMLColor($color,$R,$G,$B)       {
                // This takes a hex-color (# included!) and adds $R, $G and $B to the HTML-color (format: #xxxxxx) and returns the new color
                $nR = t3lib_div::intInRange(hexdec(substr($color,1,2))+$R,0,255);
                $nG = t3lib_div::intInRange(hexdec(substr($color,3,2))+$G,0,255);
                $nB = t3lib_div::intInRange(hexdec(substr($color,5,2))+$B,0,255);
                return '#'.
                        substr('0'.dechex($nR),-2).
                        substr('0'.dechex($nG),-2).
                        substr('0'.dechex($nB),-2);
        }

        function modifyHTMLColorAll($color,$all)        {
                return t3lib_div::modifyHTMLColor($color,$all,$all,$all);
        }

        function rm_endcomma($string)   {
                return ereg_replace(',$','',$string);
        }

        function danish_strtoupper($string)     {
                $value = strtoupper($string);
                return strtr($value, 'áéúíâêûôîæøåäöü', 'ÁÉÚÍÄËÜÖÏÆØÅÄÖÜ');
        }

        function convUmlauts($str)      {
                $pat  = array ( '/ä/',  '/Ä/',  '/ö/',  '/Ö/',  '/ü/',  '/Ü/',  '/ß/',  '/å/',  '/Å/',  '/ø/',  '/Ø/',  '/æ/',  '/Æ/'   );
                $repl = array ( 'ae',   'Ae',   'oe',   'Oe',   'ue',   'Ue',   'ss',   'aa',   'AA',   'oe',   'OE',   'ae',   'AE'    );
                return preg_replace($pat,$repl,$str);
        }

        function testInt($var)  {
                return !strcmp($var,intval($var));
        }

        function isFirstPartOfStr($str,$partStr)        {
                // Returns true, if the first part of a $str equals $partStr and $partStr is not ''
                $psLen = strlen($partStr);
                if ($psLen)     {
                        return substr($str,0,$psLen)==(string)$partStr;
                } else return false;
        }

        function formatSize($sizeInBytes,$labels='')    {

                        // Set labels:
                if (strlen($labels) == 0) {
                    $labels = ' | K| M| G';
                } else {
                    $labels = str_replace('"','',$labels);
                }
                $labelArr = explode('|',$labels);

                        // Find size:
                if ($sizeInBytes>900)   {
                        if ($sizeInBytes>900000000)     {       // GB
                                $val = $sizeInBytes/(1024*1024*1024);
                                return number_format($val, (($val<20)?1:0), '.', '').$labelArr[3];
                        }
                        elseif ($sizeInBytes>900000)    {       // MB
                                $val = $sizeInBytes/(1024*1024);
                                return number_format($val, (($val<20)?1:0), '.', '').$labelArr[2];
                        } else {        // KB
                                $val = $sizeInBytes/(1024);
                                return number_format($val, (($val<20)?1:0), '.', '').$labelArr[1];
                        }
                } else {        // Bytes
                        return $sizeInBytes.$labelArr[0];
                }
        }

        function convertMicrotime($microtime)   {
                $parts = explode(' ',$microtime);
                return round(($parts[0]+$parts[1])*1000);
        }

        function splitCalc($string,$operators)  {
                $res = Array();
                $sign='+';
                while($string)  {
                        $valueLen=strcspn($string,$operators);
                        $value=substr($string,0,$valueLen);
                        $res[] = Array($sign,trim($value));
                        $sign=substr($string,$valueLen,1);
                        $string=substr($string,$valueLen+1);
                }
                reset($res);
                return $res;
        }

        function calcPriority($string)  {
                $string=ereg_replace('[[:space:]]*','',$string);        // removing all whitespace
                $string='+'.$string;    // Ensuring an operator for the first entrance
                $qm='\*\/\+-^%';
                $regex = '(['.$qm.'])(['.$qm.']?[0-9\.]*)';
                        // split the expression here:
                preg_match_all('/'.$regex.'/',$string,$reg);

                reset($reg[2]);
                $number=0;
                $Msign='+';
                $err='';
                $buffer=doubleval(current($reg[2]));
                next($reg[2]);  // Advance pointer
                while(list($k,$v)=each($reg[2]))        {
                        $v=doubleval($v);
                        $sign = $reg[1][$k];
                        if ($sign=='+' || $sign=='-')   {
                                $number = $Msign=='-' ? $number-=$buffer : $number+=$buffer;
                                $Msign = $sign;
                                $buffer=$v;
                        } else {
                                if ($sign=='/') {if ($v) $buffer/=$v; else $err='dividing by zero';}
                                if ($sign=='%') {if ($v) $buffer%=$v; else $err='dividing by zero';}
                                if ($sign=='*') {$buffer*=$v;}
                                if ($sign=='^') {$buffer=pow($buffer,$v);}
                        }
                }
                $number = $Msign=='-' ? $number-=$buffer : $number+=$buffer;
                return $err ? 'ERROR: '.$err : $number;
        }

        function calcParenthesis($string)       {
                $securC=100;
                do {
                        $valueLenO=strcspn($string,'(');
                        $valueLenC=strcspn($string,')');
                        if ($valueLenC==strlen($string) || $valueLenC < $valueLenO)     {
                                $value = t3lib_div::calcPriority(substr($string,0,$valueLenC));
                                $string = $value.substr($string,$valueLenC+1);
                                return $string;
                        } else {
                                $string = substr($string,0,$valueLenO).t3lib_div::calcParenthesis(substr($string,$valueLenO+1));
                        }
                                // Security:
                        $securC--;
                        if ($securC<=0) break;
                } while($valueLenO<strlen($string));
                return $string;
        }

        function htmlspecialchars_decode($value)        {
                $value = str_replace('&gt;','>',$value);
                $value = str_replace('&lt;','<',$value);
                $value = str_replace('&quot;','"',$value);
                $value = str_replace('&amp;','&',$value);
                return $value;
        }

        function deHSCentities($str)    {
                return ereg_replace('&amp;([#[:alnum:]]*;)','&\1',$str);
        }

        function slashJS($string,$extended=0,$char="'") {
                if ($extended)  {$string = str_replace ("\\", "\\\\", $string);}
                return str_replace ($char, "\\".$char, $string);
        }

        function rawUrlEncodeJS($str)   {
                return str_replace('%20',' ',rawurlencode($str));
        }

        function rawUrlEncodeFP($str)   {
                return str_replace('%2F','/',rawurlencode($str));
        }

        function validEmail($email)     {
                $email = trim ($email);
                if (strstr($email,' '))  return FALSE;
                return ereg('^[A-Za-z0-9\._-]+[@][A-Za-z0-9\._-]+[\.].[A-Za-z0-9]+$',$email) ? TRUE : FALSE;
        }

        function formatForTextarea($content)    {
                return chr(10).htmlspecialchars($content);
        }












        /*************************
         *
         * ARRAY FUNCTIONS
         *
         *************************/

        function inArray($in_array,$item)       {
                if (is_array($in_array))        {
                        while (list(,$val)=each($in_array))     {
                                if (!is_array($val) && !strcmp($val,$item)) return true;
                        }
                }
        }

        function intExplode($delim, $string)    {
                $temp = explode($delim,$string);
                while(list($key,$val)=each($temp))      {
                        $temp[$key]=intval($val);
                }
                reset($temp);
                return $temp;
        }

        function revExplode($delim, $string, $count=0)  {
                $temp = explode($delim,strrev($string),$count);
                while(list($key,$val)=each($temp))      {
                        $temp[$key]=strrev($val);
                }
                $temp=array_reverse($temp);
                reset($temp);
                return $temp;
        }

        function trimExplode($delim, $string, $onlyNonEmptyValues=0)    {
                $temp = explode($delim,$string);
                $newtemp=array();
                while(list($key,$val)=each($temp))      {
                        if (!$onlyNonEmptyValues || strcmp('',trim($val)))      {
                                $newtemp[]=trim($val);
                        }
                }
                reset($newtemp);
                return $newtemp;
        }

        function uniqueArray($valueArray)       {
                return array_unique($valueArray);
        }

        function removeArrayEntryByValue($array,$cmpValue)      {
                if (is_array($array))   {
                        reset($array);
                        while(list($k,$v)=each($array)) {
                                if (is_array($v))       {
                                        $array[$k] = t3lib_div::removeArrayEntryByValue($v,$cmpValue);
                                } else {
                                        if (!strcmp($v,$cmpValue))      {
                                                unset($array[$k]);
                                        }
                                }
                        }
                }
                reset($array);
                return $array;
        }

        function implodeArrayForUrl($name,$theArray,$str='',$skipBlank=0,$rawurlencodeParamName=0)      {
                if (is_array($theArray))        {
                        foreach($theArray as $Akey => $AVal)    {
                                $thisKeyName = $name ? $name.'['.$Akey.']' : $Akey;
                                if (is_array($AVal))    {
                                        $str = t3lib_div::implodeArrayForUrl($thisKeyName,$AVal,$str,$skipBlank,$rawurlencodeParamName);
                                } else {
                                        if (!$skipBlank || strcmp($AVal,''))    {
                                                $str.='&'.($rawurlencodeParamName ? rawurlencode($thisKeyName) : $thisKeyName).
                                                        '='.rawurlencode($AVal);        // strips slashes because _POST / _GET input is with slashes...
                                        }
                                }
                        }
                }
                return $str;
        }

        function compileSelectedGetVarsFromArray($varList,$getArray,$GPvarAlt=1)        {
                $keys = t3lib_div::trimExplode(',',$varList,1);
                $outArr=array();
                foreach($keys as $v)    {
                        if (isset($getArray[$v]))       {
                                $outArr[$v]=$getArray[$v];
                        } elseif ($GPvarAlt) {
                                $outArr[$v]=t3lib_div::_GP($v);
                        }
                }
                return $outArr;
        }

        function addSlashesOnArray(&$theArray)  {
                if (is_array($theArray))        {
                        reset($theArray);
                        while(list($Akey,$AVal)=each($theArray))        {
                                if (is_array($AVal))    {
                                        t3lib_div::addSlashesOnArray($theArray[$Akey]);
                                } else {
                                        $theArray[$Akey] = addslashes($AVal);
                                }
                        }
                        reset($theArray);
                }
        }

        function stripSlashesOnArray(&$theArray)        {
                if (is_array($theArray))        {
                        reset($theArray);
                        while(list($Akey,$AVal)=each($theArray))        {
                                if (is_array($AVal))    {
                                        t3lib_div::stripSlashesOnArray($theArray[$Akey]);
                                } else {
                                        $theArray[$Akey] = stripslashes($AVal);
                                }
                        }
                        reset($theArray);
                }
        }

        function slashArray($arr,$cmd)  {
                if ($cmd=='strip')      t3lib_div::stripSlashesOnArray($arr);
                if ($cmd=='add')        t3lib_div::addSlashesOnArray($arr);
                return $arr;
        }

        function array_merge_recursive_overrule($arr0,$arr1,$notAddKeys=0,$includeEmtpyValues=true) {
                reset($arr1);
                while(list($key,$val) = each($arr1)) {
                        if(is_array($arr0[$key])) {
                                if (is_array($arr1[$key]))      {
                                        $arr0[$key] = t3lib_div::array_merge_recursive_overrule($arr0[$key],$arr1[$key],$notAddKeys);
                                }
                        } else {
                                if ($notAddKeys) {
                                        if (isset($arr0[$key])) {
                                                if ($includeEmtpyValues OR $val) {
                                                        $arr0[$key] = $val;
                                                }
                                        }
                                } else {
                                        if ($includeEmtpyValues OR $val) {
                                                $arr0[$key] = $val;
                                        }
                                }
                        }
                }
                reset($arr0);
                return $arr0;
        }

        function array_merge($arr1,$arr2)       {
                return $arr2+$arr1;
        }

        function csvValues($row,$delim=',',$quote='"')  {
                reset($row);
                $out=array();
                while(list(,$value)=each($row)) {
                        list($valPart) = explode(chr(10),$value);
                        $valPart = trim($valPart);
                        $out[]=str_replace($quote,$quote.$quote,$valPart);
                }
                $str = $quote.implode($quote.$delim.$quote,$out).$quote;
                return $str;
        }
















        /*************************
         *
         * HTML/XML PROCESSING
         *
         *************************/

        function get_tag_attributes($tag)       {
                $components = t3lib_div::split_tag_attributes($tag);
                $name = '';      // attribute name is stored here
                $valuemode = '';
                if (is_array($components))      {
                        while (list($key,$val) = each ($components))    {
                                if ($val != '=')        {       // Only if $name is set (if there is an attribute, that waits for a value), that valuemode is enabled. This ensures that the attribute is assigned it's value
                                        if ($valuemode) {
                                                if ($name)      {
                                                        $attributes[$name] = $val;
                                                        $name = '';
                                                }
                                        } else {
                                                if ($key = strtolower(ereg_replace('[^a-zA-Z0-9]','',$val)))    {
                                                        $attributes[$key] = '';
                                                        $name = $key;
                                                }
                                        }
                                        $valuemode = '';
                                } else {
                                        $valuemode = 'on';
                                }
                        }
                        if (is_array($attributes))      reset($attributes);
                        return $attributes;
                }
        }

        function split_tag_attributes($tag)     {
                $tag_tmp = trim(eregi_replace ('^<[^[:space:]]*','',trim($tag)));
                        // Removes any > in the end of the string
                $tag_tmp = trim(eregi_replace ('>$','',$tag_tmp));

                while (strcmp($tag_tmp,''))     {       // Compared with empty string instead , 030102
                        $firstChar=substr($tag_tmp,0,1);
                        if (!strcmp($firstChar,'"') || !strcmp($firstChar,"'")) {
                                $reg=explode($firstChar,$tag_tmp,3);
                                $value[]=$reg[1];
                                $tag_tmp=trim($reg[2]);
                        } elseif (!strcmp($firstChar,'=')) {
                                $value[] = '=';
                                $tag_tmp = trim(substr($tag_tmp,1));            // Removes = chars.
                        } else {
                                        // There are '' around the value. We look for the next ' ' or '>'
                                $reg = split('[[:space:]=]',$tag_tmp,2);
                                $value[] = trim($reg[0]);
                                $tag_tmp = trim(substr($tag_tmp,strlen($reg[0]),1).$reg[1]);
                        }
                }
                if (is_array($value))   reset($value);
                return $value;
        }

        function implodeAttributes($arr,$xhtmlSafe=FALSE,$dontOmitBlankAttribs=FALSE)   {
                if (is_array($arr))     {
                        if ($xhtmlSafe) {
                                $newArr=array();
                                foreach($arr as $p => $v)       {
                                        if (!isset($newArr[strtolower($p)])) $newArr[strtolower($p)] = htmlspecialchars($v);
                                }
                                $arr = $newArr;
                        }
                        $list = array();
                        foreach($arr as $p => $v)       {
                                if (strcmp($v,'') || $dontOmitBlankAttribs)     {$list[]=$p.'="'.$v.'"';}
                        }
                        return implode(' ',$list);
                }
        }

        function implodeParams($arr,$xhtmlSafe=FALSE,$dontOmitBlankAttribs=FALSE)       {
                return t3lib_div::implodeAttributes($arr,$xhtmlSafe,$dontOmitBlankAttribs);
        }

        function wrapJS($string, $linebreak=TRUE) {
                if(trim($string)) {
                                // <script wrapped in nl?
                        $cr = $linebreak? "\n" : '';

                                // remove nl from the beginning
                        $string = preg_replace ('/^\n+/', '', $string);
                                // re-ident to one tab using the first line as reference
                        if(preg_match('/^(\t+)/',$string,$match)) {
                                $string = str_replace($match[1],"\t", $string);
                        }
                        $string = $cr.'<script type="text/javascript">
/*<![CDATA[*/
'.$string.'
/*]]>*/
</script>'.$cr;
                }
                return trim($string);
        }


        function xml2tree($string,$depth=999) {
                $parser = xml_parser_create();
                $vals = array();
                $index = array();

                xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
                xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 0);
                xml_parse_into_struct($parser, $string, $vals, $index);

                if (xml_get_error_code($parser))        return 'Line '.xml_get_current_line_number($parser).': '.xml_error_string(xml_get_error_code($parser));
                xml_parser_free($parser);

                $stack = array( array() );
                $stacktop = 0;
                $startPoint=0;

                unset($tagi);
                foreach($vals as $key => $val) {
                        $type = $val['type'];

                                // open tag:
                        if ($type=='open' || $type=='complete') {
                                $stack[$stacktop++] = $tagi;

                                if ($depth==$stacktop)  {
                                        $startPoint=$key;
                                }

                                $tagi = array('tag' => $val['tag']);

                                if(isset($val['attributes']))  $tagi['attrs'] = $val['attributes'];
                                if(isset($val['value']))        $tagi['values'][] = $val['value'];
                        }
                                // finish tag:
                        if ($type=='complete' || $type=='close')        {
                                $oldtagi = $tagi;
                                $tagi = $stack[--$stacktop];
                                $oldtag = $oldtagi['tag'];
                                unset($oldtagi['tag']);

                                if ($depth==($stacktop+1))      {
                                        if ($key-$startPoint > 0)       {
                                                $partArray = array_slice(
                                                        $vals,
                                                        $startPoint+1,
                                                        $key-$startPoint-1
                                                );
                                                #$oldtagi=array('XMLvalue'=>t3lib_div::xmlRecompileFromStructValArray($partArray));
                                                $oldtagi['XMLvalue']=t3lib_div::xmlRecompileFromStructValArray($partArray);
                                        } else {
                                                $oldtagi['XMLvalue']=$oldtagi['values'][0];
                                        }
                                }

                                $tagi['ch'][$oldtag][] = $oldtagi;
                                unset($oldtagi);
                        }
                                // cdata
                        if($type=='cdata') {
                                $tagi['values'][] = $val['value'];
                        }
                }
                return $tagi['ch'];
        }

        function array2xml($array,$NSprefix='',$level=0,$docTag='phparray',$spaceInd=0, $options=array(),$parentTagName='')     {
                        // The list of byte values which will trigger binary-safe storage. If any value has one of these char values in it, it will be encoded in base64
                $binaryChars = chr(0).chr(1).chr(2).chr(3).chr(4).chr(5).chr(6).chr(7).chr(8).
                                                chr(11).chr(12).chr(14).chr(15).chr(16).chr(17).chr(18).chr(19).
                                                chr(20).chr(21).chr(22).chr(23).chr(24).chr(25).chr(26).chr(27).chr(28).chr(29).
                                                chr(30).chr(31);
                        // Set indenting mode:
                $indentChar = $spaceInd ? ' ' : chr(9);
                $indentN = $spaceInd>0 ? $spaceInd : 1;

                        // Init output variable:
                $output='';

                        // Traverse the input array
                if (is_array($array))   {
                        foreach($array as $k=>$v)       {
                                $attr = '';
                                $tagName = $k;

                                        // Construct the tag name.
                                if (!strcmp(intval($tagName),$tagName)) {       // If integer...;
                                        if ($options['useNindex']) {    // If numeric key, prefix "n"
                                                $tagName = 'n'.$tagName;
                                        } else {        // Use special tag for num. keys:
                                                $attr.=' index="'.$tagName.'"';
                                                $tagName = $options['useIndexTagForNum'] ? $options['useIndexTagForNum'] : 'numIndex';
                                        }
                                } elseif($options['useIndexTagForAssoc']) {             // Use tag for all associative keys:
                                        $attr.=' index="'.htmlspecialchars($tagName).'"';
                                        $tagName = $options['useIndexTagForAssoc'];
                                } elseif(isset($options['parentTagMap'][$parentTagName])) {             // Use tag based on parent tag name:
                                        $attr.=' index="'.htmlspecialchars($tagName).'"';
                                        $tagName = (string)$options['parentTagMap'][$parentTagName];
                                }

                                        // The tag name is cleaned up so only alphanumeric chars (plus - and _) are in there and not longer than 100 chars either.
                                $tagName = substr(ereg_replace('[^[:alnum:]_-]','',$tagName),0,100);

                                        // If the value is an array then we will call this function recursively:
                                if (is_array($v))       {
                                        // Sub elements:
                                        $content = chr(10).t3lib_div::array2xml($v,$NSprefix,$level+1,'',$spaceInd,$options,$tagName).
                                                                str_pad('',($level+1)*$indentN,$indentChar);
                                        $attr.=' type="array"';
                                } else {        // Just a value:

                                                // Look for binary chars:
                                        if (strcspn($v,$binaryChars) != strlen($v))     {       // Go for base64 encoding if the initial segment NOT matching any binary char has the same length as the whole string!
                                                        // If the value contained binary chars then we base64-encode it an set an attribute to notify this situation:
                                                $content = chr(10).chunk_split(base64_encode($v));
                                                $attr.=' base64="1"';
                                        } else {
                                                        // Otherwise, just htmlspecialchar the stuff:
                                                $content = htmlspecialchars($v);
                                                $dType = gettype($v);
                                                if ($dType!='string')   { $attr.=' type="'.$dType.'"'; }
                                        }
                                }

                                        // Add the element to the output string:
                                $output.=str_pad('',($level+1)*$indentN,$indentChar).'<'.$NSprefix.$tagName.$attr.'>'.$content.'</'.$NSprefix.$tagName.'>'.chr(10);
                        }
                }

                        // If we are at the outer-most level, then we finally wrap it all in the document tags and return that as the value:
                if (!$level)    {
                        $output =
                                '<'.$docTag.'>'.chr(10).
                                $output.
                                '</'.$docTag.'>';
                }

                return $output;
        }

        function xml2array($string,$NSprefix='') {
                global $TYPO3_CONF_VARS;

                        // Create parser:
                $parser = xml_parser_create();
                $vals = array();
                $index = array();

                xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
                xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 0);

                        // PHP5 fix of charset awareness:
                        // Problem is: PHP5 apparently detects the charset of the XML file (or defaults to utf-8) and will AUTOMATICALLY convert the content to either utf-8, iso-8859-1 or us-ascii. PHP4 just passed the content through without taking action regarding the charset.
                        // In TYPO3 we expect that the charset of XML content is NOT handled in the parser but internally in TYPO3 instead. THerefore it would be very nice if PHP5 could be configured to NOT process the charset of the files. But this is not possible for now.
                        // What we do here fixes the problem but ONLY if the charset is utf-8, iso-8859-1 or us-ascii. That should work for most TYPO3 installations, in particular if people use utf-8 which we highly recommend.
                if ((double)phpversion()>=5)    {
                        unset($ereg_result);
                        ereg('^[[:space:]]*<\?xml[^>]*encoding[[:space:]]*=[[:space:]]*"([^"]*)"',substr($string,0,200),$ereg_result);
                        $theCharset = $ereg_result[1] ? $ereg_result[1] : ($TYPO3_CONF_VARS['BE']['forceCharset'] ? $TYPO3_CONF_VARS['BE']['forceCharset'] : 'iso-8859-1');
                        xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, $theCharset);  // us-ascii / utf-8 / iso-8859-1
                }

                        // Parse content:
                xml_parse_into_struct($parser, $string, $vals, $index);

                        // If error, return error message:
                if (xml_get_error_code($parser))        return 'Line '.xml_get_current_line_number($parser).': '.xml_error_string(xml_get_error_code($parser));
                xml_parser_free($parser);

                        // Init vars:
                $stack = array(array());
                $stacktop = 0;
                $current=array();
                $tagName='';

                        // Traverse the parsed XML structure:
                foreach($vals as $key => $val) {

                                // First, process the tag-name (which is used in both cases, whether "complete" or "close")
                        $tagName = $val['tag'];

                                // Test for name space:
                        $tagName = ($NSprefix && substr($tagName,0,strlen($NSprefix))==$NSprefix) ? substr($tagName,strlen($NSprefix)) : $tagName;

                                // Test for numeric tag, encoded on the form "nXXX":
                        $testNtag = substr($tagName,1); // Closing tag.
                        $tagName = (substr($tagName,0,1)=='n' && !strcmp(intval($testNtag),$testNtag)) ? intval($testNtag) : $tagName;

                                // Test for alternative index value:
                        if (strlen($val['attributes']['index']))        { $tagName = $val['attributes']['index']; }

                                // Setting tag-values, manage stack:
                        switch($val['type'])    {
                                case 'open':            // If open tag it means there is an array stored in sub-elements. Therefore increase the stackpointer and reset the accumulation array:
                                        $current[$tagName] = array();   // Setting blank place holder
                                        $stack[$stacktop++] = $current;
                                        $current = array();
                                break;
                                case 'close':   // If the tag is "close" then it is an array which is closing and we decrease the stack pointer.
                                        $oldCurrent = $current;
                                        $current = $stack[--$stacktop];
                                        end($current);  // Going to the end of array to get placeholder key, key($current), and fill in array next:
                                        $current[key($current)] = $oldCurrent;
                                        unset($oldCurrent);
                                break;
                                case 'complete':        // If "complete", then it's a value. If the attribute "base64" is set, then decode the value, otherwise just set it.
                                        if ($val['attributes']['base64'])       {
                                                $current[$tagName] = base64_decode($val['value']);
                                        } else {
                                                $current[$tagName] = (string)$val['value']; // Had to cast it as a string - otherwise it would be evaluate false if tested with isset()!!

                                                        // Cast type:
                                                switch((string)$val['attributes']['type'])      {
                                                        case 'integer':
                                                                $current[$tagName] = (integer)$current[$tagName];
                                                        break;
                                                        case 'double':
                                                                $current[$tagName] = (double)$current[$tagName];
                                                        break;
                                                        case 'boolean':
                                                                $current[$tagName] = (bool)$current[$tagName];
                                                        break;
                                                        case 'array':
                                                                $current[$tagName] = array();   // MUST be an empty array since it is processed as a value; Empty arrays would end up here because they would have no tags inside...
                                                        break;
                                                }
                                        }
                                break;
                        }
                }

                        // Finally return the content of the document tag.
                return $current[$tagName];
        }

        function xmlRecompileFromStructValArray($vals)  {
                $XMLcontent='';

                foreach($vals as $val) {
                        $type = $val['type'];

                                // open tag:
                        if ($type=='open' || $type=='complete') {
                                $XMLcontent.='<'.$val['tag'];
                                if(isset($val['attributes']))  {
                                        foreach($val['attributes'] as $k => $v) {
                                                $XMLcontent.=' '.$k.'="'.htmlspecialchars($v).'"';
                                        }
                                }
                                if ($type=='complete')  {
                                        if(isset($val['value']))        {
                                                $XMLcontent.='>'.htmlspecialchars($val['value']).'</'.$val['tag'].'>';
                                        } else $XMLcontent.='/>';
                                } else $XMLcontent.='>';

                                if ($type=='open' && isset($val['value']))      {
                                        $XMLcontent.=htmlspecialchars($val['value']);
                                }
                        }
                                // finish tag:
                        if ($type=='close')     {
                                $XMLcontent.='</'.$val['tag'].'>';
                        }
                                // cdata
                        if($type=='cdata') {
                                $XMLcontent.=htmlspecialchars($val['value']);
                        }
                }

                return $XMLcontent;
        }

        function xmlGetHeaderAttribs($xmlData)  {
                $xmlHeader = substr(trim($xmlData),0,200);
                $reg=array();
                if (eregi('^<\?xml([^>]*)\?\>',$xmlHeader,$reg))        {
                        return t3lib_div::get_tag_attributes($reg[1]);
                }
        }











        /*************************
         *
         * FILES FUNCTIONS
         *
         *************************/

        function getURL($url)   {
                $content = '';

                        // (Proxy support implemented by Arco <arco@appeltaart.mine.nu>)
                if((substr($url,0,7)=='http://') && ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlUse']=='1'))       {
                        //external URL without error checking.
                        $ch = curl_init();
                        curl_setopt ($ch,CURLOPT_URL, $url);
                        curl_setopt ($ch,CURLOPT_HEADER, 0);
                        curl_setopt ($ch,CURLOPT_RETURNTRANSFER, 1);

                        if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyServer']) {
                                curl_setopt ($ch, CURLOPT_PROXY, $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyServer']);

                                // I don't know if it will be needed
                                if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyTunnel']) {
                                        curl_setopt ($ch, CURLOPT_HTTPPROXYTUNNEL, $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyTunnel'] );
                                }
                                if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyUserPass']) {
                                        curl_setopt ($ch, CURLOPT_PROXYUSERPWD, $GLOBALS['TYPO3_CONF_VARS']['SYS']['curlProxyUserPass'] );
                                }
                        }
                        $content=curl_exec ($ch);
                        curl_close ($ch);
                        return $content;
                } elseif($fd = fopen($url,'rb'))    {
                        while (!feof($fd))      {
                                $content.=fread($fd, 5000);
                        }
                        fclose($fd);
                        return $content;
                }
        }

        function writeFile($file,$content)      {
                if($fd = fopen($file,'wb'))     {
                        fwrite( $fd, $content);
                        fclose( $fd );

                                // Setting file system mode & group ownership of file:
                        if (@is_file($file) && TYPO3_OS!='WIN') {
                                @chmod($file, octdec($GLOBALS['TYPO3_CONF_VARS']['BE']['fileCreateMask']));             // "@" is there because file is not necessarily OWNED by the user
                                if($GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup'])    {       // skip this if createGroup is empty
                                        @chgrp($file, $GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup']);                // "@" is there because file is not necessarily OWNED by the user
                                }
                        }

                        return true;
                }
        }

        function writeFileToTypo3tempDir($filepath,$content)    {

                        // Parse filepath into directory and basename:
                $fI = pathinfo($filepath);
                $fI['dirname'].= '/';

                        // Check parts:
                if (t3lib_div::validPathStr($filepath) && $fI['basename'] && strlen($fI['basename'])<60)        {
                        if (defined('PATH_site'))       {
                                $dirName = PATH_site.'typo3temp/';      // Setting main temporary directory name (standard)
                                if (@is_dir($dirName))  {
                                        if (t3lib_div::isFirstPartOfStr($fI['dirname'],$dirName))       {

                                                        // Checking if the "subdir" is found:
                                                $subdir = substr($fI['dirname'],strlen($dirName));
                                                if ($subdir)    {
                                                        if (ereg('^[[:alnum:]_]+\/$',$subdir))  {
                                                                $dirName.= $subdir;
                                                                if (!@is_dir($dirName)) {
                                                                        t3lib_div::mkdir($dirName);
                                                                }
                                                        } else return 'Subdir, "'.$subdir.'", was NOT on the form "[a-z]/"';
                                                }
                                                        // Checking dir-name again (sub-dir might have been created):
                                                if (@is_dir($dirName))  {
                                                        if ($filepath == $dirName.$fI['basename'])      {
                                                                t3lib_div::writeFile($filepath, $content);
                                                                if (!@is_file($filepath))       return 'File not written to disk! Write permission error in filesystem?';
                                                        } else return 'Calculated filelocation didn\'t match input $filepath!';
                                                } else return '"'.$dirName.'" is not a directory!';
                                        } else return '"'.$fI['dirname'].'" was not within directory PATH_site + "typo3temp/"';
                                } else return 'PATH_site + "typo3temp/" was not a directory!';
                        } else return 'PATH_site constant was NOT defined!';
                } else return 'Input filepath "'.$filepath.'" was generally invalid!';
        }

        function mkdir($theNewFolder)   {
                $theNewFolder = ereg_replace('\/$','',$theNewFolder);
                if (mkdir($theNewFolder, octdec($GLOBALS['TYPO3_CONF_VARS']['BE']['folderCreateMask']))){
                        chmod($theNewFolder, octdec($GLOBALS['TYPO3_CONF_VARS']['BE']['folderCreateMask'])); //added this line, because the mode at 'mkdir' has a strange behaviour sometimes

                        if($GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup'])    {       // skip this if createGroup is empty
                                chgrp($theNewFolder, $GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup']);
                        }
                        return TRUE;
                }
        }

        function get_dirs($path)        {
                if ($path)      {
                        $d = @dir($path);
                        if (is_object($d))      {
                                while($entry=$d->read()) {
                                        if (@is_dir($path.'/'.$entry) && $entry!= '..' && $entry!= '.') {
                                            $filearray[]=$entry;
                                        }
                                }
                                $d->close();
                        } else return 'error';
                        return $filearray;
                }
        }

        function getFilesInDir($path,$extensionList='',$prependPath=0,$order='')        {

                        // Initialize variabels:
                $filearray = array();
                $sortarray = array();
                $path = ereg_replace('\/$','',$path);

                        // Find files+directories:
                if (@is_dir($path))     {
                        $extensionList = strtolower($extensionList);
                        $d = dir($path);
                        if (is_object($d))      {
                                while($entry=$d->read()) {
                                        if (@is_file($path.'/'.$entry)) {
                                                $fI = pathinfo($entry);
                                                $key = md5($path.'/'.$entry);
                                                if (!$extensionList || t3lib_div::inList($extensionList,strtolower($fI['extension'])))  {
                                                    $filearray[$key]=($prependPath?$path.'/':'').$entry;
                                                        if ($order=='mtime') {$sortarray[$key]=filemtime($path.'/'.$entry);}
                                                                elseif ($order) {$sortarray[$key]=$entry;}
                                                }
                                        }
                                }
                                $d->close();
                        } else return 'error opening path: "'.$path.'"';
                }

                        // Sort them:
                if ($order) {
                        asort($sortarray);
                        reset($sortarray);
                        $newArr=array();
                        while(list($k,$v)=each($sortarray))     {
                                $newArr[$k]=$filearray[$k];
                        }
                        $filearray=$newArr;
                }

                        // Return result
                reset($filearray);
                return $filearray;
        }

        function getAllFilesAndFoldersInPath($fileArr,$path,$extList='',$regDirs=0,$recursivityLevels=99)       {
                if ($regDirs)   $fileArr[] = $path;
                $fileArr = array_merge($fileArr, t3lib_div::getFilesInDir($path,$extList,1,1));

                $dirs = t3lib_div::get_dirs($path);
                if (is_array($dirs) && $recursivityLevels>0)    {
                        foreach ($dirs as $subdirs)     {
                                if ((string)$subdirs!='')       {
                                        $fileArr = t3lib_div::getAllFilesAndFoldersInPath($fileArr,$path.$subdirs.'/',$extList,$regDirs,$recursivityLevels-1);
                                }
                        }
                }
                return $fileArr;
        }

        function removePrefixPathFromList($fileArr,$prefixToRemove)     {
                foreach($fileArr as $k => $absFileRef)  {
                        if(t3lib_div::isFirstPartOfStr($absFileRef,$prefixToRemove))    {
                                $fileArr[$k] = substr($absFileRef,strlen($prefixToRemove));
                        } else return 'ERROR: One or more of the files was NOT prefixed with the prefix-path!';
                }
                return $fileArr;
        }

        function fixWindowsFilePath($theFile)   {
                return str_replace('//','/', str_replace('\\','/', $theFile));
        }

        function resolveBackPath($pathStr)      {
                $parts = explode('/',$pathStr);
                $output=array();
                foreach($parts as $pV)  {
                        if ($pV=='..')  {
                                if ($c) {
                                        array_pop($output);
                                        $c--;
                                } else $output[]=$pV;
                        } else {
                                $c++;
                                $output[]=$pV;
                        }
                }
                return implode('/',$output);
        }

        function locationHeaderUrl($path)       {
                $uI = parse_url($path);
                if (substr($path,0,1)=='/')     { // relative to HOST
                        $path = t3lib_div::getIndpEnv('TYPO3_REQUEST_HOST').$path;
                } elseif (!$uI['scheme'])       { // No scheme either
                        $path = t3lib_div::getIndpEnv('TYPO3_REQUEST_DIR').$path;
                }
                return $path;
        }
















        /*************************
         *
         * DEBUG helper FUNCTIONS
         *
         *************************/

        function debug_ordvalue($string,$characters=100)        {
                if(strlen($string) < $characters)       $characters = strlen($string);
                for ($i=0; $i<$characters; $i++)        {
                        $valuestring.=' '.ord(substr($string,$i,1));
                }
                return trim($valuestring);
        }

        function view_array($array_in)  {
                if (is_array($array_in))        {
                        $result='<table border="1" cellpadding="1" cellspacing="0" bgcolor="white">';
                        if (!count($array_in))  {$result.= '<tr><td><font face="Verdana,Arial" size="1"><b>'.htmlspecialchars("EMPTY!").'</b></font></td></tr>';}
                        while (list($key,$val)=each($array_in)) {
                                $result.= '<tr><td><font face="Verdana,Arial" size="1">'.htmlspecialchars((string)$key).'</font></td><td>';
                                if (is_array($array_in[$key]))  {
                                        $result.=t3lib_div::view_array($array_in[$key]);
                                } else
                                        $result.= '<font face="Verdana,Arial" size="1" color="red">'.nl2br(htmlspecialchars((string)$val)).'<br /></font>';
                                $result.= '</td></tr>';
                        }
                        $result.= '</table>';
                } else  {
                        $result  = false;
                }
                return $result;
        }

        function print_array($array_in) {
                echo t3lib_div::view_array($array_in);
        }

        function debug($var="",$brOrHeader=0)   {
                if ($brOrHeader && !t3lib_div::testInt($brOrHeader)) {
                        echo '<table border="0" cellpadding="0" cellspacing="0" bgcolor="white" style="border:0px; margin-top:3px; margin-bottom:3px;"><tr><td style="background-color:#bbbbbb; font-family: verdana,arial; font-weight: bold; font-size: 10px;">'.htmlspecialchars((string)$brOrHeader).'</td></tr><td>';
                } elseif ($brOrHeader<0) {
                        for($a=0;$a<abs(intval($brOrHeader));$a++){echo '<br />';}
                }

                if (is_array($var))     {
                        t3lib_div::print_array($var);
                } elseif (is_object($var))      {
                        echo '<b>|Object:<pre>';
                        print_r($var);
                        echo '</pre>|</b>';
                } elseif ((string)$var!='') {
                        echo '<b>|'.htmlspecialchars((string)$var).'|</b>';
                } else {
                        echo '<b>| debug |</b>';
                }

                if ($brOrHeader && !t3lib_div::testInt($brOrHeader)) {
                        echo '</td></tr></table>';
                } elseif ($brOrHeader>0) {
                        for($a=0;$a<intval($brOrHeader);$a++){echo '<br />';}
                }
        }
































        /*************************
         *
         * SYSTEM INFORMATION
         *
         *************************/

        function getThisUrl()   {
                $p=parse_url(t3lib_div::getIndpEnv('TYPO3_REQUEST_SCRIPT'));            // Url of this script
                $dir=t3lib_div::dirname($p['path']).'/';        // Strip file
                $url = str_replace('//','/',$p['host'].($p['port']?':'.$p['port']:'').$dir);
                return $url;
        }

        function linkThisScript($getParams=array())     {
                $parts = t3lib_div::getIndpEnv('SCRIPT_NAME');
                $params = t3lib_div::_GET();

                foreach($getParams as $k => $v) {
                        if (strcmp($v,''))      {
                                $params[$k]=$v;
                        } else unset($params[$k]);
                }

                $pString = t3lib_div::implodeArrayForUrl('',$params);

                return $pString ? $parts.'?'.ereg_replace('^&','',$pString) : $parts;
        }

        function linkThisUrl($url,$getParams=array())   {
                $parts = parse_url($url);
                if ($parts['query'])    {
                        parse_str($parts['query'],$getP);
                } else {
                        $getP = array();
                }

                $getP = t3lib_div::array_merge_recursive_overrule($getP,$getParams);
                $uP = explode('?',$url);

                $params = t3lib_div::implodeArrayForUrl('',$getP);
                $outurl = $uP[0].($params ? '?'.substr($params, 1) : '');

                return $outurl;
        }

        function getIndpEnv($getEnvName)        {
                /*
                        Conventions:
                        output from parse_url():
                        URL:    http://username:password@192.168.1.4:8080/typo3/32/temp/phpcheck/index.php/arg1/arg2/arg3/?arg1,arg2,arg3&p1=parameter1&p2[key]=value#link1
                            [scheme] => 'http'
                            [user] => 'username'
                            [pass] => 'password'
                            [host] => '192.168.1.4'
                                [port] => '8080'
                            [path] => '/typo3/32/temp/phpcheck/index.php/arg1/arg2/arg3/'
                            [query] => 'arg1,arg2,arg3&p1=parameter1&p2[key]=value'
                            [fragment] => 'link1'

                                Further definition: [path_script] = '/typo3/32/temp/phpcheck/index.php'
                                                                        [path_dir] = '/typo3/32/temp/phpcheck/'
                                                                        [path_info] = '/arg1/arg2/arg3/'
                                                                        [path] = [path_script/path_dir][path_info]


                        Keys supported:

                        URI______:
                                REQUEST_URI             =       [path]?[query]          = /typo3/32/temp/phpcheck/index.php/arg1/arg2/arg3/?arg1,arg2,arg3&p1=parameter1&p2[key]=value
                                HTTP_HOST               =       [host][:[port]]         = 192.168.1.4:8080
                                SCRIPT_NAME             =       [path_script]++         = /typo3/32/temp/phpcheck/index.php             // NOTICE THAT SCRIPT_NAME will return the php-script name ALSO. [path_script] may not do that (eg. '/somedir/' may result in SCRIPT_NAME '/somedir/index.php')!
                                PATH_INFO               =       [path_info]                     = /arg1/arg2/arg3/
                                QUERY_STRING    =       [query]                         = arg1,arg2,arg3&p1=parameter1&p2[key]=value
                                HTTP_REFERER    =       [scheme]://[host][:[port]][path]        = http://192.168.1.4:8080/typo3/32/temp/phpcheck/index.php/arg1/arg2/arg3/?arg1,arg2,arg3&p1=parameter1&p2[key]=value
                                                                                (Notice: NO username/password + NO fragment)

                        CLIENT____:
                                REMOTE_ADDR             =       (client IP)
                                REMOTE_HOST             =       (client host)
                                HTTP_USER_AGENT =       (client user agent)
                                HTTP_ACCEPT_LANGUAGE    = (client accept language)

                        SERVER____:
                                SCRIPT_FILENAME =       Absolute filename of script             (Differs between windows/unix). On windows 'C:\\blabla\\blabl\\' will be converted to 'C:/blabla/blabl/'

                        Special extras:
                                TYPO3_HOST_ONLY =               [host]                  = 192.168.1.4
                                TYPO3_PORT              =               [port]                  = 8080 (blank if 80, taken from host value)
                                TYPO3_REQUEST_HOST =    [scheme]://[host][:[port]]
                                TYPO3_REQUEST_URL =             [scheme]://[host][:[port]][path]?[query]        (sheme will by default be 'http' until we can detect if it's https -
                                TYPO3_REQUEST_SCRIPT =  [scheme]://[host][:[port]][path_script]
                                TYPO3_REQUEST_DIR =             [scheme]://[host][:[port]][path_dir]
                                TYPO3_SITE_URL =                [scheme]://[host][:[port]][path_dir] of the TYPO3 website frontend
                                TYPO3_SITE_SCRIPT =     [script / Speaking URL] of the TYPO3 website
                                TYPO3_DOCUMENT_ROOT     =       Absolute path of root of documents:     TYPO3_DOCUMENT_ROOT.SCRIPT_NAME = SCRIPT_FILENAME (typically)

                        Notice: [fragment] is apparently NEVER available to the script!


                        Testing suggestions:
                        - Output all the values.
                        - In the script, make a link to the script it self, maybe add some parameters and click the link a few times so HTTP_REFERER is seen
                        - ALSO TRY the script from the ROOT of a site (like 'http://www.mytest.com/' and not 'http://www.mytest.com/test/' !!)

                */

#               if ($getEnvName=='HTTP_REFERER')        return '';
                switch((string)$getEnvName)     {
                        case 'SCRIPT_NAME':
                                return (php_sapi_name()=='cgi'||php_sapi_name()=='cgi-fcgi')&&($_SERVER['ORIG_PATH_INFO']?$_SERVER['ORIG_PATH_INFO']:$_SERVER['PATH_INFO']) ? ($_SERVER['ORIG_PATH_INFO']?$_SERVER['ORIG_PATH_INFO']:$_SERVER['PATH_INFO']) : ($_SERVER['ORIG_SCRIPT_NAME']?$_SERVER['ORIG_SCRIPT_NAME']:$_SERVER['SCRIPT_NAME']);
                        break;
                        case 'SCRIPT_FILENAME':
                                return str_replace('//','/', str_replace('\\','/', (php_sapi_name()=='cgi'||php_sapi_name()=='isapi' ||php_sapi_name()=='cgi-fcgi')&&($_SERVER['ORIG_PATH_TRANSLATED']?$_SERVER['ORIG_PATH_TRANSLATED']:$_SERVER['PATH_TRANSLATED'])? ($_SERVER['ORIG_PATH_TRANSLATED']?$_SERVER['ORIG_PATH_TRANSLATED']:$_SERVER['PATH_TRANSLATED']):($_SERVER['ORIG_SCRIPT_FILENAME']?$_SERVER['ORIG_SCRIPT_FILENAME']:$_SERVER['SCRIPT_FILENAME'])));
                        break;
                        case 'REQUEST_URI':
                                // Typical application of REQUEST_URI is return urls, forms submitting to itselt etc. Eg:       returnUrl='.rawurlencode(t3lib_div::getIndpEnv('REQUEST_URI'))
                                if (!$_SERVER['REQUEST_URI'])   {       // This is for ISS/CGI which does not have the REQUEST_URI available.
                                        return '/'.ereg_replace('^/','',t3lib_div::getIndpEnv('SCRIPT_NAME')).
                                                ($_SERVER['QUERY_STRING']?'?'.$_SERVER['QUERY_STRING']:'');
                                } else return $_SERVER['REQUEST_URI'];
                        break;
                        case 'PATH_INFO':
                                        // $_SERVER['PATH_INFO']!=$_SERVER['SCRIPT_NAME'] is necessary because some servers (Windows/CGI) are seen to set PATH_INFO equal to script_name
                                        // Further, there must be at least one '/' in the path - else the PATH_INFO value does not make sense.
                                        // IF 'PATH_INFO' never works for our purpose in TYPO3 with CGI-servers, then 'php_sapi_name()=='cgi'' might be a better check. Right now strcmp($_SERVER['PATH_INFO'],t3lib_div::getIndpEnv('SCRIPT_NAME')) will always return false for CGI-versions, but that is only as long as SCRIPT_NAME is set equal to PATH_INFO because of php_sapi_name()=='cgi' (see above)
//                              if (strcmp($_SERVER['PATH_INFO'],t3lib_div::getIndpEnv('SCRIPT_NAME')) && count(explode('/',$_SERVER['PATH_INFO']))>1)  {
                                if (php_sapi_name()!='cgi'&&php_sapi_name()!='cgi-fcgi')        {
                                        return $_SERVER['PATH_INFO'];
                                } else return '';
                        break;
                                // These are let through without modification
                        case 'REMOTE_ADDR':
                        case 'REMOTE_HOST':
                        case 'HTTP_REFERER':
                        case 'HTTP_HOST':
                        case 'HTTP_USER_AGENT':
                        case 'HTTP_ACCEPT_LANGUAGE':
                        case 'QUERY_STRING':
                                return $_SERVER[$getEnvName];
                        break;
                        case 'TYPO3_DOCUMENT_ROOT':
                                // Some CGI-versions (LA13CGI) and mod-rewrite rules on MODULE versions will deliver a 'wrong' DOCUMENT_ROOT (according to our description). Further various aliases/mod_rewrite rules can disturb this as well.
                                // Therefore the DOCUMENT_ROOT is now always calculated as the SCRIPT_FILENAME minus the end part shared with SCRIPT_NAME.
                                $SFN = t3lib_div::getIndpEnv('SCRIPT_FILENAME');
                                $SN_A = explode('/',strrev(t3lib_div::getIndpEnv('SCRIPT_NAME')));
                                $SFN_A = explode('/',strrev($SFN));
                                $acc = array();
                                while(list($kk,$vv)=each($SN_A))        {
                                        if (!strcmp($SFN_A[$kk],$vv))   {
                                                $acc[] = $vv;
                                        } else break;
                                }
                                $commonEnd=strrev(implode('/',$acc));
                                if (strcmp($commonEnd,''))              $DR = substr($SFN,0,-(strlen($commonEnd)+1));
                                return $DR;
                        break;
                        case 'TYPO3_HOST_ONLY':
                                $p = explode(':',$_SERVER['HTTP_HOST']);
                                return $p[0];
                        break;
                        case 'TYPO3_PORT':
                                $p = explode(':',$_SERVER['HTTP_HOST']);
                                return $p[1];
                        break;
                        case 'TYPO3_REQUEST_HOST':
                                return (t3lib_div::getIndpEnv('TYPO3_SSL') ? 'https://' : 'http://').
                                        $_SERVER['HTTP_HOST'];
                        break;
                        case 'TYPO3_REQUEST_URL':
                                return t3lib_div::getIndpEnv('TYPO3_REQUEST_HOST').t3lib_div::getIndpEnv('REQUEST_URI');
                        break;
                        case 'TYPO3_REQUEST_SCRIPT':
                                return t3lib_div::getIndpEnv('TYPO3_REQUEST_HOST').t3lib_div::getIndpEnv('SCRIPT_NAME');
                        break;
                        case 'TYPO3_REQUEST_DIR':
                                return t3lib_div::getIndpEnv('TYPO3_REQUEST_HOST').t3lib_div::dirname(t3lib_div::getIndpEnv('SCRIPT_NAME')).'/';
                        break;
                        case 'TYPO3_SITE_URL':
                                if (defined('PATH_thisScript') && defined('PATH_site')) {
                                        $lPath = substr(dirname(PATH_thisScript),strlen(PATH_site)).'/';
                                        $url = t3lib_div::getIndpEnv('TYPO3_REQUEST_DIR');
                                        $siteUrl = substr($url,0,-strlen($lPath));
                                        if (substr($siteUrl,-1)!='/')   $siteUrl.='/';
                                        return $siteUrl;
                                } else return '';
                        break;
                        case 'TYPO3_SITE_SCRIPT':
                                return substr(t3lib_div::getIndpEnv('TYPO3_REQUEST_URL'),strlen(t3lib_div::getIndpEnv('TYPO3_SITE_URL')));
                        break;
                        case 'TYPO3_SSL':
                                return $_SERVER['SSL_SESSION_ID'] || !strcmp($_SERVER['HTTPS'],'on') ? TRUE : FALSE;
                        break;
                        case '_ARRAY':
                                $out = array();
                                        // Here, list ALL possible keys to this function for debug display.
                                $envTestVars = t3lib_div::trimExplode(',','
                                        HTTP_HOST,
                                        TYPO3_HOST_ONLY,
                                        TYPO3_PORT,
                                        PATH_INFO,
                                        QUERY_STRING,
                                        REQUEST_URI,
                                        HTTP_REFERER,
                                        TYPO3_REQUEST_HOST,
                                        TYPO3_REQUEST_URL,
                                        TYPO3_REQUEST_SCRIPT,
                                        TYPO3_REQUEST_DIR,
                                        TYPO3_SITE_URL,
                                        TYPO3_SITE_SCRIPT,
                                        TYPO3_SSL,
                                        SCRIPT_NAME,
                                        TYPO3_DOCUMENT_ROOT,
                                        SCRIPT_FILENAME,
                                        REMOTE_ADDR,
                                        REMOTE_HOST,
                                        HTTP_USER_AGENT,
                                        HTTP_ACCEPT_LANGUAGE',1);
                                reset($envTestVars);
                                while(list(,$v)=each($envTestVars))     {
                                        $out[$v]=t3lib_div::getIndpEnv($v);
                                }
                                reset($out);
                                return $out;
                        break;
                }
        }

        function milliseconds() {
                $p=explode(' ',microtime());
                return round(($p[0]+$p[1])*1000);
        }

        function clientInfo($useragent='')      {
                if (!$useragent) $useragent=t3lib_div::getIndpEnv('HTTP_USER_AGENT');

                $bInfo=array();
                        // Which browser?
                if (strstr($useragent,'Konqueror'))     {
                        $bInfo['BROWSER']= 'konqu';
                } elseif (strstr($useragent,'Opera'))   {
                        $bInfo['BROWSER']= 'opera';
                } elseif (strstr($useragent,'MSIE 4') || strstr($useragent,'MSIE 5') || strstr($useragent,'MSIE 6'))    {
                        $bInfo['BROWSER']= 'msie';
                } elseif (strstr($useragent,'Mozilla/4') || strstr($useragent,'Mozilla/5'))     {
                        $bInfo['BROWSER']='net';
                }
                if ($bInfo['BROWSER'])  {
                                // Browser version
                        switch($bInfo['BROWSER'])       {
                                case 'net':
                                        $bInfo['VERSION']= doubleval(substr($useragent,8));
                                        if (strstr($useragent,'Netscape6/')) {$bInfo['VERSION']=doubleval(substr(strstr($useragent,'Netscape6/'),10));}
                                        if (strstr($useragent,'Netscape/7')) {$bInfo['VERSION']=doubleval(substr(strstr($useragent,'Netscape/7'),9));}
                                break;
                                case 'msie':
                                        $tmp = strstr($useragent,'MSIE');
                                        $bInfo['VERSION'] = doubleval(ereg_replace('^[^0-9]*','',substr($tmp,4)));
                                break;
                                case 'opera':
                                        $tmp = strstr($useragent,'Opera');
                                        $bInfo['VERSION'] = doubleval(ereg_replace('^[^0-9]*','',substr($tmp,5)));
                                break;
                                case 'konqu':
                                        $tmp = strstr($useragent,'Konqueror/');
                                        $bInfo['VERSION'] = doubleval(substr($tmp,10));
                                break;
                        }
                                // Client system
                        if (strstr($useragent,'Win'))   {
                                $bInfo['SYSTEM'] = 'win';
                        } elseif (strstr($useragent,'Mac'))     {
                                $bInfo['SYSTEM'] = 'mac';
                        } elseif (strstr($useragent,'Linux') || strstr($useragent,'X11') || strstr($useragent,'SGI') || strstr($useragent,' SunOS ') || strstr($useragent,' HP-UX '))   {
                                $bInfo['SYSTEM'] = 'unix';
                        }
                }
                        // Is true if the browser supports css to format forms, especially the width
                $bInfo['FORMSTYLE']=($bInfo['BROWSER']=='msie' || ($bInfo['BROWSER']=='net'&&$bInfo['VERSION']>=5) || $bInfo['BROWSER']=='opera' || $bInfo['BROWSER']=='konqu');

                return $bInfo;
        }























        /*************************
         *
         * TYPO3 SPECIFIC FUNCTIONS
         *
         *************************/

        function getFileAbsFileName($filename,$onlyRelative=1,$relToTYPO3_mainDir=0)    {
                if (!strcmp($filename,''))              return '';

                if ($relToTYPO3_mainDir)        {
                        if (!defined('PATH_typo3'))     return '';
                        $relPathPrefix = PATH_typo3;
                } else {
                        $relPathPrefix = PATH_site;
                }
                if (substr($filename,0,4)=='EXT:')      {       // extension
                        list($extKey,$local) = explode('/',substr($filename,4),2);
                        $filename='';
                        if (strcmp($extKey,'') && t3lib_extMgm::isLoaded($extKey) && strcmp($local,'')) {
                                $filename = t3lib_extMgm::extPath($extKey).$local;
                        }
                } elseif (!t3lib_div::isAbsPath($filename))     {       // relative. Prepended with $relPathPrefix
                        $filename=$relPathPrefix.$filename;
                } elseif ($onlyRelative && !t3lib_div::isFirstPartOfStr($filename,$relPathPrefix)) {    // absolute, but set to blank if not allowed
                        $filename='';
                }
                if (strcmp($filename,'') && t3lib_div::validPathStr($filename)) {       // checks backpath.
                        return $filename;
                }
        }

        function validPathStr($theFile) {
                if (!strstr($theFile,'//') && !strstr($theFile,'..') && !strstr($theFile,'\\')) return true;
        }

        function isAbsPath($path)       {
                return TYPO3_OS=='WIN' ? substr($path,1,2)==':/' :  substr($path,0,1)=='/';
        }

        function isAllowedAbsPath($path)        {
                if (t3lib_div::isAbsPath($path) &&
                        t3lib_div::validPathStr($path) &&
                                (       t3lib_div::isFirstPartOfStr($path,PATH_site)
                                        ||
                                        ($GLOBALS['TYPO3_CONF_VARS']['BE']['lockRootPath'] && t3lib_div::isFirstPartOfStr($path,$GLOBALS['TYPO3_CONF_VARS']['BE']['lockRootPath']))
                                )
                        )       return true;
        }

        function verifyFilenameAgainstDenyPattern($filename)    {
                if (strcmp($filename,'') && strcmp($GLOBALS['TYPO3_CONF_VARS']['BE']['fileDenyPattern'],''))    {
                        $result = eregi($GLOBALS['TYPO3_CONF_VARS']['BE']['fileDenyPattern'],$filename);
                        if ($result)    return false;   // so if a matching filename is found, return false;
                }
                return true;
        }

        function upload_copy_move($source,$destination) {
                if (is_uploaded_file($source))  {
                        $uploaded = TRUE;
                        // Return the value of move_uploaded_file, and if false the temporary $source is still around so the user can use unlink to delete it:
                        $uploadedResult = move_uploaded_file($source, $destination);
                } else {
                        $uploaded = FALSE;
                        @copy($source,$destination);
                }

                        // Setting file system mode & group ownership of file:
                if (@is_file($destination) && TYPO3_OS!='WIN')  {
                        chmod($destination, octdec($GLOBALS['TYPO3_CONF_VARS']['BE']['fileCreateMask']));
                        if($GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup'])    {       // skip this if createGroup is empty
                                chgrp($destination, $GLOBALS['TYPO3_CONF_VARS']['BE']['createGroup']);
                        }
                }

                        // If here the file is copied and the temporary $source is still around, so when returning false the user can try unlink to delete the $source
                return $uploaded ? $uploadedResult : FALSE;
        }

        function upload_to_tempfile($uploadedFileName)  {
                if (is_uploaded_file($uploadedFileName))        {
                        $tempFile = t3lib_div::tempnam('upload_temp_');
                        move_uploaded_file($uploadedFileName, $tempFile);
                        return @is_file($tempFile) ? $tempFile : '';
                }
        }

        function unlink_tempfile($uploadedTempFileName) {
                if ($uploadedTempFileName && t3lib_div::validPathStr($uploadedTempFileName) && t3lib_div::isFirstPartOfStr($uploadedTempFileName,PATH_site.'typo3temp/') && @is_file($uploadedTempFileName))    {
                        if (unlink($uploadedTempFileName))      return TRUE;
                }
        }

        function tempnam($filePrefix)   {
                return tempnam(PATH_site.'typo3temp/',$filePrefix);
        }

        function stdAuthCode($uid_or_record,$fields='') {
                if (is_array($uid_or_record))   {
                        $recCopy_temp=array();
                        if ($fields)    {
                                $fieldArr = t3lib_div::trimExplode(',',$fields,1);
                                reset($fieldArr);
                                while(list($k,$v)=each($fieldArr))      {
                                        $recCopy_temp[$k]=$recCopy[$v];
                                }
                        } else {
                                $recCopy_temp=$recCopy;
                        }
                        $preKey = implode('|',$recCopy_temp);
                } else {
                        $preKey = $uid_or_record;
                }

                $authCode = $preKey.'||'.$GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'];
                $authCode = substr(md5($authCode),0,8);
                return $authCode;
        }

        function loadTCA($table)        {
                global $TCA,$LANG_GENERAL_LABELS;
                if (isset($TCA[$table]) && !is_array($TCA[$table]['columns']) && $TCA[$table]['ctrl']['dynamicConfigFile'])     {
                        if (!strcmp(substr($TCA[$table]['ctrl']['dynamicConfigFile'],0,6),'T3LIB:'))    {
                                include(PATH_t3lib.'stddb/'.substr($TCA[$table]['ctrl']['dynamicConfigFile'],6));
                        } elseif (t3lib_div::isAbsPath($TCA[$table]['ctrl']['dynamicConfigFile']) && @is_file($TCA[$table]['ctrl']['dynamicConfigFile']))       {       // Absolute path...
                                include($TCA[$table]['ctrl']['dynamicConfigFile']);
                        } else include(PATH_typo3conf.$TCA[$table]['ctrl']['dynamicConfigFile']);
                }
        }

        function resolveSheetDefInDS($dataStructArray,$sheet='sDEF')    {
                if (is_array($dataStructArray['sheets']))       {
                        $singleSheet = FALSE;
                        if (!isset($dataStructArray['sheets'][$sheet])) {
                                $sheet='sDEF';
                        }
                        $dataStruct =  $dataStructArray['sheets'][$sheet];

                                // If not an array, but still set, then regard it as a relative reference to a file:
                        if ($dataStruct && !is_array($dataStruct))      {
                                $file = t3lib_div::getFileAbsFileName($dataStruct);
                                if ($file && @is_file($file))   {
                                        $dataStruct = t3lib_div::xml2array(t3lib_div::getUrl($file));
                                }
                        }
                } else {
                        $singleSheet = TRUE;
                        $dataStruct = $dataStructArray;
                        $sheet = 'sDEF';        // Default sheet
                }
                return array($dataStruct,$sheet,$singleSheet);
        }

        function resolveAllSheetsInDS($dataStructArray) {
                if (is_array($dataStructArray['sheets']))       {
                        $out=array('sheets'=>array());
                        foreach($dataStructArray['sheets'] as $sheetId => $sDat)        {
                                list($ds,$aS) = t3lib_div::resolveSheetDefInDS($dataStructArray,$sheetId);
                                if ($sheetId==$aS)      {
                                        $out['sheets'][$aS]=$ds;
                                }
                        }
                } else {
                        list($ds) = t3lib_div::resolveSheetDefInDS($dataStructArray);
                        $out = array('sheets' => array('sDEF' => $ds));
                }
                return $out;
        }

        function callUserFunction($funcName,&$params,&$ref,$checkPrefix='user_',$silent=0)      {
                global $TYPO3_CONF_VARS;

                        // Check persistent object and if found, call directly and exit.
                if (is_array($GLOBALS['T3_VAR']['callUserFunction'][$funcName]))        {
                        return call_user_method(
                                                $GLOBALS['T3_VAR']['callUserFunction'][$funcName]['method'],
                                                $GLOBALS['T3_VAR']['callUserFunction'][$funcName]['obj'],
                                                $params,
                                                $ref
                                        );
                }

                        // Check file-reference prefix; if found, require_once() the file (should be library of code)
                if (strstr($funcName,':'))      {
                        list($file,$funcRef) = t3lib_div::revExplode(':',$funcName,2);
                        $requireFile = t3lib_div::getFileAbsFileName($file);
                        if ($requireFile) require_once($requireFile);
                } else {
                        $funcRef = $funcName;
                }

                        // Check for persistent object token, "&"
                if (substr($funcRef,0,1)=='&')  {
                        $funcRef = substr($funcRef,1);
                        $storePersistentObject = TRUE;
                } else {
                        $storePersistentObject = FALSE;
                }

                        // Check prefix is valid:
                if ($checkPrefix &&
                        !t3lib_div::isFirstPartOfStr(trim($funcRef),$checkPrefix) &&
                        !t3lib_div::isFirstPartOfStr(trim($funcRef),'tx_')
                        )       {
                        if (!$silent)   debug("Function/Class '".$funcRef."' was not prepended with '".$checkPrefix."'",1);
                        return FALSE;
                }

                        // Call function or method:
                $parts = explode('->',$funcRef);
                if (count($parts)==2)   {       // Class

                                // Check if class/method exists:
                        if (class_exists($parts[0]))    {

                                        // Get/Create object of class:
                                if ($storePersistentObject)     {       // Get reference to current instance of class:
                                        if (!is_object($GLOBALS['T3_VAR']['callUserFunction_classPool'][$parts[0]]))    {
                                                $GLOBALS['T3_VAR']['callUserFunction_classPool'][$parts[0]] = &t3lib_div::makeInstance($parts[0]);
                                        }
                                        $classObj = &$GLOBALS['T3_VAR']['callUserFunction_classPool'][$parts[0]];
                                } else {        // Create new object:
                                        $classObj = &t3lib_div::makeInstance($parts[0]);
                                }

                                if (method_exists($classObj, $parts[1]))        {

                                                // If persistent object should be created, set reference:
                                        if ($storePersistentObject)     {
                                                $GLOBALS['T3_VAR']['callUserFunction'][$funcName] = array (
                                                        'method' => $parts[1],
                                                        'obj' => &$classObj
                                                );
                                        }
                                                // Call method:
                                        $content = call_user_method(
                                                $parts[1],
                                                $classObj,
                                                $params,
                                                $ref
                                        );
                                } else {
                                        if (!$silent)   debug("<strong>ERROR:</strong> No method name '".$parts[1]."' in class ".$parts[0],1);
                                }
                        } else {
                                if (!$silent)   debug("<strong>ERROR:</strong> No class named: ".$parts[0],1);
                        }
                } else {        // Function
                        if (function_exists($funcRef))  {
                                $content = call_user_func($funcRef, $params, $ref);
                        } else {
                                if (!$silent)   debug("<strong>ERROR:</strong> No function named: ".$funcRef,1);
                        }
                }
                return $content;
        }

        function &getUserObj($classRef,$checkPrefix='user_',$silent=0)  {
                global $TYPO3_CONF_VARS;
                        // Check persistent object and if found, call directly and exit.
                if (is_object($GLOBALS['T3_VAR']['getUserObj'][$classRef]))     {
                        return $GLOBALS['T3_VAR']['getUserObj'][$classRef];
                } else {

                                // Check file-reference prefix; if found, require_once() the file (should be library of code)
                        if (strstr($classRef,':'))      {
                                list($file,$class) = t3lib_div::revExplode(':',$classRef,2);
                                $requireFile = t3lib_div::getFileAbsFileName($file);
                                if ($requireFile)       require_once($requireFile);
                        } else {
                                $class = $classRef;
                        }

                                // Check for persistent object token, "&"
                        if (substr($class,0,1)=='&')    {
                                $class = substr($class,1);
                                $storePersistentObject = TRUE;
                        } else {
                                $storePersistentObject = FALSE;
                        }

                                // Check prefix is valid:
                        if ($checkPrefix &&
                                !t3lib_div::isFirstPartOfStr(trim($class),$checkPrefix) &&
                                !t3lib_div::isFirstPartOfStr(trim($class),'tx_')
                                )       {
                                if (!$silent)   debug("Class '".$class."' was not prepended with '".$checkPrefix."'",1);
                                return FALSE;
                        }

                                // Check if class exists:
                        if (class_exists($class))       {
                                $classObj = &t3lib_div::makeInstance($class);

                                        // If persistent object should be created, set reference:
                                if ($storePersistentObject)     {
                                        $GLOBALS['T3_VAR']['getUserObj'][$classRef] = &$classObj;
                                }

                                return $classObj;
                        } else {
                                if (!$silent)   debug("<strong>ERROR:</strong> No class named: ".$class,1);
                        }
                }
        }

        function &makeInstance($className)      {
                return class_exists('ux_'.$className) ? t3lib_div::makeInstance('ux_'.$className) : new $className;
        }

        function makeInstanceClassName($className)      {
                return class_exists('ux_'.$className) ? t3lib_div::makeInstanceClassName('ux_'.$className) : $className;
        }

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

                $error = FALSE;

                if (!is_array($excludeServiceKeys) ) {
                        $excludeServiceKeys = t3lib_div::trimExplode(',', $excludeServiceKeys, 1);
                }
                while ($info = t3lib_extMgm::findService($serviceType, $serviceSubType, $excludeServiceKeys))   {

                                // Check persistent object and if found, call directly and exit.
                        if (is_object($GLOBALS['T3_VAR']['makeInstanceService'][$info['className']]))   {
                                        // reset service and return object
                                $T3_VAR['makeInstanceService'][$info['className']]->reset();
                                return $GLOBALS['T3_VAR']['makeInstanceService'][$info['className']];

                                // include file and create object
                        } elseif (@is_file($info['classFile'])) {
                                require_once ($info['classFile']);
                                $obj = t3lib_div::makeInstance($info['className']);
                                if (is_object($obj)) {
                                        if(!@is_callable(array($obj,'init')))   {
                                                        // use silent logging??? I don't think so.
                                                die ('Broken service:'.t3lib_div::view_array($info));
                                        }
                                        $obj->info = $info;
                                        if ($obj->init()) { // service available?

                                                        // create persistent object
                                                $T3_VAR['makeInstanceService'][$info['className']] = &$obj;

                                                        // needed to delete temp files
                                                register_shutdown_function(array(&$obj, '__destruct'));

                                                return $obj; // object is passed as reference by funtion definition
                                        }
                                        $error = $obj->getLastErrorArray();
                                        unset($obj);
                                }
                        }
                                // deactivate the service
                        t3lib_extMgm::deactivateService($info['serviceType'],$info['serviceKey']);
                }
                return $error;
        }

        function plainMailEncoded($email,$subject,$message,$headers='',$enc='',$charset='ISO-8859-1',$dontEncodeSubject=0)      {
                switch((string)$enc)    {
                        case 'base64':
                                $headers=trim($headers).chr(10).
                                'Mime-Version: 1.0'.chr(10).
                                'Content-Type: text/plain; charset="'.$charset.'"'.chr(10).
                                'Content-Transfer-Encoding: base64';

                                $message=trim(chunk_split(base64_encode($message.chr(10)))).chr(10);    // Adding chr(10) because I think MS outlook 2002 wants it... may be removed later again.

                                if (!$dontEncodeSubject)        $subject='=?'.$charset.'?B?'.base64_encode($subject).'?=';
                        break;
                        case 'quoted-printable':
                                $headers=trim($headers).chr(10).
                                'Mime-Version: 1.0'.chr(10).
                                'Content-Type: text/plain; charset="'.$charset.'"'.chr(10).
                                'Content-Transfer-Encoding: quoted-printable';

                                $message=t3lib_div::quoted_printable($message);

                                if (!$dontEncodeSubject)        $subject='=?'.$charset.'?Q?'.trim(t3lib_div::quoted_printable(ereg_replace('[[:space:]]','_',$subject),1000)).'?=';
                        break;
                        case '8bit':
                                $headers=trim($headers).chr(10).
                                'Mime-Version: 1.0'.chr(10).
                                'Content-Type: text/plain; charset="'.$charset.'"'.chr(10).
                                'Content-Transfer-Encoding: 8bit';
                        break;
                }
                $headers=trim(implode(chr(10),t3lib_div::trimExplode(chr(10),$headers,1)));     // make sure no empty lines are there.

                mail($email,$subject,$message,$headers);
        }

        function quoted_printable($string,$maxlen=76)   {
                $newString = '';
                $theLines = explode(chr(10),$string);   // Break lines. Doesn't work with mac eol's which seems to be 13. But 13-10 or 10 will work
                while (list(,$val)=each($theLines))     {
                        $val = ereg_replace(chr(13).'$','',$val);               // removes possible character 13 at the end of line

                        $newVal = '';
                        $theValLen = strlen($val);
                        $len = 0;
                        for ($index=0;$index<$theValLen;$index++)       {
                                $char = substr($val,$index,1);
                                $ordVal =Ord($char);
                                if ($len>($maxlen-4) || ($len>(($maxlen-10)-4)&&$ordVal==32))   {
                                        $len=0;
                                        $newVal.='='.chr(13).chr(10);
                                }
                                if (($ordVal>=33 && $ordVal<=60) || ($ordVal>=62 && $ordVal<=126) || $ordVal==9 || $ordVal==32) {
                                        $newVal.=$char;
                                        $len++;
                                } else {
                                        $newVal.=sprintf('=%02X',$ordVal);
                                        $len+=3;
                                }
                        }
                        $newVal = ereg_replace(chr(32).'$','=20',$newVal);              // replaces a possible SPACE-character at the end of a line
                        $newVal = ereg_replace(chr(9).'$','=09',$newVal);               // replaces a possible TAB-character at the end of a line
                        $newString.=$newVal.chr(13).chr(10);
                }
                return ereg_replace(chr(13).chr(10).'$','',$newString);
        }

        function substUrlsInPlainText($message,$urlmode='76',$index_script_url='')      {
                        // Substitute URLs with shorter links:
                $urlSplit=explode('http://',$message);
                reset($urlSplit);
                while(list($c,$v)=each($urlSplit))      {
                        if ($c) {
                                $newParts = split('[[:space:]]|\)|\(',$v,2);
                                $newURL='http://'.$newParts[0];
                                        switch((string)$urlmode)        {
                                                case 'all':
                                                        $newURL=t3lib_div::makeRedirectUrl($newURL,0,$index_script_url);
                                                break;
                                                case '76':
                                                        $newURL=t3lib_div::makeRedirectUrl($newURL,76,$index_script_url);
                                                break;
                                        }
                                $urlSplit[$c]=$newURL.substr($v,strlen($newParts[0]));
                        }
                }

                $message=implode('',$urlSplit);
                return $message;
        }

        function makeRedirectUrl($inUrl,$l=0,$index_script_url='')      {
                if (strlen($inUrl)>$l)  {
                        $md5 = substr(md5($inUrl),0,20);
                        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('md5hash', 'cache_md5params', 'md5hash="'.$GLOBALS['TYPO3_DB']->quoteStr($md5, 'cache_md5params').'"');
                        if (!$GLOBALS['TYPO3_DB']->sql_num_rows($res))  {
                                $insertFields = array(
                                        'md5hash' => $md5,
                                        'tstamp' => time(),
                                        'type' => 2,
                                        'params' => $inUrl
                                );

                                $GLOBALS['TYPO3_DB']->exec_INSERTquery('cache_md5params', $insertFields);
                        }
                        $inUrl=($index_script_url ? $index_script_url : t3lib_div::getIndpEnv('TYPO3_REQUEST_DIR')).
                                '?RDCT='.$md5;
                }
                return $inUrl;
        }

        function freetypeDpiComp($font_size)    {
                $dpi = intval($GLOBALS['TYPO3_CONF_VARS']['GFX']['TTFdpi']);
                if ($dpi!=72)   $font_size = $font_size/$dpi*72;
                return $font_size;
        }

        function devLog($msg, $extKey, $severity=0, $dataVar=FALSE)     {
                global $TYPO3_CONF_VARS;

                if (is_array($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['devLog']))    {
                        $params = array('msg'=>$msg, 'extKey'=>$extKey, 'severity'=>$severity, 'dataVar'=>$dataVar);
                        $fakeThis = FALSE;
                        foreach($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['devLog'] as $hookMethod)   {
                                t3lib_div::callUserFunction($hookMethod,$params,$fakeThis);
                        }
                }
        }

        function arrayToLogString($arr, $valueList=array(), $valueLength=20) {
                $str = '';
                if(is_array($arr)) {
                        if (!is_array($valueList)) {
                                $valueList = explode(',', $valueList);
                        }
                        foreach($arr as $key => $value) {
                                if (!count($valueList) OR (count($valueList) AND in_array($key, $valueList))) {
                                        $str .= (string)$key.trim(': '.t3lib_div::fixed_lgd(str_replace("\n",'|',(string)$value), $valueLength)).'; ';
                                }
                        }
                }
                return $str;
        }
}

?>

---