View difference between Paste ID: KqcX24FC and aQEbdw4j

 <?php
 /*!
  * @file bbcode.php
  *
  * A BBCode tag is defined in terms of two parameters, a parse type,
  * and an argument count. The parse type, "type", is given by one of
  * the tag type ("TT_") constants.
  *
  * The argument count, "args", is in the range [0,4]. A zero-argument tag
  * does not have an end tag. A one-argument tag has its argument between
  * the start and end tag. A two-element tag is identical to a one-argument
  * tag with the advent of an =arg1 in the opening tag, eg,
  *   [url=arg1]arg0[/url]
  * A three-argument tag is given an additional parameter at tag close.
  * A four-element tag actually has unlimited arguments and operates as
  * an HTML tag. The parameters are passed in an associative array to
  * a callback, which is the only valid type for this count.
  *
  * Tags also contain an "enclosed" flag which denotes what is wrapped
  * inside the tags; this is one of the content type ("CT_") constants.
  *
  * From an implementation perspective, the argument count controls how
  * the tag is decomposed into memory, ie, parsed. The type determines
  * how the tag is evaluated after parse finishes. The argument count is
  * used in evaluation to pass the correct number of parameters, but the
  * type is not considered during parse, at all.
  *
  * Other notes: Tag names may not contain spaces or "=".
  *
  * @section License
  *
  * Copyright (C) 2014 Josh Ventura <josh at dreamland im>
  *
  * This file is a BBCode parser. Permission is hereby granted,
  * free of charge, to any person obtaining a copy of this software
  * and associated documentation files (the "Software"), to deal in
  * the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute,
  * sublicense, and/or sell copies of the Software, and to permit
  * persons to whom the Software is furnished to do so, subject to
  * the following conditions:
  *
  * The above copyright notice and this permission notice shall be
  * included in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
  * OR OTHER DEALINGS IN THE SOFTWARE.
  *
  * Amen.
 */
 
 const TT_TRIVIAL = 0;    ///< This tag is a direct HTML wrapper tag
 const TT_INTERLEAVE = 1; ///< This tag becomes "html"[0] . arg0 . "html"[1] . arg1 ...
 const TT_CALLBACK = 2;   ///< This tag gets evaluated by a callback function
 
 const CT_MARKDOWN = 0; ///< The inside of the tag is Markdown-format text as non-BB. This is the default.
 const CT_RAW = 1; ///< The inside of the tag is raw data and should not be formatted.
 
 include('tags.php');
 
 function notice($s) { echo "<!-- Notice: $s -->\n"; }
 
 /*!
  * This is a recursive function; call it with i = 0, and it will
  * call itself recursively until all tags are parsed. It returns the
  * parsed string, with $i set to the position of the first-read closing tag.
  * @param  $str  The string to parse.
  * @param  $i    [in/out] The position from which to start parsing.
  *               Set at the end of the function to denote the first
  *               unparsed character, or FALSE if all characters have
  *               been consumed.
  * @return Returns the HTML parsed substring of the given input.
 */
 function parse_sub($str, &$i, $contenttype, $opentags)
 {
   global $bbtags;
   $outstr = "";
   $bookmark = $i;
   for ($i = strpos($str, '[', $i); $i !== FALSE; $i = strpos($str, '[', $i))
   {
     $close = strpos($str, ']', $i + 1);
     if ($close == FALSE) {
       $i = FALSE;
       break;
     }
 
     // Look inside our tag, now
     $stag = substr($str, $i+1, $close - $i - 1);
 
     // If it's a closing tag, return and let the parent handle that
     if ($stag[0] == '/')
       return $outstr . parse_nonbb(substr($str, $bookmark, $i - $bookmark), $contenttype);
 
     if ($contenttype == CT_RAW) {
       ++$i;
       continue;
     }
 
-    // Doplegänger
+    // Dopplegänger
-    if ($stag[0] == '[') {
+    $doppl = strpos($stag, '[');
     if ($doppl !== FALSE) {
       $i += $doppl + 1;
       continue;
     }
 
     // Make sure we're safe if args=1; we don't know, yet
     $tagc = preg_split('/\s*[\s=]\s*/', $stag, 2);
     if (count($tagc) == 2)
       $arg1 = $tagc[1]; // This technically allows [tag x]y[/tag]
     else
       $arg1 = NULL; // Don't reuse old arg values
     $tname = strtolower($tagc[0]); // Deliberately not trimmed
 
     // Look up tag
     $tstart = $i;
     $i = $close + 1;
     if (!array_key_exists($tname, $bbtags)) {
       notice("No bbtag called [$tname] ($stag)");
       continue;
     }
 
     // Tag found
     $bbtag = $bbtags[$tname];
     if ($bbtag['args'] > 0)
     {
       $tlen = strlen($tname) + 2;
 
       // Handle associative tags
       if ($bbtag['args'] > 3)
       {
         $i = $tstart + $tlen;
         if (ctype_space($str[$i-1])) {
           $args = read_attr_list($str, $i);
           if ($args === NULL) { // Bail on failure
             $i = FALSE;
             return $outstr . parse_nonbb(substr($str, $bookmark), $contenttype);
           }
           ++$i;
         }
         else if ($str[$i-1] == ']')
           $args = array();
         else continue;
       }
       else {
         $args = NULL;
         if ($bbtag['args'] == 1 && $str[$tstart + $tlen - 1] != ']') {
           notice("$str [$tstart+$tlen-1] != ']'");
           continue;
         }
       }
 
       $arg0 = '';
       $stend = $i;
       for (;;)
       {
         // This is where shit gets interesting
         array_push($opentags, $tname);
         $arg0 .= parse_sub($str, $i, isset($bbtag['content'])? $bbtag['content'] : CT_MARKDOWN, $opentags);
         array_pop($opentags);
 
         // Make sure we arrived at a closing tag
         if ($i == FALSE)
           return $outstr . parse_nonbb(substr($str, $bookmark, $stend - $bookmark), $contenttype) . $arg0;
 
         $close = strpos($str, ']', $i);
         $ctag = substr($str, $i, $close - $i);
 
         // Make sure this is *our* closing tag
         if (strncasecmp($ctag, '[/'.$tname, $tlen) != 0)
         {
           // If someone else's closing tag, bail; tags should be closed in order
           foreach ($opentags as $k => $otname)
             if (strncasecmp($ctag, '[/'.$otname, 2 + strlen($otname)) == 0)
               return $outstr . parse_nonbb(substr($str, $bookmark, $stend - $bookmark), $contenttype) . $arg0;
 
           // If not anyone's tag, just keep looking
           $arg0 .= $str[$i++];
           continue;
         }
 
         break;
       }
 
       // Now we have a little more parsing to do for ternary tags
       if ($bbtag['args'] == 3) {
         $arg2 = trim(substr($str, $i + $tlen, $close - $i - $tlen));
         if (strlen($arg2) > 0 && $arg2[0] == '=')
           $arg2 = trim(substr($arg2, 1));
       }
       else
         $arg2 = NULL;
 
       $i = $close + 1;
     }
     else
       $arg0 = $arg1 = $arg2 = $args = NULL;
 
     $outstr .= parse_nonbb(substr($str, $bookmark, $tstart - $bookmark), $contenttype);
     $outstr .= evaluate_tag($tname, $bbtag, $arg0, $arg1, $arg2, $args);
     $bookmark = $i;
   }
   $outstr .= parse_nonbb(substr($str, $bookmark), $contenttype);
   return $outstr;
 }
 
 
 /*! This function might as well be in that last block of code,
  * but it was getting frighteningly big, so I moved it here.
  * @note Unused tag arguments should be NULL; \p $arg1 and \p $arg2 should
  *       never be non-null at the same time as \p $args.
  * @param $tname  The name of the tag.
  * @param $bbtag  The tag array from the \c bbtags array.
  * @param $arg0   The first argument, the text between the tags, if applicable.
  * @param $arg1   The second argument, the = value in the opening tag, if applicable.
  * @param $arg2   The third argument, the = value in the closing tag, if applicable.
  * @param $args   An associative array of arguments, if applicable.
  * @return Returns the result of evaluating the tag;
  *         a string with which to replace the tag.
 */
 function evaluate_tag($tname, $bbtag, $arg0, $arg1, $arg2, $args) {
   switch ($bbtag['type'])
   {
     case TT_TRIVIAL: switch ($bbtag['args']) {
       case 0:  return "<$tname />";
       case 1:  return "<$tname>$arg0</$tname>";
       case 2:  return "<!-- This tag is invalid -->";
       case 3:  return "<!-- This tag is invalid -->";
       default: return "<!-- This tag would be a security risk -->";
     }
     case TT_INTERLEAVE: $h = $bbtag['html']; switch ($bbtag['args']) {
       case 0:  return $h[0];
       case 1:  return $h[0] . $arg0 . $h[1];
       case 2:  return $h[0] . $arg1 . $h[1] . $arg0 . $h[2];
       case 3:  return $h[0] . $arg1 . $h[1] . $arg0 . $h[2] . $arg2 . $h[3];
       default: return "<!-- This tag cannot be automated -->";
     }
     case TT_CALLBACK: $f = $bbtag['func']; switch ($bbtag['args']) {
       case 0:  return $f();
       case 1:  return $f($arg0);
       case 2:  return $f($arg0, $arg1);
       case 3:  return $f($arg0, $arg1, $arg2);
       default: return $f($arg0, $args);
     }
   }
 }
 
 
 /*! This nonsense is to parse associative tags.
  * @param $str The string from which to read attributes.
  * @param $i   [in/out] The position from which to start reading.
  *             Set at end of function call to denote the end of the list.
  * @return  Returns the associative array read in from the string.
 */
 function read_attr_list($str, &$i) {
   $len = strlen($str);
   $attrs = array();
   while ($i < $len && $str[$i] != ']')
   {
     if (ctype_space($str[$i])) {
       ++$i;
       continue;
     }
 
     // Read an attribute name
     $attr_start = $i;
     while (++$i < $len && $str[$i] != '=' && !ctype_space($str[$i]));
     $attr_name = substr($str, $attr_start, $i-$attr_start);
 
     if ($i >= $len) // Bail if out of bounds
       { notice("OOB0: '$attr_name'"); return NULL; }
 
     // Read past the attribute name
     while ($i < $len && ctype_space($str[$i]))
       { notice("white: '" . $str[$i] . "'"); ++$i; }
     if ($i >= $len) // Bail if out of bounds
       { notice("OOB1: '$attr_name'"); return NULL; }
 
     if ($str[$i] == '=')
     {
       while (++$i < $len && ctype_space($str[$i]));
       if ($str[$i] == '"' || $str[$i] == '\'')
       {
         $val_start = $i + 1;
         $ochar = $str[$i];
         while (++$i < $len && $str[$i] != $ochar)
           if ($str[$i] == '\\') ++$i;
         if ($i >= $len)
           { notice("OOB2"); return NULL; }
         $val = str_replace(
           array("\\\\", "\\\'", "\\\"", "\\r", "\\n", "\\t"),
           array("\\",     "\'",   "\"",   "\r",  "\n", "\t"),
           substr($str, $val_start, $i - $val_start)
         );
         ++$i;
       }
       else {
         $val_start = $i;
         while (++$i < $len && $str[$i] != ']' && !ctype_space($str[$i]));
         if ($i >= $len)
           { notice("OOB3"); return NULL; }
         $val = substr($str, $val_start, $i - $val_start);
       }
     }
     else {
       $val = NULL;
       ++$i;
     }
     $attrs[$attr_name] = $val;
   }
   return $attrs;
 }
 
 /*!
  * Parse for non-BBCode elements, such as URLs or (God forbid) Markdown.
  * @param $str  HTML-escaped plain text input.
  * @return  Returns HTML-formatted parsed text.
 */
 function parse_nonbb($str, $contenttype)
 {
   if ($contenttype != CT_MARKDOWN)
     return $str;
 
   $urlexp = "/(?i)\b("
     . "(?:https?:\/\/|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}\/)"
     . "(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+"
     . "(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'\".,<>?«»“”‘’])"
   .")/";
   return preg_replace($urlexp, "<a href=\"$1\">$1</a>", $str);
   return $str;
 }
 
 /*! Main BBCode parser call.
  * @param  $str  The BBCode string to parse.
  * @return Returns the HTML parsed version of the input.
 */
 function parse_bbcode($str) {
   $i = 0;
   $res = "";
   while ($i !== false) {
     $res .= parse_sub($str, $i, CT_MARKDOWN, array());
     if ($i !== false)
       $res .= $str[$i++];
   }
   return $res;
 }
 
 $test = "
 [b]Bold[/b]
 [assoc one=\"two\" two=\"four\" three=eight four=sixteen]yes[/assoc]
 [/code]
 www.google.com
 
 [b]this should be[i] bold[/b]
 [b]this should not be, but this should be: [b] bold[/b]
 
 [hr]
 
 [ [b]bold[/b] ]
 [ [b]bold[/b] ]
 
 http://google.com/
 www.google.com [
 ";
 
 echo "=================================\nTest:\n=================================\n" . $test . "\n";
 echo "=================================\nResult:\n=================================\n";
 echo parse_bbcode($test);
 
 ?>