/src/typo3_src-4.0.7/t3lib/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;
        }
















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

                        // 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 = chr(10).
                                                                t3lib_div::array2xml(
                                                                        $v,
                                                                        $NSprefix,
                                                                        $level+1,
                                                                        '',
                                                                        $spaceInd,
                                                                        $subOptions,
                                                                        array(
                                                                                'parentTagName' => $tagName,
                                                                                'grandParentTagName' => $stackData['parentTagName'],
                                                                                'path' => $clearStackPath ? '' : $stackData['path'].'/'.$tagName,
                                                                        )
                                                                ).
                                                                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 = chr(10).chunk_split(base64_encode($v));
                                                $attr.=' base64="1"';
                                        } else {
                                                        // Otherwise, just htmlspecialchar the stuff:
                                                $content = htmlspecialchars($v);
                                                $dType = gettype($v);