class.t3lib_parsehtml.php

Go to the documentation of this file.

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2004 Kasper Skaarhoj (kasperYYYY@typo3.com)
*  All rights reserved
*
*  This script is part of the TYPO3 project. 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_parsehtml {
   var $caseShift_cache=array();


   // *******************************************'
   // COPY FROM class.tslib_content.php: / BEGIN
   // substituteSubpart
   // Cleaned locally 2/2003 !!!! (so different from tslib_content version)
   // *******************************************'

   function getSubpart($content, $marker) {
      if ($marker && strstr($content,$marker))  {
         $start = strpos($content, $marker)+strlen($marker);
         $stop = @strpos($content, $marker, $start+1);
         $sub = substr($content, $start, $stop-$start);

         $reg=Array();
         ereg('^[^<]*-->',$sub,$reg);
         $start+=strlen($reg[0]);

         $reg=Array();
         ereg('<!--[^>]*$',$sub,$reg);
         $stop-=strlen($reg[0]);

         return substr($content, $start, $stop-$start);
      }
   }

   function substituteSubpart($content,$marker,$subpartContent,$recursive=1,$keepMarker=0)   {
      $start = strpos($content, $marker);
      $stop = @strpos($content, $marker, $start+1)+strlen($marker);
      if ($start && $stop>$start)   {
         // code before
         $before = substr($content, 0, $start);
         $reg=Array();
         ereg('<!--[^>]*$',$before,$reg);
         $start-=strlen($reg[0]);
         if ($keepMarker)  {
            $reg_k=Array();
            if ($reg[0])   ereg('^[^>]*-->',substr($content,$start),$reg_k);
            $before_marker = substr($content, $start, strlen($reg_k[0]?$reg_k[0]:$marker));
         }
         $before = substr($content, 0, $start);
            // code after
         $after = substr($content, $stop);
         $reg=Array();
         ereg('^[^<]*-->',$after,$reg);
         $stop+=strlen($reg[0]);
         if ($keepMarker)  {
            $reg_k=Array();
            if ($reg[0])   ereg('<!--[^<]*$',substr($content,0,$stop),$reg_k);
            $sLen = strlen($reg_k[0]?$reg_k[0]:$marker);
            $after_marker = substr($content, $stop-$sLen,$sLen);
         }
         $after = substr($content, $stop);


            // replace?
         if (is_array($subpartContent))   {
            $substContent=$subpartContent[0].$this->getSubpart($content,$marker).$subpartContent[1];
         } else {
            $substContent=$subpartContent;
         }

         if ($recursive && strpos($after, $marker))   {
            return $before.($keepMarker?$before_marker:'').$substContent.($keepMarker?$after_marker:'').$this->substituteSubpart($after,$marker,$subpartContent);
         } else {
            return $before.($keepMarker?$before_marker:'').$substContent.($keepMarker?$after_marker:'').$after;
         }
      } else {
         return $content;
      }
   }
   // *******************************************'
   // COPY FROM class.tslib_content.php: / END
   // *******************************************'







   /************************************
    *
    * Parsing HTML code
    *
    ************************************/

   function splitIntoBlock($tag,$content,$eliminateExtraEndTags=0)   {
      $tags=array_unique(t3lib_div::trimExplode(',',$tag,1));
      $regexStr = '</?('.implode('|',$tags).')(>|[[:space:]][^>]*>)';

      $parts = spliti($regexStr,$content);

      $newParts=array();
      $pointer=strlen($parts[0]);
      $buffer=$parts[0];
      $nested=0;
      reset($parts);
      next($parts);
      while(list($k,$v)=each($parts))  {
         $isEndTag= substr($content,$pointer,2)=='</' ? 1 : 0;
         $tagLen = strcspn(substr($content,$pointer),'>')+1;

         if (!$isEndTag)   {  // We meet a start-tag:
            if (!$nested)  {  // Ground level:
               $newParts[]=$buffer; // previous buffer stored
               $buffer='';
            }
            $nested++;  // We are inside now!
            $mbuffer=substr($content,$pointer,strlen($v)+$tagLen);   // New buffer set and pointer increased
            $pointer+=strlen($mbuffer);
            $buffer.=$mbuffer;
         } else { // If we meet an endtag:
            $nested--;  // decrease nested-level
            $eliminated=0;
            if ($eliminateExtraEndTags && $nested<0)  {
               $nested=0;
               $eliminated=1;
            } else {
               $buffer.=substr($content,$pointer,$tagLen);  // In any case, add the endtag to current buffer and increase pointer
            }
            $pointer+=$tagLen;
            if (!$nested && !$eliminated) {  // if we're back on ground level, (and not by eliminating tags...
               $newParts[]=$buffer;
               $buffer='';
            }
            $mbuffer=substr($content,$pointer,strlen($v));  // New buffer set and pointer increased
            $pointer+=strlen($mbuffer);
            $buffer.=$mbuffer;
         }

      }
      $newParts[]=$buffer;
      return $newParts;
   }

   function splitIntoBlockRecursiveProc($tag,$content,&$procObj,$callBackContent,$callBackTags,$level=0) {
      $parts = $this->splitIntoBlock($tag,$content,TRUE);
      foreach($parts as $k => $v)   {
         if ($k%2)   {
            $firstTagName = $this->getFirstTagName($v, TRUE);
            $tagsArray = array();
            $tagsArray['tag_start'] = $this->getFirstTag($v);
            $tagsArray['tag_end'] = '</'.$firstTagName.'>';
            $tagsArray['tag_name'] = strtolower($firstTagName);
            $tagsArray['add_level'] = 1;
            $tagsArray['content'] = $this->splitIntoBlockRecursiveProc($tag,$this->removeFirstAndLastTag($v),$procObj,$callBackContent,$callBackTags,$level+$tagsArray['add_level']);

            if ($callBackTags)   $tagsArray = $procObj->$callBackTags($tagsArray,$level);

            $parts[$k] =
               $tagsArray['tag_start'].
               $tagsArray['content'].
               $tagsArray['tag_end'];
         } else {
            if ($callBackContent)   $parts[$k] = $procObj->$callBackContent($parts[$k],$level);
         }
      }

      return implode('',$parts);
   }

   function splitTags($tag,$content)   {
      $tags = t3lib_div::trimExplode(',',$tag,1);
      $regexStr = '<('.implode('|',$tags).')(>|\/>|[[:space:]][^>]*>)';
      $parts = spliti($regexStr,$content);

      $pointer = strlen($parts[0]);
      $newParts = array();
      $newParts[] = $parts[0];
      reset($parts);
      next($parts);
      while(list($k,$v)=each($parts))  {
         $tagLen = strcspn(substr($content,$pointer),'>')+1;

            // Set tag:
         $tag = substr($content,$pointer,$tagLen); // New buffer set and pointer increased
         $newParts[] = $tag;
         $pointer+= strlen($tag);

            // Set content:
         $newParts[] = $v;
         $pointer+= strlen($v);
      }
      return $newParts;
   }

   function getAllParts($parts,$tag_parts=1,$include_tag=1) {
      reset($parts);
      $newParts=array();
      while(list($k,$v)=each($parts))  {
         if (($k+($tag_parts?0:1))%2)  {
            if (!$include_tag)   $v=$this->removeFirstAndLastTag($v);
            $newParts[]=$v;
         }
      }
      return $newParts;
   }

   function removeFirstAndLastTag($str)   {
         // First:
      $endLen = strcspn($str,'>')+1;
      $str = substr($str,$endLen);
         // Last:
      $str = strrev($str);
      $endLen = strcspn($str,'<')+1;
      $str = substr($str,$endLen);
         // return
      return strrev($str);
   }

   function getFirstTag($str) {
         // First:
      $endLen = strcspn($str,'>')+1;
      $str = substr($str,0,$endLen);
      return $str;
   }

   function getFirstTagName($str,$preserveCase=FALSE) {
      list($tag) = split('[[:space:]]',substr(trim($this->getFirstTag($str)),1,-1), 2);
      if (!$preserveCase)  $tag = strtoupper($tag);

      return trim($tag);
   }

   function get_tag_attributes($tag,$deHSC=0)   {
      list($components,$metaC) = $this->split_tag_attributes($tag);
      $name = '';  // attribute name is stored here
      $valuemode = '';
      $attributes = array();
      $attributesMeta = array();
      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] = $deHSC?t3lib_div::htmlspecialchars_decode($val):$val;
                     $attributesMeta[$name]['dashType']=$metaC[$key];
                     $name = '';
                  }
               } else {
                  if ($namekey = ereg_replace('[^a-zA-Z0-9_:-]','',$val))  {
                     $name = strtolower($namekey);
                     $attributesMeta[$name]=array();
                     $attributesMeta[$name]['origTag']=$namekey;
                     $attributes[$name] = '';
                  }
               }
               $valuemode = '';
            } else {
               $valuemode = 'on';
            }
         }
         if (is_array($attributes)) reset($attributes);
         return array($attributes,$attributesMeta);
      }
   }

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

      $metaValue = array();
      $value = array();
      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];
            $metaValue[]=$firstChar;
            $tag_tmp=trim($reg[2]);
         } elseif (!strcmp($firstChar,'=')) {
            $value[] = '=';
            $metaValue[]='';
            $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]);
            $metaValue[]='';
            $tag_tmp = trim(substr($tag_tmp,strlen($reg[0]),1).$reg[1]);
         }
      }
      if (is_array($value))   reset($value);
      return array($value,$metaValue);
   }

   function checkTagTypeCounts($content,$blockTags='a,b,blockquote,body,div,em,font,form,h1,h2,h3,h4,h5,h6,i,li,map,ol,option,p,pre,select,span,strong,table,td,textarea,tr,u,ul', $soloTags='br,hr,img,input,area') {
      $content = strtolower($content);
      $analyzedOutput=array();
      $analyzedOutput['counts']=array();  // Counts appearances of start-tags
      $analyzedOutput['errors']=array();  // Lists ERRORS
      $analyzedOutput['warnings']=array();   // Lists warnings.
      $analyzedOutput['blocks']=array();  // Lists stats for block-tags
      $analyzedOutput['solo']=array(); // Lists stats for solo-tags

         // Block tags, must have endings...
      $blockTags = explode(',',$blockTags);
      foreach($blockTags as $tagName)  {
         $countBegin = count(split('<'.$tagName.'[^[:alnum:]]',$content))-1;
         $countEnd = count(split('<\/'.$tagName.'[^[:alnum:]]',$content))-1;
         $analyzedOutput['blocks'][$tagName]=array($countBegin,$countEnd,$countBegin-$countEnd);
         if ($countBegin)  $analyzedOutput['counts'][$tagName]=$countBegin;
         if ($countBegin-$countEnd) {
            if ($countBegin-$countEnd > 0)   {
               $analyzedOutput['errors'][$tagName]='There were more start-tags ('.$countBegin.') than end-tags ('.$countEnd.') for the element "'.$tagName.'". There should be an equal amount!';
            } else {
               $analyzedOutput['warnings'][$tagName]='There were more end-tags ('.$countEnd.') than start-tags ('.$countBegin.') for the element "'.$tagName.'". There should be an equal amount! However the problem is not fatal.';
            }
         }
      }

         // Solo tags, must NOT have endings...
      $soloTags = explode(',',$soloTags);
      foreach($soloTags as $tagName)   {
         $countBegin = count(split('<'.$tagName.'[^[:alnum:]]',$content))-1;
         $countEnd = count(split('<\/'.$tagName.'[^[:alnum:]]',$content))-1;
         $analyzedOutput['solo'][$tagName]=array($countBegin,$countEnd);
         if ($countBegin)  $analyzedOutput['counts'][$tagName]=$countBegin;
         if ($countEnd) {
            $analyzedOutput['warnings'][$tagName]='There were end-tags found ('.$countEnd.') for the element "'.$tagName.'". This was not expected (although XHTML technically allows it).';
         }
      }

      return $analyzedOutput;
   }












   /*********************************
    *
    * Clean HTML code
    *
    *********************************/

   function HTMLcleaner($content, $tags=array(),$keepAll=0,$hSC=0,$addConfig=array())  {
      $newContent = array();
      $tokArr = explode('<',$content);
      $newContent[] = $this->processContent(current($tokArr),$hSC,$addConfig);
      next($tokArr);

      $c = 1;
      $tagRegister = array();
      $tagStack = array();
      while(list(,$tok)=each($tokArr)) {
         $firstChar = substr($tok,0,1);
#        if (strcmp(trim($firstChar),'')) {     // It is a tag...
         if (ereg('[[:alnum:]\/]',$firstChar))  {     // It is a tag... (first char is a-z0-9 or /) (fixed 19/01 2004). This also avoids triggering on <?xml..> and <!DOCTYPE..>
            $tagEnd = strcspn($tok,'>');
            if (strlen($tok)!=$tagEnd) {  // If there is and end-bracket...
               $endTag = $firstChar=='/' ? 1 : 0;
               $tagContent = substr($tok,$endTag,$tagEnd-$endTag);
               $tagParts = split('[[:space:]]',$tagContent,2);
               $tagName = strtolower($tagParts[0]);
               if (isset($tags[$tagName]))   {
                  if (is_array($tags[$tagName]))   {  // If there is processing to do for the tag:

                     if (!$endTag)  {  // If NOT an endtag, do attribute processing (added dec. 2003)
                           // Override attributes
                        if (strcmp($tags[$tagName]['overrideAttribs'],'')) {
                           $tagParts[1]=$tags[$tagName]['overrideAttribs'];
                        }

                           // Allowed tags
                        if (strcmp($tags[$tagName]['allowedAttribs'],''))  {
                           if (!strcmp($tags[$tagName]['allowedAttribs'],'0'))   {  // No attribs allowed
                              $tagParts[1]='';
                           } elseif (trim($tagParts[1])) {
                              $tagAttrib = $this->get_tag_attributes($tagParts[1]);
                              $tagParts[1]='';
                              $newTagAttrib = array();
                              $tList = t3lib_div::trimExplode(',',strtolower($tags[$tagName]['allowedAttribs']),1);
                              while(list(,$allowTag)=each($tList))   {
                                 if (isset($tagAttrib[0][$allowTag]))   $newTagAttrib[$allowTag]=$tagAttrib[0][$allowTag];
                              }
                              $tagParts[1]=$this->compileTagAttribs($newTagAttrib,$tagAttrib[1]);
                           }
                        }

                           // Fixed attrib values
                        if (is_array($tags[$tagName]['fixAttrib']))  {
                           $tagAttrib = $this->get_tag_attributes($tagParts[1]);
                           $tagParts[1]='';
                           reset($tags[$tagName]['fixAttrib']);
                           while(list($attr,$params)=each($tags[$tagName]['fixAttrib']))  {
                              if (strlen($params['set']))   $tagAttrib[0][$attr] = $params['set'];
                              if (strlen($params['unset'])) unset($tagAttrib[0][$attr]);
                              if (strcmp($params['default'],'') && !isset($tagAttrib[0][$attr]))   $tagAttrib[0][$attr]=$params['default'];
                              if ($params['always'] || isset($tagAttrib[0][$attr])) {
                                 if ($params['trim']) {$tagAttrib[0][$attr]=trim($tagAttrib[0][$attr]);}
                                 if ($params['intval'])  {$tagAttrib[0][$attr]=intval($tagAttrib[0][$attr]);}
                                 if ($params['lower'])   {$tagAttrib[0][$attr]=strtolower($tagAttrib[0][$attr]);}
                                 if ($params['upper'])   {$tagAttrib[0][$attr]=strtoupper($tagAttrib[0][$attr]);}
                                 if ($params['range'])   {
                                    if (isset($params['range'][1]))  {
                                       $tagAttrib[0][$attr]=t3lib_div::intInRange($tagAttrib[0][$attr],intval($params['range'][0]),intval($params['range'][1]));
                                    } else {
                                       $tagAttrib[0][$attr]=t3lib_div::intInRange($tagAttrib[0][$attr],intval($params['range'][0]));
                                    }
                                 }
                                 if (is_array($params['list']))   {
                                    if (!in_array($this->caseShift($tagAttrib[0][$attr],$params['casesensitiveComp']),$this->caseShift($params['list'],$params['casesensitiveComp'],$tagName))) $tagAttrib[0][$attr]=$params['list'][0];
                                 }
                                 if (($params['removeIfFalse'] && $params['removeIfFalse']!='blank' && !$tagAttrib[0][$attr]) || ($params['removeIfFalse']=='blank' && !strcmp($tagAttrib[0][$attr],'')))   {
                                    unset($tagAttrib[0][$attr]);
                                 }
                                 if (strcmp($params['removeIfEquals'],'') && !strcmp($this->caseShift($tagAttrib[0][$attr],$params['casesensitiveComp']),$this->caseShift($params['removeIfEquals'],$params['casesensitiveComp']))) {
                                    unset($tagAttrib[0][$attr]);
                                 }
                                 if ($params['prefixLocalAnchors'])  {
                                    if (substr($tagAttrib[0][$attr],0,1)=='#')   {
                                       $prefix = t3lib_div::getIndpEnv('TYPO3_REQUEST_URL');
                                       $tagAttrib[0][$attr] = $prefix.$tagAttrib[0][$attr];
                                       if ($params['prefixLocalAnchors']==2 && t3lib_div::isFirstPartOfStr($prefix,t3lib_div::getIndpEnv('TYPO3_SITE_URL')))      {
                                          $tagAttrib[0][$attr] = substr($tagAttrib[0][$attr],strlen(t3lib_div::getIndpEnv('TYPO3_SITE_URL')));
                                       }
                                    }
                                 }
                                 if ($params['prefixRelPathWith'])   {
                                    $urlParts = parse_url($tagAttrib[0][$attr]);
                                    if (!$urlParts['scheme'] && substr($urlParts['path'],0,1)!='/')   {  // If it is NOT an absolute URL (by http: or starting "/")
                                       $tagAttrib[0][$attr] = $params['prefixRelPathWith'].$tagAttrib[0][$attr];
                                    }
                                 }
                                 if ($params['userFunc'])   {
                                    $tagAttrib[0][$attr] = t3lib_div::callUserFunction($params['userFunc'],$tagAttrib[0][$attr],$this);
                                 }
                              }
                           }
                           $tagParts[1]=$this->compileTagAttribs($tagAttrib[0],$tagAttrib[1]);
                        }
                     } else { // If endTag, remove any possible attributes:
                        $tagParts[1]='';
                     }

                        // Protecting the tag by converting < and > to &lt; and &gt; ??
                     if ($tags[$tagName]['protect'])  {
                        $lt = '&lt;';  $gt = '&gt;';
                     } else {
                        $lt = '<';  $gt = '>';
                     }
                        // Remapping tag name?
                     if ($tags[$tagName]['remap']) $tagParts[0] = $tags[$tagName]['remap'];

                        // rmTagIfNoAttrib
                     if ($endTag || trim($tagParts[1]) || !$tags[$tagName]['rmTagIfNoAttrib'])  {
                        $setTag=1;

                        if ($tags[$tagName]['nesting'])  {
                           if (!is_array($tagRegister[$tagName])) $tagRegister[$tagName]=array();

                           if ($endTag)   {
/*                            if ($tags[$tagName]['nesting']=='global') {
                                 $lastEl = end($tagStack);
                                 $correctTag = !strcmp($tagName,$lastEl);
                              } else $correctTag=1;
   */
                              $correctTag=1;
                              if ($tags[$tagName]['nesting']=='global') {
                                 $lastEl = end($tagStack);
                                 if (strcmp($tagName,$lastEl)) {
                                    if (in_array($tagName,$tagStack))   {
                                       while(count($tagStack) && strcmp($tagName,$lastEl))   {
                                          $elPos = end($tagRegister[$lastEl]);
                                          unset($newContent[$elPos]);

                                          array_pop($tagRegister[$lastEl]);
                                          array_pop($tagStack);
                                          $lastEl = end($tagStack);
                                       }
                                    } else {
                                       $correctTag=0; // In this case the
                                    }
                                 }
                              }
                              if (!count($tagRegister[$tagName]) || !$correctTag)   {
                                 $setTag=0;
                              } else {
                                 array_pop($tagRegister[$tagName]);
                                 if ($tags[$tagName]['nesting']=='global') {array_pop($tagStack);}
                              }
                           } else {
                              array_push($tagRegister[$tagName],$c);
                              if ($tags[$tagName]['nesting']=='global') {array_push($tagStack,$tagName);}
                           }
                        }

                        if ($setTag)   {
                              // Setting the tag
                           $newContent[$c++]=$this->processTag($lt.($endTag?'/':'').trim($tagParts[0].' '.$tagParts[1]).$gt,$addConfig,$endTag,$lt=='&lt;');
                        }
                     }
                  } else {
                     $newContent[$c++]=$this->processTag('<'.($endTag?'/':'').$tagContent.'>',$addConfig,$endTag);
                  }
               } elseif ($keepAll) {   // This is if the tag was not defined in the array for processing:
                  if (!strcmp($keepAll,'protect')) {
                     $lt = '&lt;';  $gt = '&gt;';
                  } else {
                     $lt = '<';  $gt = '>';
                  }
                  $newContent[$c++]=$this->processTag($lt.($endTag?'/':'').$tagContent.$gt,$addConfig,$endTag,$lt=='&lt;');
               }
               $newContent[$c++]=$this->processContent(substr($tok,$tagEnd+1),$hSC,$addConfig);
            } else {
               $newContent[$c++]=$this->processContent('<'.$tok,$hSC,$addConfig);   // There were not end-bracket, so no tag...
            }
         } else {
            $newContent[$c++]=$this->processContent('<'.$tok,$hSC,$addConfig);   // It was not a tag anyways
         }
      }

         // Unsetting tags:
      reset($tagRegister);
      while(list($tag,$positions)=each($tagRegister)) {
         reset($positions);
         while(list(,$pKey)=each($positions))   {
            unset($newContent[$pKey]);
         }
      }

      return implode('',$newContent);
   }

   function bidir_htmlspecialchars($value,$dir) {
      if ($dir==1)   {
         $value = htmlspecialchars($value);
      } elseif ($dir==2)   {
         $value = t3lib_div::deHSCentities(htmlspecialchars($value));
      } elseif ($dir==-1) {
         $value = str_replace('&gt;','>',$value);
         $value = str_replace('&lt;','<',$value);
         $value = str_replace('&quot;','"',$value);
         $value = str_replace('&amp;','&',$value);
      }
      return $value;
   }

   function prefixResourcePath($main_prefix,$content,$alternatives=array())   {

      $parts = $this->splitTags('td,table,body,img,input,form,link,script,a',$content);
      foreach($parts as $k => $v)   {
         if ($k%2)   {
            $params = $this->get_tag_attributes($v,1);
            $tagEnd = substr($v,-2)=='/>' ? ' />' : '>'; // Detect tag-ending so that it is re-applied correctly.
            $firstTagName = $this->getFirstTagName($v);  // The 'name' of the first tag
            $somethingDone=0;
            $prefix = isset($alternatives[strtoupper($firstTagName)]) ? $alternatives[strtoupper($firstTagName)] : $main_prefix;
            switch(strtolower($firstTagName))   {
                  // background - attribute:
               case 'td':
               case 'body':
               case 'table':
                  $src = $params[0]['background'];
                  if ($src)   {
                     $params[0]['background'] = $this->prefixRelPath($prefix,$params[0]['background']);
                     $somethingDone=1;
                  }
               break;
                  // src attribute
               case 'img':
               case 'input':
               case 'script':
                  $src = $params[0]['src'];
                  if ($src)   {
                     $params[0]['src'] = $this->prefixRelPath($prefix,$params[0]['src']);
                     $somethingDone=1;
                  }
               break;
               case 'link':
               case 'a':
                  $src = $params[0]['href'];
                  if ($src)   {
                     $params[0]['href'] = $this->prefixRelPath($prefix,$params[0]['href']);
                     $somethingDone=1;
                  }
               break;
                  // action attribute
               case 'form':
                  $src = $params[0]['action'];
                  if ($src)   {
                     $params[0]['action'] = $this->prefixRelPath($prefix,$params[0]['action']);
                     $somethingDone=1;
                  }
               break;
            }
            if ($somethingDone)  {
               $tagParts = split('[[:space:]]',$v,2);
               $tagParts[1]=$this->compileTagAttribs($params[0],$params[1]);
               $parts[$k] = '<'.trim(strtolower($firstTagName).' '.$tagParts[1]).
                           $tagEnd;
            }
         }
      }
      $content = implode('',$parts);

         // Fix <style> section:
      $prefix = isset($alternatives['style']) ? $alternatives['style'] : $main_prefix;
      if (strlen($prefix)) {
         $parts = $this->splitIntoBlock('style',$content);
         foreach($parts as $k => $v)   {
            if ($k%2)   {
               $parts[$k] = eregi_replace('(url[[:space:]]*\([[:space:]]*["\']?)([^"\')]*)(["\']?[[:space:]]*\))','\1'.$prefix.'\2\3',$parts[$k]);
            }
         }
         $content = implode('',$parts);
      }

      return $content;
   }

   function prefixRelPath($prefix,$srcVal)   {
      $pU = parse_url($srcVal);
      if (!$pU['scheme'] && substr($srcVal, 0, 1)!='/')  { // If not an absolute URL.
         $srcVal = $prefix.$srcVal;
      }
      return $srcVal;
   }

   function cleanFontTags($value,$keepFace=0,$keepSize=0,$keepColor=0)  {
      $fontSplit = $this->splitIntoBlock('font',$value); // ,1 ?? - could probably be more stable if splitTags() was used since this depends on end-tags being properly set!
      reset($fontSplit);
      while(list($k,$v)=each($fontSplit)) {
         if ($k%2)   {  // font:
            $attribArray=$this->get_tag_attributes_classic($this->getFirstTag($v));
            $newAttribs=array();
            if ($keepFace && $attribArray['face']) $newAttribs[]='face="'.$attribArray['face'].'"';
            if ($keepSize && $attribArray['size']) $newAttribs[]='size="'.$attribArray['size'].'"';
            if ($keepColor && $attribArray['color'])  $newAttribs[]='color="'.$attribArray['color'].'"';

            $innerContent = $this->cleanFontTags($this->removeFirstAndLastTag($v),$keepFace,$keepSize,$keepColor);
            if (count($newAttribs)) {
               $fontSplit[$k]='<font '.implode(' ',$newAttribs).'>'.$innerContent.'</font>';
            } else {
               $fontSplit[$k]=$innerContent;
            }
         }
      }
      return implode('',$fontSplit);
   }

   function mapTags($value,$tags=array(),$ltChar='<',$ltChar2='<')   {

      foreach($tags as $from => $to)   {
         $value = eregi_replace($ltChar.$from.'>',$ltChar2.$to.'>',$value);
         $value = eregi_replace($ltChar.$from.'[[:space:]]([^>]*)>',$ltChar2.$to.' \\1>',$value);
         $value = eregi_replace($ltChar.'\/'.$from.'[^>]*>',$ltChar2.'/'.$to.'>',$value);
      }
      return $value;
   }

   function unprotectTags($content,$tagList='') {
      $tagsArray = t3lib_div::trimExplode(',',$tagList,1);
      $contentParts = explode('&lt;',$content);
      next($contentParts); // bypass the first
      while(list($k,$tok)=each($contentParts))  {
         $firstChar = substr($tok,0,1);
         if (strcmp(trim($firstChar),'')) {
            $subparts = explode('&gt;',$tok,2);
            $tagEnd = strlen($subparts[0]);
            if (strlen($tok)!=$tagEnd) {
               $endTag = $firstChar=='/' ? 1 : 0;
               $tagContent = substr($tok,$endTag,$tagEnd-$endTag);
               $tagParts = split('[[:space:]]',$tagContent,2);
               $tagName = strtolower($tagParts[0]);
               if (!strcmp($tagList,'') || in_array($tagName,$tagsArray))  {
                  $contentParts[$k] = '<'.$subparts[0].'>'.$subparts[1];
               } else $contentParts[$k] = '&lt;'.$tok;
            } else $contentParts[$k] = '&lt;'.$tok;
         } else $contentParts[$k] = '&lt;'.$tok;
      }

      return implode('',$contentParts);
   }

   function stripTagsExcept($value,$tagList) {
      $tags=t3lib_div::trimExplode(',',$tagList,1);
      $forthArr=array();
      $backArr=array();
      while(list(,$theTag)=each($tags))   {
         $forthArr[$theTag]=md5($theTag);
         $backArr[md5($theTag)]=$theTag;
      }
         $value = $this->mapTags($value,$forthArr,'<','_');
         $value=strip_tags($value);
         $value = $this->mapTags($value,$backArr,'_','<');
      return $value;
   }

   function caseShift($str,$flag,$cacheKey='')  {
      if (is_array($str))  {
         if (!$cacheKey || !isset($this->caseShift_cache[$cacheKey]))   {
            reset($str);
            while(list($k)=each($str)) {
               $str[$k] = strtoupper($str[$k]);
            }
            if ($cacheKey) $this->caseShift_cache[$cacheKey]=$str;
         } else {
            $str = $this->caseShift_cache[$cacheKey];
         }
      } elseif (!$flag) $str = strtoupper($str);
      return $str;
   }

   function compileTagAttribs($tagAttrib,$meta=array(), $xhtmlClean=0)  {
      $accu=array();
      reset($tagAttrib);
      while(list($k,$v)=each($tagAttrib)) {
         if ($xhtmlClean)  {
            $attr=strtolower($k);
            if (strcmp($v,'') || isset($meta[$k]['dashType'])) {
               $attr.='="'.htmlspecialchars($v).'"';
            }
         } else {
            $attr=$meta[$k]['origTag']?$meta[$k]['origTag']:$k;
            if (strcmp($v,'') || isset($meta[$k]['dashType'])) {
               $dash=$meta[$k]['dashType']?$meta[$k]['dashType']:(t3lib_div::testInt($v)?'':'"');
               $attr.='='.$dash.$v.$dash;
            }
         }
         $accu[]=$attr;
      }
      return implode(' ',$accu);
   }

   function get_tag_attributes_classic($tag,$deHSC=0) {
      $attr=$this->get_tag_attributes($tag,$deHSC);
      return is_array($attr[0])?$attr[0]:array();
   }

   function indentLines($content, $number=1, $indentChar="\t") {
      $preTab = str_pad('', $number*strlen($indentChar), $indentChar);
      $lines = explode(chr(10),str_replace(chr(13),'',$content));
      while(list($k,$v) = each($lines))   {
         $lines[$k] = $preTab.$v;
      }
      return implode(chr(10), $lines);
   }

   function HTMLparserConfig($TSconfig,$keepTags=array())   {
         // Allow tags (base list, merged with incoming array)
      $alTags = array_flip(t3lib_div::trimExplode(',',strtolower($TSconfig['allowTags']),1));
      $keepTags = array_merge($alTags,$keepTags);

         // Set config properties.
      if (is_array($TSconfig['tags.']))   {
         reset($TSconfig['tags.']);
         while(list($key,$tagC)=each($TSconfig['tags.']))   {
            if (!is_array($tagC) && $key==strtolower($key)) {
               if (!strcmp($tagC,'0')) unset($keepTags[$key]);
               if (!strcmp($tagC,'1') && !isset($keepTags[$key])) $keepTags[$key]=1;
            }
         }

         reset($TSconfig['tags.']);
         while(list($key,$tagC)=each($TSconfig['tags.']))   {
            if (is_array($tagC) && $key==strtolower($key))  {
               $key=substr($key,0,-1);
               if (!is_array($keepTags[$key]))  $keepTags[$key]=array();
               if (is_array($tagC['fixAttrib.']))  {
                  reset($tagC['fixAttrib.']);
                  while(list($atName,$atConfig)=each($tagC['fixAttrib.'])) {
                     if (is_array($atConfig))   {
                        $atName=substr($atName,0,-1);
                        if (!is_array($keepTags[$key]['fixAttrib'][$atName])) {
                           $keepTags[$key]['fixAttrib'][$atName]=array();
                        }
                        $keepTags[$key]['fixAttrib'][$atName] = array_merge($keepTags[$key]['fixAttrib'][$atName],$atConfig);    // Candidate for t3lib_div::array_merge() if integer-keys will some day make trouble...
                        if (strcmp($keepTags[$key]['fixAttrib'][$atName]['range'],'')) $keepTags[$key]['fixAttrib'][$atName]['range'] = t3lib_div::trimExplode(',',$keepTags[$key]['fixAttrib'][$atName]['range']);
                        if (strcmp($keepTags[$key]['fixAttrib'][$atName]['list'],''))  $keepTags[$key]['fixAttrib'][$atName]['list'] = t3lib_div::trimExplode(',',$keepTags[$key]['fixAttrib'][$atName]['list']);
                     }
                  }
               }
               unset($tagC['fixAttrib.']);
               unset($tagC['fixAttrib']);
               $keepTags[$key] = array_merge($keepTags[$key],$tagC);       // Candidate for t3lib_div::array_merge() if integer-keys will some day make trouble...
            }
         }
      }
         // localNesting
      if ($TSconfig['localNesting'])   {
         $lN = t3lib_div::trimExplode(',',strtolower($TSconfig['localNesting']),1);
         while(list(,$tn)=each($lN))   {
            if (isset($keepTags[$tn])) {
               $keepTags[$tn]['nesting']=1;
            }
         }
      }
      if ($TSconfig['globalNesting'])  {
         $lN = t3lib_div::trimExplode(',',strtolower($TSconfig['globalNesting']),1);
         while(list(,$tn)=each($lN))   {
            if (isset($keepTags[$tn])) {
               if (!is_array($keepTags[$tn]))   $keepTags[$tn]=array();
               $keepTags[$tn]['nesting']='global';
            }
         }
      }
      if ($TSconfig['rmTagIfNoAttrib'])   {
         $lN = t3lib_div::trimExplode(',',strtolower($TSconfig['rmTagIfNoAttrib']),1);
         while(list(,$tn)=each($lN))   {
            if (isset($keepTags[$tn])) {
               if (!is_array($keepTags[$tn]))   $keepTags[$tn]=array();
               $keepTags[$tn]['rmTagIfNoAttrib']=1;
            }
         }
      }
      if ($TSconfig['noAttrib']) {
         $lN = t3lib_div::trimExplode(',',strtolower($TSconfig['noAttrib']),1);
         while(list(,$tn)=each($lN))   {
            if (isset($keepTags[$tn])) {
               if (!is_array($keepTags[$tn]))   $keepTags[$tn]=array();
               $keepTags[$tn]['allowedAttribs']=0;
            }
         }
      }
      if ($TSconfig['removeTags'])  {
         $lN = t3lib_div::trimExplode(',',strtolower($TSconfig['removeTags']),1);
         while(list(,$tn)=each($lN))   {
            $keepTags[$tn]=array();
            $keepTags[$tn]['allowedAttribs']=0;
            $keepTags[$tn]['rmTagIfNoAttrib']=1;
         }
      }

         // Create additional configuration:
      $addConfig=array();
      if ($TSconfig['xhtml_cleaning']) {
         $addConfig['xhtml']=1;
      }

      return array(
         $keepTags,
         ''.$TSconfig['keepNonMatchedTags'],
         intval($TSconfig['htmlSpecialChars']),
         $addConfig
      );
   }

   function XHTML_clean($content)   {
      $content = $this->HTMLcleaner(
         $content,
         array(), // No tags treated specially
         1,       // Keep ALL tags.
         0,       // All content is htmlspecialchar()'ed (or ??) - if we do, <script> content will break...
         array('xhtml' => 1)
      );
      return $content;
   }

   function processTag($value,$conf,$endTag,$protected=0)   {
         // Return immediately if protected or no parameters
      if ($protected || !count($conf)) return $value;
         // OK then, begin processing for XHTML output:
         // STILL VERY EXPERIMENTAL!!
      if ($conf['xhtml'])  {
         if ($endTag)   {  // Endtags are just set lowercase right away
            $value = strtolower($value);
         } elseif (substr($value,0,2)!='<!') {  // ... and comments are ignored.
            $inValue = substr($value,1,(substr($value,-2)=='/>'?-2:-1));   // Finding inner value with out < >
            list($tagName,$tagP)=split('[[:space:]]',$inValue,2); // Separate attributes and tagname
            $tagName = strtolower($tagName);

               // Process attributes
            $tagAttrib = $this->get_tag_attributes($tagP);
            if (!strcmp($tagName,'img') && !isset($tagAttrib[0]['alt']))      $tagAttrib[0]['alt']='';   // Set alt attribute for all images (not XHTML though...)
            if (!strcmp($tagName,'script') && !isset($tagAttrib[0]['type']))  $tagAttrib[0]['type']='text/javascript';  // Set type attribute for all script-tags
            $outA=array();
            reset($tagAttrib[0]);
            while(list($attrib_name,$attrib_value)=each($tagAttrib[0])) {
                  // Set attributes: lowercase, always in quotes, with htmlspecialchars converted.
               $outA[]=$attrib_name.'="'.htmlspecialchars($this->bidir_htmlspecialchars($attrib_value,-1)).'"';
            }
            $newTag='<'.trim($tagName.' '.implode(' ',$outA));
               // All tags that are standalone (not wrapping, not having endtags) should be ended with '/>'
            if (t3lib_div::inList('img,br,hr,meta,link,base,area,input',$tagName) || substr($value,-2)=='/>')  {
               $newTag.=' />';
            } else {
               $newTag.='>';
            }
            $value = $newTag;
         }
      }

      return $value;
   }

   function processContent($value,$dir,$conf)   {
      if ($dir!=0)   $value = $this->bidir_htmlspecialchars($value,$dir);
      return $value;
   }
}



if (defined('TYPO3_MODE') && $TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_parsehtml.php'])  {
   include_once($TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_parsehtml.php']);
}
?>

---