Beste leden,
IK ben sinds kort overgestapt naar het gebruik van een stack-based parser.
Maar nu zou ik niet weten hoe ik de volgende code daarin moet verwerken.
PHP
$text = preg_replace("(\[quote=(.+?)\](.+?)\[\/quote\])is",'<fieldset><legend> <b>$1 schreef:</b> </legend><br />$2<br /></fieldset><br />' ,$text);
$text = preg_replace("(\[quote\](.+?)\[\/quote])is",'<fieldset><legend> <b>Quote</b> </legend><br />$1<br /></fieldset><br />' ,$text);Deze code moet hierin:
PHP
<?php
/*
* Auteur: Grayen Myrith
*/
class ubb
{
private $aPieces = array();
private $aTree = array();
private $bParse = true;
private $bParagraphise = true;
private $aAlias = array
(
'*' => 'li',
'list' => 'ul',
'ulist' => 'ul',
'olist' => 'ol',
'url' => 'a',
'quote' => 'blockquote',
'google' => 'search'
);
/*
allowed: alle tags die in de gedefineerde tag mogen staan.
child: de verplichte childs die een tag moet hebben.
parent: de verplichte parent die en tag moet hebben.
inline: is het inline element? of niet?
solid: is het een block element waarbij eerst alle tags moeten worden gesloten? Voorbeelden hiervan: table, ul, ol dat moet je uiteraard niet aan tags als td gaan geven, want dan krijg je bijvoorbeeld het volgende: <table><tr></tr></table><td>tekst</td> (en dat willen we natuurljik niet :P)
single: de tag heeft geen bij behorende sluitende tag.
master: door deze item toe te voegen negeert de tag alle regels (Pas op! bij deze tags kun je niet meer gebruik maken van $this->parse('tag') functionaliteit)
*/
public $aFilters = array
(
'basic' => array
(
'b' => array
(
'allowed' => 'all',
'solid' => false,
'inline' => true
),
'i' => array
(
'allowed' => 'all',
'solid' => false,
'inline' => true
),
'u' => array
(
'allowed' => 'all',
'solid' => false,
'inline' => true
),
's' => array
(
'allowed' => 'all',
'solid' => false,
'inline' => true
),
'sub' => array
(
'allowed' => 'all',
'solid' => false,
'inline' => true
),
'sup' => array
(
'allowed' => 'all',
'solid' => false,
'inline' => true
)
),
'extended' => array
(
'code' => array
(
'allowed' => 'all',
'solid' => true,
'inline' => false
),
'h2' => array
(
'allowed' => 'all',
'solid' => true,
'inline' => false
),
'h3' => array
(
'allowed' => 'all',
'solid' => true,
'inline' => false
),
'h4' => array
(
'allowed' => 'all',
'solid' => true,
'inline' => false
),
'h5' => array
(
'allowed' => 'all',
'solid' => true,
'inline' => false
),
'h6' => array
(
'allowed' => 'all',
'solid' => true,
'inline' => false
),
'blockquote' => array
(
'allowed' => 'all',
'solid' => true,
'inline' => false,
'master' => true
),
'hr' => array
(
'allowed' => 'all',
'solid' => true,
'inline' => false,
'single' => true
)
),
'links' => array
(
'a' => array
(
'allowed' => 'all',
'solid' => false,
'inline' => true
),
'search' => array
(
'allowed' => 'all',
'solid' => false,
'inline' => true
)
),
'images' => array
(
'img' => array
(
'allowed' => 'none',
'solid' => true,
'inline' => false,
'single' => true
)
),
'tables' => array
(
'table' => array
(
'allowed' => 'all',
'child' => array('tr'),
'solid' => true,
'inline' => false
),
'tr' => array
(
'allowed' => 'all',
'parent' => array('table'),
'child' => array('td', 'th'),
'solid' => false,
'inline' => false
),
'th' => array
(
'allowed' => 'all',
'parent' => array('tr'),
'solid' => false,
'inline' => false
),
'td' => array
(
'allowed' => 'all',
'parent' => array('tr'),
'solid' => false,
'inline' => false
)
),
'lists' => array
(
'ol' => array
(
'allowed' => 'all',
'child' => array('li'),
'solid' => true,
'inline' => false
),
'ul' => array
(
'allowed' => 'all',
'child' => array('li'),
'solid' => true,
'inline' => false
),
'li' => array
(
'allowed' => 'all',
'parent' => array('ul', 'ol'),
'solid' => false,
'inline' => false
)
)
);
private $aFilter = array('basic', 'extended', 'links', 'images', 'lists', 'tables');
private $aTags = array();
public $sText = '';
public $aText = array();
public function __construct($sText)
{
$this->sText = trim($sText);
foreach($this->aFilters as $sName => $aTags)
{
if(in_array($sName, $this->aFilter) === true)
{
$this->aTags = array_merge($this->aTags, $aTags);
}
}
}
private function realEmpty($sString)
{
return !(empty($sString) === false && substr_count($sString, "\\n") != strlen($sString));
}
private function getPieces()
{
# De tekst die in delen moet worden gehakt.
$sText = $this->sText;
# De counter voor de key waarden voor elk stukje.
$i = 0;
# De tekst dat zich nog voor de tag bevindt.
$sOther = '';
while(strlen($sText) > 0)
{
$iOpen = strpos($sText, '[');
$iClose = strpos($sText, ']');
# Er is geen tag gevonden, het is dus tekst.
if($iClose === false || $iOpen === false)
{
$this->aPieces['t'.$i] = $sText;
$i++;
return true;
}
else
{
# Is het echt wel een tag, zoals [tag] en niet zomaar twee haakjes als ][.
while($iOpen > $iClose)
{
$iClose = strpos($sText, ']', $iClose + 1);
# Het was geen echte tag, dus het is tekst.
if($iClose === false)
{
$this->aPieces['t'.$i] = $sText;
$i++;
return true;
}
}
# Zit er niet nog een [ voor de tag.
$iTemp = strpos($sText, '[', $iOpen + 1);
while($iOpen < $iTemp && $iTemp < $iClose)
{
$iOpen = $iTemp;
$iTemp = strpos($sText, '[', $iOpen + 1);
}
# Er is een tag gevonden.
if($iOpen < $iClose)
{
$sTag = substr($sText, $iOpen, $iClose - $iOpen + 1);
# Heeft de tag wel een waarde en is het niet gewoon [].
$sTagValue = substr($sTag, 1, -1);
if(empty($sTagValue) === true)
{
$iOpen = $iClose + 1;
}
# De tekst voor de tag ophalen.
$sTemp = substr($sText, 0, $iOpen);
if(empty($sTemp) === false)
{
$sOther .= $sTemp;
}
# Is de tag niet leeg?
if(empty($sTagValue) === false)
{
# Stond er nog tekst voor de tag?
if(empty($sOther) === false)
{
$this->aPieces['t'.$i] = $sOther;
$i++;
$sOther = '';
}
# Stop de tag in de array.
$this->aPieces[($sTag{1} == '/' ? 'c' : 'o').$i] = $sTag;
$i++;
}
# Hakt het al geparsde deel van de tekst af.
$sText = substr($sText, $iClose + 1);
}
}
}
}
private function createTree()
{
foreach($this->aPieces as $sKey => $sPiece)
{
switch($sKey{0})
{
case 't':
$this->append($this->createText($sPiece));
break;
case 'o':
$this->append($this->createOpenTag($sPiece));
break;
case 'c':
$this->append($this->createCloseTag($sPiece));
break;
}
}
}
private function append($aData)
{
$this->aTree[] = $aData;
}
private function createOpenTag($sTag)
{
# Zet alle gegevens over de tag in een array.
$aNode = array();
$aNode['type'] = 'open';
$aNode['text'] = $sTag;
# De tag zonder haakjes.
$sTag = substr($sTag, 1, -1);
if(strpos($sTag, ' ') == true || strpos($sTag, '=') == true)
{
$aNode['tag'] = strtok($sTag, " =");
}
else
{
$aNode['tag'] = $sTag;
}
$aNode['attributes'] = array();
$iSpace = strpos($aNode['text'], ' ');
$iIsSign = strpos($aNode['text'], '=');
if($iSpace !== false || $iIsSign !== false)
{
while(preg_match('#([a-zA-Z0-9]+?)=\'(.*?)\'(\s|$)#si', $sTag, $aMatches) == true || preg_match('#([a-zA-Z0-9]+?)=(.*?)(\s|$)#si', $sTag, $aMatches) == true)
{
$sValue = trim($aMatches[2]);
if(empty($sValue) === false)
{
$aNode['attributes'][isset($this->aAlias[trim($aMatches[1])]) === true ? $this->aAlias[trim($aMatches[1])] : trim($aMatches[1])] = str_replace(array('"', "'"), '', $sValue);
}
$sTag = str_replace($aMatches[0], '', $sTag);
}
}
# Vervangt de waarde naar de alias.
if(isset($this->aAlias[$aNode['tag']]) === true)
{
$aNode['tag'] = $this->aAlias[$aNode['tag']];
if($iSpace === false && $iIsSign === false)
{
$aNode['text'] = '['.$aNode['tag'].']';
}
else
{
if($iSpace > $iIsSign || $iIsSign !== false && $iSpace === false)
{
$aNode['text'] = '['.$aNode['tag'].substr($aNode['text'], $iIsSign).']';
}
else if($iIsSign > $iSpace || $iSpace === false && $iIsSign !== false)
{
$aNode['text'] = '['.$aNode['tag'].substr($aNode['text'], $iSpace).']';
}
}
}
return $aNode;
}
private function createCloseTag($sTag)
{
$aNode = array();
$aNode['type'] = 'close';
$aNode['text'] = $sTag;
$aNode['tag'] = substr($sTag, 2, -1);
# Kijken of er een alias voor bestaat.
$aNode['tag'] = isset($this->aAlias[$aNode['tag']]) === true ? $this->aAlias[$aNode['tag']] : $aNode['tag'];
return $aNode;
}
private function createText($sText)
{
$aNode = array();
$aNode['type'] = 'text';
$aNode['text'] = $sText;
return $aNode;
}
private function validateTree()
{
# Is er een child toegevoegd (en is dus nog niet gesloten)?
$sOpened = '';
# Welk block element geopend is als laatst geopend?
$bSolidOpened = false;
$aNewTree = array();
$aOpenTags = array();
$aNode = array_shift($this->aTree);
while(empty($aNode) === false)
{
$aPrevNode = end($aNewTree);
switch($aNode['type'])
{
case 'text':
# Heeft de parent tag nog een bepaalde child nodig?
if($this->realEmpty($aNode['text']) === false && empty($aOpenTags) === false && ($vChild = $this->childNeeded(end($aOpenTags), 'text')) !== false && is_bool($vChild) === false)
{
array_unshift($this->aTree, $this->createCloseTag('[/'.$vChild['tag'].']'));
array_unshift($this->aTree, $aNode);
array_unshift($this->aTree, $vChild);
}
else
{
# Als het vorige fragment ook tekst is, voeg deze dan samen.
if($aPrevNode['type'] === 'text')
{
$aNode['text'] = $aPrevNode['text'].$aNode['text'];
array_pop($aNewTree);
}
# Als er een paragraaf in de tekst zit, sluit dan eerst alle open tags.
if(empty($aOpenTags) === false && isset($this->aTags[end($aOpenTags)]) === true && strpos($aNode['text'], "\\n\\n") !== false)
{
# Verwijder spaties links en recht van de tekst indien de tekst in een element staat.
$aNode['text'] = trim($aNode['text']);
if($this->aTags[end($aOpenTags)]['inline'] === true)
{
$aParagraphs = explode("\\n\\n", $aNode['text']);
$aNode['text'] = array_shift($aParagraphs);
$aNewTree[] = $aNode;
while(end($aOpenTags) && (isset($this->aTags[end($aOpenTags)]['single']) === false || $this->aTags[end($aOpenTags)]['single'] !== true))
{
$aNewTree[] = $this->createCloseTag('[/'.end($aOpenTags).']');
array_pop($aOpenTags);
}
$aNode['text'] = "\\n\\n".implode("\\n\\n", $aParagraphs);
$aNewTree[] = $aNode;
}
else
{
$aNode['text'] = $aNode['text'];
$aNewTree[] = $aNode;
}
}
else
{
$aNewTree[] = $aNode;
}
}
break;
case 'open':
$bSkip = false;
if(isset($this->aTags[$aNode['tag']]) === false)
{
$aNode['type'] = 'text';
if($aNode['type'] == 'text')
{
$aNode['text'] = $aPrevNode['text'].$aNode['text'];
array_pop($aNewTree);
}
$aNewTree[] = $aNode;
}
else
{
# Is de tag wel toegestaan binnen zijn parent?
if(empty($aOpenTags) === true || $this->isAllowed(end($aOpenTags), $aNode['tag']) === true)
{
# Voorkomt dat een inline element om een block element komt te staan.
if(isset($this->aTags[end($aOpenTags)]) === true && $this->aTags[end($aOpenTags)]['inline'] === true && $this->aTags[$aNode['tag']]['inline'] === false)
{
array_pop($aNewTree);
array_pop($aOpenTags);
continue;
}
# Zorgt ervoor dat alle tags worden gesloten bij een nieuw block element.
if(isset($this->aTags[$aNode['tag']]['solid']) === true && $this->aTags[$aNode['tag']]['solid'] === true)
{
$bSolidOpened = true;
while(end($aOpenTags) && (isset($this->aTags[end($aOpenTags)]['single']) === false || $this->aTags[end($aOpenTags)]['single'] !== true) && isset($this->aTags[end($aOpenTags)]['master']) === false)
{
$aNewTree[] = $this->createCloseTag('[/'.end($aOpenTags).']');
array_pop($aOpenTags);
}
}
$vParent = $this->parentNeeded(end($aOpenTags), $aNode['tag']);
$vChild = $this->childNeeded(end($aOpenTags), $aNode['tag']);
# Omdat we het gebruik van parent willen verkomen moeten we kijken of de vorige node niet al de juiste parent heeft aangemaakt.
if(is_bool($vParent) === false)
{
if($aNode['tag'] == end($aOpenTags))
{
$aNewTree[] = $this->createCloseTag('[/'.$aNode['tag'].']');
array_pop($aOpenTags);
}
else
{
array_unshift($this->aTree, $aNode);
array_unshift($this->aTree, $vParent);
$bSkip = true;
}
}
# Is een child noodzakelijk?
if(is_bool($vChild) === false)
{
array_unshift($this->aTree, $aNode);
array_unshift($this->aTree, $vChild);
$bSkip = true;
}
if($bSkip === false)
{
# Voeg de tag toe aan de nieuwe tree.
$aNewTree[] = $aNode;
$aOpenTags[] = $aNode['tag'];
}
}
}
break;
case 'close':
# Als er niks tussen de tags staat, haal ze dan weg.
if($aPrevNode['type'] == 'open' && $aPrevNode['tag'] == $aNode['tag'])
{
array_pop($aNewTree);
array_pop($aOpenTags);
}
else
{
# Is de sluitende tag wel gelijk aan de geopende?
if(empty($aOpenTags) === false && ($aNode['tag'] == end($aOpenTags)))
{
if(in_array($aNode['tag'], $aOpenTags) === true)
{
$aNewTree[] = $aNode;
array_pop($aOpenTags);
}
}
else if(isset($this->aTags[$aNode['tag']]) === false)
{
$aNode['type'] = 'text';
if($aNode['type'] == 'text')
{
$aNode['text'] = $aPrevNode['text'].$aNode['text'];
array_pop($aNewTree);
}
$aNewTree[] = $aNode;
}
}
break;
}
$aNode = array_shift($this->aTree);
}
# Sluit alle nog open tags.
while(end($aOpenTags) && (isset($this->aTags[end($aOpenTags)]['single']) === false || $this->aTags[end($aOpenTags)]['single'] !== true))
{
$aNewTree[] = $this->createCloseTag('[/'.end($aOpenTags).']');
array_pop($aOpenTags);
}
# Update de oude tree.
$this->aTree = $aNewTree;
}
private function childNeeded($sParent, $sChild)
{
# Er zijn geen verplichte childs.
if(isset($this->aTags[$sParent]['child']) === false)
{
return false;
}
# De nieuwe child is al in orde.
if(in_array($sChild, $this->aTags[$sParent]['child']) === true)
{
return false;
}
# Een child is nodig, dus moet er een worden toegevoegd.
return $this->createOpenTag('['.$this->aTags[$sParent]['child'][0].']');
}
private function parentNeeded($sParent, $sChild)
{
# Er zijn geen verplichte parents.
if(isset($this->aTags[$sChild]['parent']) === false)
{
return false;
}
# De parent is al in orde.
if(in_array($sParent, $this->aTags[$sChild]['parent']) === true)
{
return false;
}
# Een andere parent is nodig, dus moet er een worden toegevoegd.
return $this->createOpenTag('['.$this->aTags[$sChild]['parent'][0].']');
}
private function isAllowed($sParent, $sChild)
{
# Alle tags zijn toegestaan.
if($this->aTags[$sParent]['allowed'] == 'all')
{
return true;
}
# Geen enkele tag is binnen deze tag toegestaan.
if($this->aTags[$sParent]['allowed'] == 'none')
{
return false;
}
# Leest de argumenten uit.
$aArguments = explode('^', $this->aTags[$sChild]['allowed']);
$aTags = explode(',', $aArguments[1]);
# Kijkt of de child aan de eisen voldoet.
if($aArguments[0] == 'none' && in_array($sChild, $aTags) === true)
{
return true;
}
if($aArguments[0] == 'all' && in_array($sChild, $aTags) === true)
{
return false;
}
return false;
}
# Zodat de parser weet of hij zich in het eerste level bevindt of niet.
private $iLevel = 0;
# Zorgt ervoor dat de parse functie ook werkt binnen ubb methodes die je zelf aan heb gemaakt.
private $bChangeSolid = false;
private function parse($sStopTag = '')
{
# Als er niks is om te parsen.
if(empty($this->aTree) === true)
{
return '';
}
# De tag van het block type dat open is.
$aOpen = array();
# De hoeveelheid tags er van het type block en hetzelfde zijn die open zijn.
$iOpen = 0;
# Wat het vorige type was.
$bSolid = false;
# Het type van het huidige element.
$bNodeInline = false;
# De counter voor de keys van de text array.
$i = 0;
$iLevel = $this->iLevel;
$this->iLevel++;
$sText = '';
while($aNode = array_shift($this->aTree))
{
if($this->bParagraphise === true && $iLevel == 0)
{
# Is het een tag?
if(isset($aNode['tag']) === true && isset($this->aTags[$aNode['tag']]) === true)
{
# Is geen tag open van het type block?
if(empty($aOpen) === true)
{
$bNodeInline = $this->aTags[$aNode['tag']]['solid'];
}
}
else if($aNode['type'] == 'text' && empty($aOpen) === true && empty($aNode['text']) === false)
{
$bNodeInline = false;
}
# Stopt de tekst als een item in de tekst array.
if($bSolid !== $bNodeInline && $this->realEmpty($sText) === false)
{
$this->aText[($bSolid === false ? 'i' : 'b').$i] = trim($sText);
$sText = '';
$i++;
}
# Update het vorige type naar het huidige.
$bSolid = $bNodeInline;
}
if(isset($aNode['tag']) === true && isset($this->aTags[$aNode['tag']]) === true)
{
if($aNode['tag'] == $sStopTag)
{
$this->bChangeSolid = true;
return $sText;
}
else
{
if(method_exists($this, $aNode['tag']) === true)
{
if($this->bParse === true)
{
$sText .= $this->$aNode['tag']($aNode);
}
else
{
$sText .= $aNode['text'];
}
}
}
}
else
{
$sText .= $aNode['text'];
}
# Zet de tekst in array formaat als dit aan staat.
if($this->bParagraphise === true && $iLevel == 0)
{
# Is het een tag?
if(isset($aNode['tag']) === true && isset($this->aTags[$aNode['tag']]) === true)
{
if(isset($this->aTags[$aNode['tag']]['master']) === true)
{
$this->aText['b'.$i] = trim($sText);
$sText = '';
$i++;
$aOpen = array();
$iOpen = 0;
}
else
{
# Er is een tag geopend van het type block.
if($aNode['type'] == 'open' && $this->aTags[$aNode['tag']]['solid'] === true)
{
if(empty($aOpen) === true)
{
$aOpen = $aNode;
}
# Is het dezelfde tag als de geen die al open is?
if($aNode['tag'] == $aOpen['tag'])
{
$iOpen++;
}
}
# Er is een tag gesloten van het type block.
if(($aNode['type'] == 'close' && $this->aTags[$aNode['tag']]['solid'] === true && empty($aOpen) === false && $aNode['tag'] == $aOpen['tag']) || $this->bChangeSolid === true)
{
$this->bChangeSolid = false;
$iOpen--;
if($iOpen == 0 && $this->realEmpty($sText) === false)
{
$this->aText[($bSolid === false ? 'i' : 'b').$i] = trim($sText);
$sText = '';
$i++;
$aOpen = array();
}
}
}
}
}
}
# Als paragrafen aanmaken aanstaat, maak dan paragrafen om de teksten.
if($this->bParagraphise === true && $iLevel == 0)
{
# Het overgebleven geparsde tekst toevoegen aan de tekst array.
if($this->realEmpty($sText) === false)
{
$this->aText[($bSolid === false ? 'i' : 'b').$i] = $sText;
}
# Zorg ervoor dat er paragrafen komen.
$this->sText = '';
foreach($this->aText as $sKey => $sText)
{
if($sKey{0} == 'i')
{
$this->sText .= $this->paragraphise($sText);
}
else
{
$this->sText .= $sText;
}
}
}
else
{
$this->sText = $sText;
}
}
private function paragraphise($sText)
{
$aParagraphs = explode("\\n\\n", $sText);
$sText = '';
foreach($aParagraphs as $sParagraph)
{
$sText .= '<p>'.str_replace("\\n", '<br />', trim($sParagraph)).'</p>';
}
return $sText;
}
private function basic($aNode, $sTag)
{
if($aNode['type'] == 'open')
{
return '<'.$sTag.'>';
}
else
{
return '</'.$sTag.'>';
}
}
private function b($aNode)
{
return $this->basic($aNode, 'strong');
}
private function i($aNode)
{
return $this->basic($aNode, 'em');
}
private function u($aNode)
{
return $this->basic($aNode, 'ins');
}
private function s($aNode)
{
return $this->basic($aNode, 'del');
}
private function sub($aNode)
{
return $this->basic($aNode, 'sub');
}
private function sup($aNode)
{
return $this->basic($aNode, 'sup');
}
private function a($aNode)
{
if($aNode['type'] == 'open')
{
if(isset($aNode['attributes'][$aNode['tag']]) === true)
{
$sHref = $aNode['attributes'][$aNode['tag']];
if(strpos($sHref, 'http://') === false)
{
$sHref = 'http://'.$sHref;
}
}
else
{
$sHref = '#';
}
return '<a href="'.$sHref.'">';
}
else
{
return '</a>';
}
}
private function search($aNode)
{
$sSearch = $this->parse('search');
return 'Google zoekopdracht: <a href="http://www.google.nl/search?q='.$sSearch.'">'.$sSearch.'</a>';
}
private function h2($aNode)
{
return $this->basic($aNode, 'h2');
}
private function h3($aNode)
{
return $this->basic($aNode, 'h3');
}
private function h4($aNode)
{
return $this->basic($aNode, 'h4');
}
private function h5($aNode)
{
return $this->basic($aNode, 'h5');
}
private function h6($aNode)
{
return $this->basic($aNode, 'h6');
}
private function ol($aNode)
{
return $this->basic($aNode, 'ol');
}
private function ul($aNode)
{
return $this->basic($aNode, 'ul');
}
private function li($aNode)
{
return $this->basic($aNode, 'li');
}
private function table($aNode)
{
return $this->basic($aNode, 'table');
}
private function tr($aNode)
{
return $this->basic($aNode, 'tr');
}
private function th($aNode)
{
return $this->basic($aNode, 'th');
}
private function td($aNode)
{
return $this->basic($aNode, 'td');
}
private function img($aNode)
{
$this->bParse = false;
$sIMG = $this->parse('img');
$this->bParse = true;
return '<img src="'.stripslashes($sIMG).'" alt="Kon niet weergegeven worden" />';
}
private function hr($aNode)
{
if($aNode['type'] == 'open')
{
return '<hr />';
}
}
private function blockquote($aNode)
{
//return $this->basic($aNode, 'blockquote');
}
private function code($aNode)
{
$this->bParse = false;
$sCode = $this->parse('code');
$this->bParse = true;
$sCode = str_replace("<br>", "", $sCode);
$sCode = str_replace("<br />", "", $sCode);
$sCode = str_replace(">", ">", $sCode);
$sCode = str_replace("<", "<", $sCode);
$sCode = str_replace(""", "\\"", $sCode);
$sCode = str_replace("&", "&", $sCode);
$sCode = str_replace('$', '\$', $sCode);
$sCode = str_replace('\\n', '\\\\n', $sCode);
$sCode = str_replace('\\r', '\\\\r', $sCode);
$sCode = str_replace('\\t', '\\\\t', $sCode);
$sCode = str_replace(':)', ':)', $sCode);
$lines = explode(PHP_EOL, trim($sCode));
$i=1;
$code = '<br/>
<div class="Code">
<div class="Code_Titel">PHP code</div>
<div class="Left">';
foreach ($lines as $line)
{
$code .= $i.'<br />';
$i++;
}
$code .= '</div>
<div class="Right">
'.highlight_string(stripslashes(trim($sCode)), true).'
</div>
</div>
<br/>';
return $code;
}
static public function execute($sText)
{
$oParser = new ubb($sText);
$oParser->getPieces();
$oParser->createTree();
$oParser->validateTree();
$oParser->parse();
echo $oParser->sText;
return noXSS($oParser->sText);
}
}
function noXSS($sString)
{
return stripslashes(preg_replace('#(href|src)=(\\'|\\")(.+?)(\\'|\\")( |>)#ise', "'\\\\1=\\\\2'.removeJavascript('\\\\3').'\\\\4\\\\5'", $sString));
}
function removeJavascript($sString)
{
$sReturn = '#';
$sCheck = str_replace(array("\\n", ' '), '', stripslashes(strip_tags(html_entity_decode(trim(strtolower($sString))))));
$bEvil = false;
$aEvil = array('javascript:', 'onfocus=', 'onblur=', 'onclick=', 'ondblclick=', 'onmousedown=', 'onmouseup=', 'onmouseover=', 'onmousemove=', 'onmouseout=', 'onkeypress=', 'onkeydown=', 'onkeyup=');
foreach($aEvil as $sEvil)
{
if(strpos($sCheck, $sEvil) !== false)
{
$bEvil = true;
break;
}
}
if($bEvil === false)
{
$sReturn = $sString;
}
return $sReturn;
}
?>hij moet erin komen bij de blockquote.
Hopelijk kan iemand me hiermee helpen.