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-2007 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) && $gfxConf['im'] && $gfxConf['im_path_lzw'])       {       // IM
                                $cmd = t3lib_div::imageMagickCommand('convert', '"'.$theFile.'" "'.$theFile.'"', $gfxConf['im_path_lzw']);
                                exec($cmd);

                                $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';
                                $cmd = t3lib_div::imageMagickCommand('convert', '"'.$theFile.'" "'.$newFile.'"', $GLOBALS['TYPO3_CONF_VARS']['GFX']['im_path_lzw']);
                                exec($cmd);
                                $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[] = 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)  {
                if ($list==='*')        return TRUE;
                if (strstr($baseIP, ':') && t3lib_div::validIPv6($baseIP))      {
                        return t3lib_div::cmpIPv6($baseIP, $list);
                } else {
                        return t3lib_div::cmpIPv4($baseIP, $list);
                }
        }

        function cmpIPv4($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 cmpIPv6($baseIP, $list)        {
                $success = false;       // Policy default: Deny connection
                $baseIP = t3lib_div::normalizeIPv6($baseIP);

                $values = t3lib_div::trimExplode(',',$list,1);
                foreach ($values as $test)      {
                        list($test,$mask) = explode('/',$test);
                        if (t3lib_div::validIPv6($test))        {
                                $test = t3lib_div::normalizeIPv6($test);
                                if (intval($mask))      {
                                        switch ($mask) {        // test on /48 /64
                                                case '48':
                                                        $testBin = substr(t3lib_div::IPv6Hex2Bin($test), 0, 48);
                                                        $baseIPBin = substr(t3lib_div::IPv6Hex2Bin($baseIP), 0, 48);
                                                        $success = strcmp($testBin, $baseIPBin)==0 ? true : false;
                                                break;
                                                case '64':
                                                        $testBin = substr(t3lib_div::IPv6Hex2Bin($test), 0, 64);
                                                        $baseIPBin = substr(t3lib_div::IPv6Hex2Bin($baseIP), 0, 64);
                                                        $success = strcmp($testBin, $baseIPBin)==0 ? true : false;
                                                break;
                                                default:
                                                        $success = false;
                                        }
                                } else {
                                        if (t3lib_div::validIPv6($test))        {       // test on full ip address 128 bits
                                                $testBin = t3lib_div::IPv6Hex2Bin($test);
                                                $baseIPBin = t3lib_div::IPv6Hex2Bin($baseIP);
                                                $success = strcmp($testBin, $baseIPBin)==0 ? true : false;
                                        }
                                }
                        }
                        if ($success) return true;
                }
                return false;
        }

        function IPv6Hex2Bin ($hex)     {
                $bin = '';
                $hex = str_replace(':', '', $hex);      // Replace colon to nothing
                for ($i=0; $i<strlen($hex); $i=$i+2)    {
                        $bin.= chr(hexdec(substr($hex, $i, 2)));
                }
                return $bin;
        }

        function normalizeIPv6($address)        {
                $normalizedAddress = '';
                $stageOneAddress = '';

                $chunks = explode('::', $address);      // Count 2 if if address has hidden zero blocks
                if (count($chunks)==2)  {
                        $chunksLeft = explode(':', $chunks[0]);
                        $chunksRight = explode(':', $chunks[1]);
                        $left = count($chunksLeft);
                        $right = count($chunksRight);

                                // Special case: leading zero-only blocks count to 1, should be 0
                        if ($left==1 && strlen($chunksLeft[0])==0)      $left=0;

                        $hiddenBlocks = 8 - ($left + $right);
                        $hiddenPart = '';
                        while ($h<$hiddenBlocks)        {
                                $hiddenPart .= '0000:';
                                $h++;
                        }

                        if ($left == 0) {
                                $stageOneAddress = $hiddenPart . $chunks[1];
                        } else {
                                $stageOneAddress = $chunks[0] . ':' . $hiddenPart . $chunks[1];
                        }
                } else $stageOneAddress = $address;

                        // normalize the blocks:
                $blocks = explode(':', $stageOneAddress);
                $divCounter = 0;
                foreach ($blocks as $block)     {
                        $tmpBlock = '';
                        $i = 0;
                        $hiddenZeros = 4 - strlen($block);
                        while ($i < $hiddenZeros)       {
                                $tmpBlock .= '0';
                                $i++;
                        }
                        $normalizedAddress .= $tmpBlock . $block;
                        if ($divCounter < 7)    {
                                $normalizedAddress .= ':';
                                $divCounter++;
                        }
                }
                return $normalizedAddress;
        }

        function validIPv6($ip) {
                $uppercaseIP = strtoupper($ip);

                $regex = '/^(';
                $regex.= '(([\dA-F]{1,4}:){7}[\dA-F]{1,4})|';
                $regex.= '(([\dA-F]{1,4}){1}::([\dA-F]{1,4}:){1,5}[\dA-F]{1,4})|';
                $regex.= '(([\dA-F]{1,4}:){2}:([\dA-F]{1,4}:){1,4}[\dA-F]{1,4})|';
                $regex.= '(([\dA-F]{1,4}:){3}:([\dA-F]{1,4}:){1,3}[\dA-F]{1,4})|';
                $regex.= '(([\dA-F]{1,4}:){4}:([\dA-F]{1,4}:){1,2}[\dA-F]{1,4})|';
                $regex.= '(([\dA-F]{1,4}:){5}:([\dA-F]{1,4}:){0,1}[\dA-F]{1,4})|';
                $regex.= '(::([\dA-F]{1,4}:){0,6}[\dA-F]{1,4})';
                $regex.= ')$/';

                return preg_match($regex, $uppercaseIP) ? true : 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($list,$item)    {
                return strstr(','.$list.',', ','.$item.',') ? true : false;
        }

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

        function expandList($list)      {
                $items = explode(',',$list);
                $list = array();
                while(list(,$item)=each($items))        {
                        $range = explode('-',$item);
                        if (isset($range[1]))   {
                                $runAwayBrake = 1000;
                                for ($n=$range[0]; $n<=$range[1]; $n++) {
                                        $list[] = $n;

                                        $runAwayBrake--;
                                        if ($runAwayBrake<=0)   break;
                                }
                        } else {
                                $list[] = $item;
                        }
                }

                return implode(',',$list);
        }

        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 compat_version($verNumberStr)  {
                global $TYPO3_CONF_VARS;
                $currVersionStr = $TYPO3_CONF_VARS['SYS']['compat_version'] ? $TYPO3_CONF_VARS['SYS']['compat_version'] : TYPO3_branch;

                if (t3lib_div::int_from_ver($currVersionStr) < t3lib_div::int_from_ver($verNumberStr))  {
                        return FALSE;
                } else {
                        return TRUE;
                }
        }

        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)        {
                $reg = array();
                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:
                $reg = array();
                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);
                                        }
                                }
                        }
                }
                return $str;
        }

        function explodeUrl2Array($string,$multidim=FALSE)      {
                $output = array();
                if ($multidim)  {
                        parse_str($string,$output);
                } else {
                        $p = explode('&',$string);
                        foreach($p as $v)       {
                                if (strlen($v)) {
                                        list($pK,$pV) = explode('=',$v,2);
                                        $output[rawurldecode($pK)] = rawurldecode($pV);
                                }
                        }
                }
                return $output;
        }

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

        function removeDotsFromTS($ts) {
                $out = array();
                if (is_array($ts)) {
                        foreach ($ts as $key => $value) {
                                if (is_array($value)) {
                                        $key = rtrim($key, '.');
                                        $out[$key] = t3lib_div::removeDotsFromTS($value);
                                } else {
                                        $out[$key] = $value;
                                }
                        }
                }
                return $out;
        }
















        /*************************
         *
         * 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
                        $match = array();
                        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;

// FIXME don't use unset() - what does that mean? Use NULL or similar.
                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_cs($array,$docTag='phparray',$options=array(),$charset='')   {

                        // Figure out charset if not given explicitly:
                if (!$charset)  {
                        if ($GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset'])  {       // First priority: forceCharset! If set, this will be authoritative!
                                $charset = $GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset'];
                        } elseif (is_object($GLOBALS['LANG']))  {
                                $charset = $GLOBALS['LANG']->charSet;   // If "LANG" is around, that will hold the current charset
                        } else {
                                $charset = 'iso-8859-1';        // THIS is just a hopeful guess!
                        }
                }

                        // Return XML:
                return '<?xml version="1.0" encoding="'.htmlspecialchars($charset).'" standalone="yes" ?>'.chr(10).
                                t3lib_div::array2xml($array,'',0,$docTag,0, $options);
        }

        function array2xml($array,$NSprefix='',$level=0,$docTag='phparray',$spaceInd=0, $options=array(),$stackData=array())    {
                        // 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;
                $nl = ($spaceInd >= 0 ? chr(10) : '');

                        // 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(isset($options['grandParentTagMap'][$stackData['grandParentTagName'].'/'.$stackData['parentTagName']])) {            // Use tag based on grand-parent + parent tag name
                                        $attr.=' index="'.htmlspecialchars($tagName).'"';
                                        $tagName = (string)$options['grandParentTagMap'][$stackData['grandParentTagName'].'/'.$stackData['parentTagName']];
                                }elseif(isset($options['parentTagMap'][$stackData['parentTagName'].':_IS_NUM']) && t3lib_div::testInt($tagName)) {              // Use tag based on parent tag name + if current tag is numeric
                                        $attr.=' index="'.htmlspecialchars($tagName).'"';
                                        $tagName = (string)$options['parentTagMap'][$stackData['parentTagName'].':_IS_NUM'];
                                }elseif(isset($options['parentTagMap'][$stackData['parentTagName'].':'.$tagName])) {            // Use tag based on parent tag name + current tag
                                        $attr.=' index="'.htmlspecialchars($tagName).'"';
                                        $tagName = (string)$options['parentTagMap'][$stackData['parentTagName'].':'.$tagName];
                                } elseif(isset($options['parentTagMap'][$stackData['parentTagName']])) {                // Use tag based on parent tag name:
                                        $attr.=' index="'.htmlspecialchars($tagName).'"';
                                        $tagName = (string)$options['parentTagMap'][$stackData['parentTagName']];
                                } elseif (!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'];
                                }

                                        // 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:
                                        if ($options['alt_options'][$stackData['path'].'/'.$tagName])   {
                                                $subOptions = $options['alt_options'][$stackData['path'].'/'.$tagName];
                                                $clearStackPath = $subOptions['clearStackPath'];
                                        } else {
                                                $subOptions = $options;
                                                $clearStackPath = FALSE;
                                        }

                                        $content = $nl .
                                                                t3lib_div::array2xml(
                                                                        $v,
                                                                        $NSprefix,
                                                                        $level+1,
                                                                        '',
                                                                        $spaceInd,
                                                                        $subOptions,
                                                                        array(
                                                                                'parentTagName' => $tagName,
                                                                                'grandParentTagName' => $stackData['parentTagName'],
                                                                                'path' => $clearStackPath ? '' : $stackData['path'].'/'.$tagName,
                                                                        )
                                                                ).
                                                                ($spaceInd >= 0 ? str_pad('',($level+1)*$indentN,$indentChar) : '');
                                        if ((int)$options['disableTypeAttrib']!=2)      {       // Do not set "type = array". Makes prettier XML but means that empty arrays are not restored with xml2array
                                                $attr.=' type="array"';
                                        }
                                } else {        // Just a value:

                                                // Look for binary chars:
                                        $vLen = strlen($v);     // check for length, because PHP 5.2.0 may crash when first argument of strcspn is empty
                                        if ($vLen && strcspn($v,$binaryChars) != $vLen) {       // 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 = $nl.chunk_split(base64_encode($v));
                                                $attr.=' base64="1"';
                                        } else {
                                                        // Otherwise, just htmlspecialchar the stuff:
                                                $content = htmlspecialchars($v);
                                                $dType = gettype($v);
                                                if ($dType == 'string') {
                                                        if ($options['useCDATA'] && $content != $v) {
                                                                $content = '<![CDATA[' . $v . ']]>';
                                                        }
                                                } elseif (!$options['disableTypeAttrib']) {
                                                        $attr.= ' type="'.$dType.'"';
                                                }
                                        }
                                }

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

                        // 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.'>'.$nl.
                                $output.
                                '</'.$docTag.'>';
                }

                return $output;
        }

        function xml2array($string,$NSprefix='',$reportDocTag=FALSE) {
                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);

                        //  PHP4 doesn't like Unicode byte order marks (BOM), so we have to check for them
                        // The BOM check comes first, so that the PHP5 preg_match() below doesn't have to check for it
                if(substr($string,0,3)=="\xEF\xBB\xBF") {
                        xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, 'utf-8');
                }
                        // PHP 4.x: output charset is the same as the input charset, charsets are handled transparently if not specified in xml_parser_create()
                        // PHP 5.0.0 & 5.0.1: default output charset is ISO-8859-1, only ASCII, ISO-8859-1 and UTF-8 are supported!!!
                        // PHP 5.0.2+: default output charset is UTF-8  , only ASCII, ISO-8859-1 and UTF-8 are supported!!!
                elseif ((double)phpversion()>=5)        {
                        $match = array();
                        preg_match('/^[[:space:]]*<\?xml[^>]*encoding[[:space:]]*=[[:space:]]*"([^"]*)"/',substr($string,0,200),$match);
                        $theCharset = $match[1] ? $match[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 = '';
                $documentTag = '';

                        // 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'];
                        if (!$documentTag)      $documentTag = $tagName;

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

                if ($reportDocTag)      {
                        $current[$tagName]['_DOCUMENT_TAG'] = $documentTag;
                }

                        // 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, $includeHeader = 0, $requestHeaders = false)      {
                $content = false;

                        // (Proxy support implemented by Arco <arco@appeltaart.mine.nu>)
                if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['curlUse'] == '1' && preg_match('/^https?:\/\//', $url)) {
                                // External URL without error checking.
                        $ch = curl_init();
                        if (!$ch)       {
                                return false;
                        }

                        curl_setopt($ch, CURLOPT_URL, $url);
                        curl_setopt($ch, CURLOPT_HEADER, $includeHeader ? 1 : 0);
                        curl_setopt($ch, CURLOPT_NOBODY, $includeHeader == 2 ? 1 : 0);
                        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
                        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
                        curl_setopt($ch, CURLOPT_FAILONERROR, 1);
                        if (is_array($requestHeaders))  {
                                curl_setopt($ch, CURLOPT_HTTPHEADER, $requestHeaders);
                        }

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

                                        // Not sure if this is 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);

                } elseif ($includeHeader)       {
                        $parsedURL = parse_url($url);
                        if (!t3lib_div::inList('ftp,ftps,http,https,gopher,telnet', $parsedURL['scheme']))      {
                                return false;
                        }

                        $fp = @fsockopen($parsedURL['host'], ($parsedURL['port'] > 0 ? $parsedURL['port'] : 80), $errno, $errstr, 2.0);
                        if (!$fp)       {
                                return false;
                        }

                        $msg = 'GET ' . $parsedURL['path'] .
                                        ($parsedURL['query'] ? '?' . $parsedURL['query'] : '') .
                                        ' HTTP/1.0' . "\r\n" . 'Host: ' .
                                        $parsedURL['host'] . "\r\n\r\n";
                        fputs($fp, $msg);
                        while (!feof($fp))      {
                                $line = fgets($fp, 2048);
                                $content.= $line;
                                if ($includeHeader == 2 && !strlen(trim($line)))        {
                                        break;  // Stop at the first empty line (= end of header)
                                }
                        }
                        fclose($fp);

                } elseif (is_array($requestHeaders))    {
                        $ctx = stream_context_create(array(
                                                'http' => array(
                                                        'header' => implode("\r\n", $requestHeaders)
                                                )
                                        )
                                );
                        if (version_compare(phpversion(), '5.0', '>=')) {
                                $content = @file_get_contents($url, false, $ctx);
                        }
                        elseif (false !== ($fd = @fopen($url, 'rb', false, $ctx)))      {
                                $content = '';
                                while (!feof($fd))      {
                                        $content.= @fread($fd, 4096);
                                }
                                fclose($fd);
                        }
                }
                else    {
                        $content = @file_get_contents($url);
                }

                return $content;
        }

        function writeFile($file,$content)      {
                if (!@is_file($file))   $changePermissions = true;

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

                        if ($res===false)       return false;

                        if ($changePermissions) {       // Change the permissions only if the file has just been created
                                t3lib_div::fixPermissions($file);
                        }

                        return true;
                }

                return false;
        }

        function fixPermissions($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
                        }
                }
        }

        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) || ereg('^[[:alnum:]_]+\/[[:alnum:]_]+\/$',$subdir))      {
                                                                $dirName.= $subdir;
                                                                if (!@is_dir($dirName)) {
                                                                        t3lib_div::mkdir_deep(PATH_site.'typo3temp/', $subdir);
                                                                }
                                                        } else return 'Subdir, "'.$subdir.'", was NOT on the form "[[:alnum:]_]/" or  "[[:alnum:]_]/[[:alnum:]_]/"';
                                                }
                                                        // 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 = preg_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 mkdir_deep($destination,$deepDir)      {
                $allParts = t3lib_div::trimExplode('/',$deepDir,1);
                $root = '';
                foreach($allParts as $part)     {
                        $root.= $part.'/';
                        if (!is_dir($destination.$root))        {
                                t3lib_div::mkdir($destination.$root);
                                if (!@is_dir($destination.$root))       {
                                        return 'Error: The directory "'.$destination.$root.'" could not be created...';
                                }
                        }
                }
        }

        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='',$excludePattern='')     {

                        // 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);   // Don't change this ever - extensions may depend on the fact that the hash is an md5 of the path! (import/export extension)
                                                if ((!strlen($extensionList) || t3lib_div::inList($extensionList,strtolower($fI['extension']))) && (!strlen($excludePattern) || !preg_match('/^'.$excludePattern.'$/',$entry))) {
                                                    $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,$excludePattern='')    {
                if ($regDirs)   $fileArr[] = $path;
                $fileArr = array_merge($fileArr, t3lib_div::getFilesInDir($path,$extList,1,1,$excludePattern));

                $dirs = t3lib_div::get_dirs($path);
                if (is_array($dirs) && $recursivityLevels>0)    {
                        foreach ($dirs as $subdirs)     {
                                if ((string)$subdirs!='' && (!strlen($excludePattern) || !preg_match('/^'.$excludePattern.'$/',$subdirs)))      {
                                        $fileArr = t3lib_div::getAllFilesAndFoldersInPath($fileArr,$path.$subdirs.'/',$extList,$regDirs,$recursivityLevels-1,$excludePattern);
                                }
                        }
                }
                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();
                $c = 0;
                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 valign="top"><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  = '<table border="1" cellpadding="1" cellspacing="0" bgcolor="white">
                                <tr>
                                        <td><font face="Verdana,Arial" size="1" color="red">'.nl2br(htmlspecialchars((string)$array_in)).'<br /></font></td>
                                </tr>
                        </table>';      // Output it as a string.
                }
                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 class="typo3-debug" 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><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 />';}
                }
        }

        function debug_trail()  {
                $trail = debug_backtrace();
                $trail = array_reverse($trail);
                array_pop($trail);

                $path = array();
                foreach($trail as $dat) {
                        $path[] = $dat['class'].$dat['type'].$dat['function'];
                }

                return implode(' // ',$path);
        }

        function debugRows($rows,$header='')    {
                if (is_array($rows))    {
                        reset($rows);
                        $firstEl = current($rows);
                        if (is_array($firstEl)) {
                                $headerColumns = array_keys($firstEl);
                                $tRows = array();

                                        // Header:
                                $tRows[] = '<tr><td colspan="'.count($headerColumns).'" style="background-color:#bbbbbb; font-family: verdana,arial; font-weight: bold; font-size: 10px;"><strong>'.htmlspecialchars($header).'</strong></td></tr>';
                                $tCells = array();
                                foreach($headerColumns as $key) {
                                        $tCells[] = '
                                                        <td><font face="Verdana,Arial" size="1"><strong>'.htmlspecialchars($key).'</strong></font></td>';
                                }
                                $tRows[] = '
                                                <tr>'.implode('',$tCells).'
                                                </tr>';

                                        // Rows:
                                foreach($rows as $singleRow)    {
                                        $tCells = array();
                                        foreach($headerColumns as $key) {
                                                $tCells[] = '
                                                        <td><font face="Verdana,Arial" size="1">'.htmlspecialchars($singleRow[$key]).'</font></td>';
                                        }
                                        $tRows[] = '
                                                <tr>'.implode('',$tCells).'
                                                </tr>';
                                }

                                $table = '
                                        <table border="1" cellpadding="1" cellspacing="0" bgcolor="white">'.implode('',$tRows).'
                                        </table>';
                                echo $table;
                        } else debug('Empty array of rows',$header);
                } else debug('No array of rows',$header);
        }




























        /*************************
         *
         * 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);
                $getP = array();
                if ($parts['query'])    {
                        parse_str($parts['query'],$getP);
                }
                $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] (scheme will by default be "http" until we can detect something different)
                                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)
                                TYPO3_SSL =                     Returns TRUE if this session uses SSL (HTTPS)

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

                $retVal = '';

                switch ((string)$getEnvName)    {
                        case 'SCRIPT_NAME':
                                $retVal = (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':
                                $retVal = 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 itself etc. Example: returnUrl='.rawurlencode(t3lib_div::getIndpEnv('REQUEST_URI'))
                                if ($GLOBALS['TYPO3_CONF_VAR']['SYS']['requestURIvar']) {       // This is for URL rewriters that store the original URI in a server variable (eg ISAPI_Rewriter for IIS: HTTP_X_REWRITE_URL)
                                        list($v,$n) = explode('|',$GLOBALS['TYPO3_CONF_VAR']['SYS']['requestURIvar']);
                                        $retVal = $GLOBALS[$v][$n];
                                } elseif (!$_SERVER['REQUEST_URI'])     {       // This is for ISS/CGI which does not have the REQUEST_URI available.
                                        $retVal = '/'.ereg_replace('^/','',t3lib_div::getIndpEnv('SCRIPT_NAME')).
                                                ($_SERVER['QUERY_STRING']?'?'.$_SERVER['QUERY_STRING']:'');
                                } else $retVal = $_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')        {
                                        $retVal = $_SERVER['PATH_INFO'];
                                }
                        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':
                                $retVal = $_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)); }
                                $retVal = $DR;
                        break;
                        case 'TYPO3_HOST_ONLY':
                                $p = explode(':',$_SERVER['HTTP_HOST']);
                                $retVal = $p[0];
                        break;
                        case 'TYPO3_PORT':
                                $p = explode(':',$_SERVER['HTTP_HOST']);
                                $retVal = $p[1];
                        break;
                        case 'TYPO3_REQUEST_HOST':
                                $retVal = (t3lib_div::getIndpEnv('TYPO3_SSL') ? 'https://' : 'http://').
                                        $_SERVER['HTTP_HOST'];
                        break;
                        case 'TYPO3_REQUEST_URL':
                                $retVal = t3lib_div::getIndpEnv('TYPO3_REQUEST_HOST').t3lib_div::getIndpEnv('REQUEST_URI');
                        break;
                        case 'TYPO3_REQUEST_SCRIPT':
                                $retVal = t3lib_div::getIndpEnv('TYPO3_REQUEST_HOST').t3lib_div::getIndpEnv('SCRIPT_NAME');
                        break;
                        case 'TYPO3_REQUEST_DIR':
                                $retVal = 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.='/';
                                        $retVal = $siteUrl;
                                }
                        break;
                        case 'TYPO3_SITE_SCRIPT':
                                $retVal = substr(t3lib_div::getIndpEnv('TYPO3_REQUEST_URL'),strlen(t3lib_div::getIndpEnv('TYPO3_SITE_URL')));
                        break;
                        case 'TYPO3_SSL':
                                $retVal = $_SERVER['SSL_SESSION_ID'] || !strcmp($_SERVER['HTTPS'],'on') || !strcmp($_SERVER['HTTPS'],'1') ? TRUE : FALSE;       // see http://bugs.typo3.org/view.php?id=3909
                        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);
                                $retVal = $out;
                        break;
                }
                return $retVal;
        }

        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 (preg_match('/MSIE [4567]/', $useragent))      {
                        $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));}       // Will we ever know if this was a typo or intention...?! :-(
                                        if (strstr($useragent,'Netscape/6')) {$bInfo['VERSION'] = doubleval(substr(strstr($useragent,'Netscape/6'),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;
        }

        function getHostname($requestHost=TRUE) {
                $host = '';
                if ($requestHost && (!defined('TYPO3_cliMode') || !TYPO3_cliMode))      {
                        $host = $_SERVER['HTTP_HOST'];
                }
                if (!$host)     {
                                // will fail for PHP 4.1 and 4.2
                        $host = @php_uname('n');
                                // 'n' is ignored in broken installations
                        if (strpos($host, ' ')) $host = '';
                }
                        // we have not found a FQDN yet
                if ($host && strpos('.',$host) === FALSE)       {
                        $ip = gethostbyname($host);
                                // we got an IP address
                        if ($ip != $host)       {
                                $fqdn = gethostbyaddr($ip);
                                if ($ip != $fqdn)       $host = $fqdn;
                        }
                }
                if (!$host)     $host = 'localhost.localdomain';

                return $host;
        }






















        /*************************
         *
         * 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,'\\') && !preg_match('#(?:^\.\.|/\.\./)#',$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);
                }

                t3lib_div::fixPermissions($destination);        // Change the permissions of the file

                        // 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='',$codeLength=8)   {

                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]=$uid_or_record[$v];
                                }
                        } else {
                                $recCopy_temp=$uid_or_record;
                        }
                        $preKey = implode('|',$recCopy_temp);
                } else {
                        $preKey = $uid_or_record;
                }

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

        function cHashParams($addQueryParams) {
                $params = explode('&',substr($addQueryParams,1));       // Splitting parameters up

                        // Make array:
                $pA = array();
                foreach($params as $theP)       {
                        $pKV = explode('=', $theP);     // Splitting single param by '=' sign
                        if (!t3lib_div::inList('id,type,no_cache,cHash,MP,ftu',$pKV[0]) && !preg_match('/TSFE_ADMIN_PANEL\[.*?\]/',$pKV[0]))    {
                                $pA[rawurldecode($pKV[0])] = (string)rawurldecode($pKV[1]);
                        }
                }
                $pA['encryptionKey'] = $GLOBALS['TYPO3_CONF_VARS']['SYS']['encryptionKey'];
                ksort($pA);

                return $pA;
        }

        function hideIfNotTranslated($l18n_cfg_fieldValue)      {
                if ($GLOBALS['TYPO3_CONF_VARS']['FE']['hidePagesIfNotTranslatedByDefault'])     {
                        return $l18n_cfg_fieldValue&2 ? FALSE : TRUE;
                } else {
                        return $l18n_cfg_fieldValue&2 ? TRUE : FALSE;
                }
        }

        function readLLfile($fileRef,$langKey)  {

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

                        if (@is_file($baseFile.'.xml')) {
                                $LOCAL_LANG = t3lib_div::readLLXMLfile($baseFile.'.xml', $langKey);
                        } elseif (@is_file($baseFile.'.php'))   {
                                include($baseFile.'.php');
                        } else die('Filereference, "'.$file.'", not found!');
                }

                return is_array($LOCAL_LANG)?$LOCAL_LANG:array();
        }

        function readLLXMLfile($fileRef,$langKey)       {

                if (is_object($GLOBALS['LANG']))        {
                        $csConvObj = &$GLOBALS['LANG']->csConvObj;
                } elseif (is_object($GLOBALS['TSFE']))  {
                        $csConvObj = &$GLOBALS['TSFE']->csConvObj;
                } else $csConvObj = NULL;

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

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

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

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

                                        // Read XML, parse it.
                                $xmlString = t3lib_div::getUrl($fileRef);
                                $xmlContent = t3lib_div::xml2array($xmlString);
                                if (!is_array($xmlContent))     {
                                        die($fileRef.' was not XML!: '.$xmlContent);
                                }

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

                                        // Converting charset of default language from utf-8 to iso-8859-1 (since that is what the system would expect for default langauge in the core due to historical reasons)
                                        // This conversion is unneccessary for 99,99% of all default labels since they are in english, therefore ASCII.
                                        // However, an extension like TemplaVoila uses an extended character in its name, even in Default language. To accommodate that (special chars for default) this conversion must be made.
                                        // Since the output from this function is probably always cached it is considered insignificant to do this conversion.
                                        // - kasper
                                if (is_array($LOCAL_LANG['default']))   {
                                        foreach($LOCAL_LANG['default'] as $labelKey => $labelValue)     {
                                                $LOCAL_LANG['default'][$labelKey] = $csConvObj->utf8_decode($labelValue,'iso-8859-1');
                                        }
                                }

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

                                                // If no entry is found for the language key, then force a value depending on meta-data setting. By default an automated filename will be used:
                                        if (!isset($xmlContent['data'][$langKey]))      {
                                                $LOCAL_LANG[$langKey] = t3lib_div::llXmlAutoFileName($fileRef, $langKey);
                                        } else {
                                                $LOCAL_LANG[$langKey] = $xmlContent['data'][$langKey];
                                        }

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

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

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

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

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

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

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

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

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

                        return $LOCAL_LANG;
                }
        }

        function llXmlAutoFileName($fileRef,$language)  {
                        // Analyse file reference:
                $location = 'typo3conf/l10n/'.$language.'/';    // Default location of translations
                if (t3lib_div::isFirstPartOfStr($fileRef,PATH_typo3.'sysext/')) {       // Is system:
                        $validatedPrefix = PATH_typo3.'sysext/';
                        #$location = 'EXT:csh_'.$language.'/';  // For system extensions translations are found in "csh_*" extensions (language packs)
                } elseif (t3lib_div::isFirstPartOfStr($fileRef,PATH_typo3.'ext/'))      {       // Is global:
                        $validatedPrefix = PATH_typo3.'ext/';
                } elseif (t3lib_div::isFirstPartOfStr($fileRef,PATH_typo3conf.'ext/'))  {       // Is local:
                        $validatedPrefix = PATH_typo3conf.'ext/';
                } else {
                        $validatedPrefix = '';
                }

                if ($validatedPrefix)   {

                                // Divide file reference into extension key, directory (if any) and base name:
                        list($file_extKey,$file_extPath) = explode('/',substr($fileRef,strlen($validatedPrefix)),2);
                        $temp = t3lib_div::revExplode('/',$file_extPath,2);
                        if (count($temp)==1)    array_unshift($temp,'');        // Add empty first-entry if not there.
                        list($file_extPath,$file_fileName) = $temp;

                                // The filename is prefixed with "[language key]." because it prevents the llxmltranslate tool from detecting it.
                        return $location.
                                $file_extKey.'/'.
                                ($file_extPath?$file_extPath.'/':'').
                                $language.'.'.$file_fileName;
                } else return NULL;
        }


        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)) return 'Data structure must be an array';

                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;
                        if (isset($dataStruct['meta'])) unset($dataStruct['meta']);     // Meta data should not appear there.
                        $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_func_array(
                                                array(&$GLOBALS['T3_VAR']['callUserFunction'][$funcName]['obj'],
                                                        $GLOBALS['T3_VAR']['callUserFunction'][$funcName]['method']),
                                                array(&$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) t3lib_div::requireOnce($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_func_array(
                                                array(&$classObj, $parts[1]),
                                                array(&$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_array($funcRef, array(&$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)       t3lib_div::requireOnce($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)      {

                        // Load class file if not found:
                if (!class_exists($className))  {
                        if (substr($className,0,6)=='t3lib_')   {
                                t3lib_div::requireOnce(PATH_t3lib.'class.'.strtolower($className).'.php');
                        }
                }

                        // Return object.
                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
                        } else {
                                $requireFile = t3lib_div::getFileAbsFileName($info['classFile']);
                                if (@is_file($requireFile)) {
                                        t3lib_div::requireOnce ($requireFile);
                                        $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 function definition
                                                }
                                                $error = $obj->getLastErrorArray();
                                                unset($obj);
                                        }
                                }
                        }
                                // deactivate the service
                        t3lib_extMgm::deactivateService($info['serviceType'],$info['serviceKey']);
                }
                return $error;
        }

        function requireOnce($requireFile)      {
                global $T3_SERVICES, $T3_VAR, $TYPO3_CONF_VARS;

                require_once ($requireFile);
        }

        function plainMailEncoded($email,$subject,$message,$headers='',$encoding='quoted-printable',$charset='',$dontEncodeHeader=false)        {
                if (!$charset)  {
                        $charset = $GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset'] ? $GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset'] : 'ISO-8859-1';
                }

                if (!$dontEncodeHeader) {
                                // Mail headers must be ASCII, therefore we convert the whole header to either base64 or quoted_printable
                        $newHeaders=array();
                        foreach (explode(chr(10),$headers) as $line)    {       // Split the header in lines and convert each line separately
                                $parts = explode(': ',$line,2); // Field tags must not be encoded
                                if (count($parts)==2)   {
                                        $parts[1] = t3lib_div::encodeHeader($parts[1],$encoding,$charset);
                                        $newHeaders[] = implode(': ',$parts);
                                } else {
                                        $newHeaders[] = $line;  // Should never happen - is such a mail header valid? Anyway, just add the unchanged line...
                                }
                        }
                        $headers = implode(chr(10),$newHeaders);
                        unset($newHeaders);

                        $email = t3lib_div::encodeHeader($email,$encoding,$charset);            // Email address must not be encoded, but it could be appended by a name which should be so (e.g. "Kasper Skårhøj <kasperYYYY@typo3.com>")
                        $subject = t3lib_div::encodeHeader($subject,$encoding,$charset);
                }

                switch ((string)$encoding)      {
                        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.
                        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;
                        case 'quoted-printable':
                        default:
                                $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);
                        break;
                }

                $linebreak = chr(10);                   // Default line break for Unix systems.
                if (TYPO3_OS=='WIN')    {
                        $linebreak = chr(13).chr(10);   // Line break for Windows. This is needed because PHP on Windows systems send mails via SMTP instead of using sendmail, and thus the linebreak needs to be \r\n.
                }

                $headers=trim(implode($linebreak,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)   {
                        // Make sure the string contains only Unix linebreaks
                $string = str_replace(chr(13).chr(10), chr(10), $string);       // Replace Windows breaks (\r\n)
                $string = str_replace(chr(13), chr(10), $string);               // Replace Mac breaks (\r)

                $linebreak = chr(10);                   // Default line break for Unix systems.
                if (TYPO3_OS=='WIN')    {
                        $linebreak = chr(13).chr(10);   // Line break for Windows. This is needed because PHP on Windows systems send mails via SMTP instead of using sendmail, and thus the linebreak needs to be \r\n.
                }

                $newString = '';
                $theLines = explode(chr(10),$string);   // Split lines
                foreach ($theLines as $val)     {
                        $newVal = '';
                        $theValLen = strlen($val);
                        $len = 0;
                        for ($index=0; $index < $theValLen; $index++)   {       // Walk through each character of this line
                                $char = substr($val,$index,1);
                                $ordVal = ord($char);
                                if ($len>($maxlen-4) || ($len>(($maxlen-10)-4)&&$ordVal==32))   {
                                        $newVal.='='.$linebreak;        // Add a line break
                                        $len=0;                 // Reset the length counter
                                }
                                if (($ordVal>=33 && $ordVal<=60) || ($ordVal>=62 && $ordVal<=126) || $ordVal==9 || $ordVal==32) {
                                        $newVal.=$char;         // This character is ok, add it to the message
                                        $len++;
                                } else {
                                        $newVal.=sprintf('=%02X',$ordVal);      // Special character, needs to be encoded
                                        $len+=3;
                                }
                        }
                        $newVal = preg_replace('/'.chr(32).'$/','=20',$newVal);         // Replaces a possible SPACE-character at the end of a line
                        $newVal = preg_replace('/'.chr(9).'$/','=09',$newVal);          // Replaces a possible TAB-character at the end of a line
                        $newString.=$newVal.$linebreak;
                }
                return preg_replace('/'.$linebreak.'$/','',$newString);         // Remove last newline
        }

        function encodeHeader($line,$enc='quoted-printable',$charset='ISO-8859-1')      {
                        // Avoid problems if "###" is found in $line (would conflict with the placeholder which is used below)
                if (strstr($line,'###'))        return $line;

                        // Check if any non-ASCII characters are found - otherwise encoding is not needed
                if (!preg_match('/[^'.chr(32).'-'.chr(127).']/',$line)) return $line;

                        // Wrap email addresses in a special marker
                $line = preg_replace('/([^ ]+@[^ ]+)/', '###$1###', $line);

                $matches = preg_split('/(.?###.+###.?|\(|\))/', $line, -1, PREG_SPLIT_NO_EMPTY);
                foreach ($matches as $part)     {
                        $oldPart = $part;
                        switch ((string)$enc)   {
                                case 'base64':
                                        $part = '=?'.$charset.'?B?'.base64_encode($part).'?=';
                                break;
                                case 'quoted-printable':
                                default:
                                        $qpValue = t3lib_div::quoted_printable($part,1000);
                                        if ($part!=$qpValue)    {
                                                $qpValue = str_replace(' ','_',$qpValue);       // Encoded words in the header should not contain non-encoded spaces. "_" is a shortcut for "=20". See RFC 2047 for details.
                                                $part = '=?'.$charset.'?Q?'.$qpValue.'?=';
                                        }
                                break;
                        }
                        $line = str_replace($oldPart, $part, $line);
                }
                $line = preg_replace('/###(.+?)###/', '$1', $line);     // Remove the wrappers

                return $line;
        }

        function substUrlsInPlainText($message,$urlmode='76',$index_script_url='')      {
                        // Substitute URLs with shorter links:
                foreach (array('http','https') as $protocol)    {
                        $urlSplit = explode($protocol.'://',$message);
                        reset($urlSplit);
                        while (list($c,$v) = each($urlSplit))   {
                                if ($c) {
                                        $newParts = preg_split('/\s|[<>"{}|\\\^`()\']/', $v, 2);
                                        $newURL = $protocol.'://'.$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']->fullQuoteStr($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').'index.php').
                                '?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 initSysLog()   {
                global $TYPO3_CONF_VARS;

                        // for CLI logging name is <fqdn-hostname>:<TYPO3-path>
                if (defined('TYPO3_cliMode') && TYPO3_cliMode)  {
                        $TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'] = t3lib_div::getHostname($requestHost=FALSE).':'.PATH_site;
                }
                        // for Web logging name is <protocol>://<request-hostame>/<site-path>
                else {
                        $TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'] = t3lib_div::getIndpEnv('TYPO3_SITE_URL');
                }

                        // init custom logging
                if (is_array($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'])) {
                        $params = array('initLog'=>TRUE);
                        $fakeThis = FALSE;
                        foreach ($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'] as $hookMethod)       {
                                t3lib_div::callUserFunction($hookMethod,$params,$fakeThis);
                        }
                }

                        // init TYPO3 logging
                foreach (explode(';',$TYPO3_CONF_VARS['SYS']['systemLog'],2) as $log)   {
                        list($type,$destination) = explode(',',$log,3);

                        if ($type == 'syslog')  {
                                define_syslog_variables();
                                if (TYPO3_OS == 'WIN')  {
                                        $facility = LOG_USER;
                                } else {
                                        $facility = constant('LOG_'.strtoupper($destination));
                                }
                                openlog($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'], LOG_ODELAY, $facility);
                        }
                }

                $TYPO3_CONF_VARS['SYS']['systemLogLevel'] = t3lib_div::intInRange($TYPO3_CONF_VARS['SYS']['systemLogLevel'],0,4);
                $TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogInit'] = TRUE;
        }

        function sysLog($msg, $extKey, $severity=0) {
                global $TYPO3_CONF_VARS;

                $severity = t3lib_div::intInRange($severity,0,4);

                        // is message worth logging?
                if (intval($TYPO3_CONF_VARS['SYS']['systemLogLevel']) > $severity)      return;

                        // initialize logging
                if (!$TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogInit'])      {
                        t3lib_div::initSysLog();
                }

                        // do custom logging
                if (is_array($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'])) {
                        $params = array('msg'=>$msg, 'extKey'=>$extKey, 'backTrace'=>debug_backtrace());
                        $fakeThis = FALSE;
                        foreach ($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLog'] as $hookMethod)       {
                                t3lib_div::callUserFunction($hookMethod,$params,$fakeThis);
                        }
                }

                        // TYPO3 logging enabled?
                if (!$TYPO3_CONF_VARS['SYS']['systemLog'])      return;

                $dateFormat = $GLOBALS['TYPO3_CONF_VARS']['SYS']['ddmmyy'];
                $timeFormat = $GLOBALS['TYPO3_CONF_VARS']['SYS']['hhmm'];

                        // use all configured logging options
                foreach (explode(';',$TYPO3_CONF_VARS['SYS']['systemLog'],2) as $log)   {
                        list($type,$destination,$level) = explode(',',$log,4);

                                // is message worth logging for this log type?
                        if (intval($level) > $severity) continue;

                        $msgLine = ' - '.$extKey.': '.$msg;

                                // write message to a file
                        if ($type == 'file')    {
                                $file = fopen($destination, 'a');
                                if ($file)     {
                                        flock($file, LOCK_EX);  // try locking, but ignore if not available (eg. on NFS and FAT)
                                        fwrite($file, date($dateFormat.' '.$timeFormat).$msgLine.chr(10));
                                        flock($file, LOCK_UN);    // release the lock
                                        fclose($file);
                                }
                        }
                                // send message per mail
                        elseif ($type == 'mail')        {
                                list($to,$from) = explode('/',$destination);
                                mail($to, 'Warning - error in TYPO3 installation',
                                        'Host: '.$TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost']."\n".
                                        'Extension: '.$extKey."\n".
                                        'Severity: '.$severity."\n".
                                        "\n".$msg,
                                        ($from ? 'From: '.$from : '')
                                );
                        }
                                // use the PHP error log
                        elseif ($type == 'error_log')   {
                                error_log($TYPO3_CONF_VARS['SC_OPTIONS']['t3lib/class.t3lib_div.php']['systemLogHost'].$msgLine, 0);
                        }
                                // use the system log
                        elseif ($type == 'syslog')      {
                                $priority = array(LOG_INFO,LOG_NOTICE,LOG_WARNING,LOG_ERR,LOG_CRIT);
                                syslog($priority[(int)$severity], $msgLine);
                        }
                }
        }

        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 = t3lib_div::trimExplode(',', $valueList, 1);
                        }
                        $valListCnt = count($valueList);
                        foreach ($arr as $key => $value)        {
                                if (!$valListCnt || in_array($key, $valueList)) {
                                        $str .= (string)$key.trim(': '.t3lib_div::fixed_lgd(str_replace("\n",'|',(string)$value), $valueLength)).'; ';
                                }
                        }
                }
                return $str;
        }

        function imageMagickCommand($command, $parameters, $path='')    {
                $gfxConf = $GLOBALS['TYPO3_CONF_VARS']['GFX'];
                $isExt = (TYPO3_OS=='WIN' ? '.exe' : '');
                $switchCompositeParameters=false;

                if(!$path)      { $path = $gfxConf['im_path']; }

                $im_version = strtolower($gfxConf['im_version_5']);
                $combineScript = $gfxConf['im_combine_filename'] ? trim($gfxConf['im_combine_filename']) : 'combine';

                if($command==='combine')        {       // This is only used internally, has no effect outside
                        $command = 'composite';
                }

                        // Compile the path & command
                if($im_version==='gm')  {
                        $switchCompositeParameters=true;
                        $path .= 'gm'.$isExt.' '.$command;
                } else  {
                        if($im_version==='im6') { $switchCompositeParameters=true; }
                        $path .= (($command=='composite') ? $combineScript : $command).$isExt;
                }

                $cmdLine = $path.' '.$parameters;

                if($command=='composite' && $switchCompositeParameters) {       // Because of some weird incompatibilities between ImageMagick 4 and 6 (plus GraphicsMagick), it is needed to change the parameters order under some preconditions
                        $paramsArr = t3lib_div::unQuoteFilenames($parameters);

                        if(count($paramsArr)>5) {       // The mask image has been specified => swap the parameters
                                $tmp = $paramsArr[count($paramsArr)-3];
                                $paramsArr[count($paramsArr)-3] = $paramsArr[count($paramsArr)-4];
                                $paramsArr[count($paramsArr)-4] = $tmp;
                        }

                        $cmdLine = $path.' '.implode(' ', $paramsArr);
                }

                return $cmdLine;
        }

        function unQuoteFilenames($parameters,$unQuote=FALSE)   {
                $paramsArr = explode(' ', trim($parameters));

                $quoteActive = -1;      // Whenever a quote character (") is found, $quoteActive is set to the element number inside of $params. A value of -1 means that there are not open quotes at the current position.
                foreach($paramsArr as $k=>$v)   {
                        if($quoteActive > -1)   {
                                $paramsArr[$quoteActive] .= ' '.$v;
                                unset($paramsArr[$k]);
                                if(ereg('"$', $v))      { $quoteActive = -1; }

                        } elseif(!trim($v))     {
                                unset($paramsArr[$k]);  // Remove empty elements

                        } elseif(ereg('^"', $v))        {
                                $quoteActive = $k;
                        }
                }

                if($unQuote) {
                        foreach($paramsArr as $key=>$val) {
                                $paramsArr[$key]=preg_replace('/(^"|"$)/','',$val);
                        }
                }
                return $paramsArr;
        }


        function quoteJSvalue($value, $inScriptTags = false)    {
                $value = addcslashes($value, '\''.chr(10).chr(13));
                if (!$inScriptTags)     {
                        $value = htmlspecialchars($value);
                }
                return '\''.$value.'\'';
        }


}

?>

---