Ticket #14481: shortcode.patch

shortcodes.php

@@ -1 +1 @@
 <?php
-/**
- * WordPress API for creating bbcode like tags or what WordPress calls
- * "shortcodes." The tag and attribute parsing or regular expression code is
- * based on the Textpattern tag parser.
- *
- * A few examples are below:
- *
- * [shortcode /]
- * [shortcode foo="bar" baz="bing" /]
- * [shortcode foo="bar"]content[/shortcode]
- *
- * Shortcode tags support attributes and enclosed content, but does not entirely
- * support inline shortcodes in other shortcodes. You will have to call the
- * shortcode parser in your function to account for that.
- *
- * {@internal
- * Please be aware that the above note was made during the beta of WordPress 2.6
- * and in the future may not be accurate. Please update the note when it is no
- * longer the case.}}
- *
- * To apply shortcode tags to content:
- *
- * <code>
- * $out = do_shortcode($content);
- * </code>
- *
- * @link http://codex.wordpress.org/Shortcode_API
- *
- * @package WordPress
- * @subpackage Shortcodes
- * @since 2.5
- */
+/*
+Author: Jacob Beauregard (jrbeaure at uvm dot edu)
+*/
 
+/*
+
+From Test Cases (http://svn.automattic.com/wordpress-tests/wp-testcase/test_shortcode.php)
+==========================================================================================
+Shortcode Statuses (to implement, or not to implement?)
+        enabled = the shortcode works as normal (default)
+        strip = the shortcode will be parsed and removed.  e.g. '[shortcode foo="bar"]' produces ''.  '[shortcode]foo[/shortcode]' produces 'foo'.
+        faux = the shortcode will be abbreviated.  e.g. '[shortcode foo="bar"]' products '[shortcode]'.  '[shortocde]foo[/shortcode]' produces '[shortcode]'
+        disabled = the shortcode is not parsed at all.  e.g. '[shortcode foo="bar"]' products '[shortcode foo="bar"]'
+
+
+Major Differences/Improvements:
+===============================
+I. Addressing http://codex.wordpress.org/Shortcode_API#Limitations
+
+        1. You can nest any tag at any depth regardless of ancestors (Ticket #10702)
+
+        2. Tag and attribute names may match /[A-Za-z][-A-Za-z0-9_:.]*//* (trialing /* because that comment ends),
+           with case-insensitive interpretation
+
+        3. Interpretation doesn't get tripped up by things like hyphens
+
+II. Addressing Ticket #12760, 
+
+        1. Changed from fix in #6518
+           Reasoning: balancing double-square-brackets can have misleading results with nesting
+
+        2. Shortcodes escapable by using [[, ]]
+
+        3. ']]' is escaped "right to left", so '[shortcode]]]' would evaluate to 'result]'
+
+        4. '[[' is escaped left to right '[[[shortcode]]]' => '[result]'
+
+III. Enhancements
+
+        1. Only matches valid shortcode for registered hooks, everything else will appear as text
+
+        2. Can register multiple hooks to single shortcode, uses priority (default: 10)
+
+IV. Conflicting Design Changes
+
+        1. Quoted literals are escaped by entities rather than cslashes
+
+        2. Inline (self-closing) shortcodes get passed content to accomodate multiple callbacks
+
+        3. No equivalent to shortcode_parse_atts function 
+           (Not marked private in function reference, but not documented in shortcode API page)
+
+        4. Boolean attributes take the place of positional attributes 
+           [foo bar] gets attributes array('bar' => 'bar') instead of array('0' => 'bar')
+
+        5. Disallows attribute and tag names that don't match /[A-Za-z][-A-Za-z0-9_:.]*/ 
+
+//pardon me /*
+
+        6. Disallows unquoted attribute values, unless they match /[-A-Za-z0-9_:.]+/
+
+
+VI. Addressing Tickets #9264, #10082 (see following, `Basic Interpretation Method`)
+
+
+Basic Interpretation Method:
+============================
+1. If an open tag is encountered, it is added to the stack
+
+2. If a close tag is encountered and there is no matching open tag on the stack
+   the close tag is ignored
+
+3. If a close tag is encountered and there is a matching open tag on the stack
+   all opened tags on the stack before the matched tag will be implicitly self-closed
+
+4. If text or an inline tag is encountered, it will be evaluated to its parent's
+   content immediately
+
+5. If tags are not closed by the end of the interpretation, they will be implicitly
+   self-closed
+
+
+Issues:
+=======
+1. Haven't written new unit tests to reflect new functionality added
+
+2. Documentation is not as good (though I hope most of the code is self-explanatory)
+
+3. Not 100% backwards compatible
+
+*/
+
+/* +++++ PUBLIC FUNCTIONS ++++++ */
+
 /**
- * Container for storing shortcode tags and their hook to call for the shortcode
- *
- * @since 2.5
- * @name $shortcode_tags
- * @var array
- * @global array $shortcode_tags
- */
-$shortcode_tags = array();
+ * add hook for shortcode tag
+*/
+function add_shortcode($name,$handler,$priority=10) {
+        $name = strtolower($name);
+        shortcode_register_set('priority',$name,$handler,$priority);
+        shortcode_register_set('callback',$name,$priority,$handler,true);
+}
 
 /**
- * Add hook for shortcode tag.
- *
- * There can only be one hook for each shortcode. Which means that if another
- * plugin has a similar shortcode, it will override yours or yours will override
- * theirs depending on which order the plugins are included and/or ran.
- *
- * Simplest example of a shortcode tag using the API:
- *
- * <code>
- * // [footag foo="bar"]
- * function footag_func($atts) {
- *      return "foo = {$atts[foo]}";
- * }
- * add_shortcode('footag', 'footag_func');
- * </code>
- *
- * Example with nice attribute defaults:
- *
- * <code>
- * // [bartag foo="bar"]
- * function bartag_func($atts) {
- *      extract(shortcode_atts(array(
- *              'foo' => 'no foo',
- *              'baz' => 'default baz',
- *      ), $atts));
- *
- *      return "foo = {$foo}";
- * }
- * add_shortcode('bartag', 'bartag_func');
- * </code>
- *
- * Example with enclosed content:
- *
- * <code>
- * // [baztag]content[/baztag]
- * function baztag_func($atts, $content='') {
- *      return "content = $content";
- * }
- * add_shortcode('baztag', 'baztag_func');
- * </code>
- *
- * @since 2.5
- * @uses $shortcode_tags
- *
- * @param string $tag Shortcode tag to be searched in post content.
- * @param callable $func Hook to run when shortcode is found.
- */
-function add_shortcode($tag, $func) {
-        global $shortcode_tags;
+ * remove hook for shortcode tag
+*/
+function remove_shortcode($name,$handler) {
+        $name = strtolower($name);
+        $priority = shortcode_register_get('priority',$name,$handler);
 
-        if ( is_callable($func) )
-                $shortcode_tags[$tag] = $func;
+        shortcode_register_unset('priority',$name,$handler);
+        shortcode_register_unset('callback',$name,$priority,$handler);
 }
 
 /**
- * Removes hook for shortcode.
- *
- * @since 2.5
- * @uses $shortcode_tags
- *
- * @param string $tag shortcode tag to remove hook for.
- */
-function remove_shortcode($tag) {
-        global $shortcode_tags;
+ * check if handler is hooked to shortcode tag, returns priority
+*/
+function has_shortcode($name,$handler) {
+        $name = strtolower($name);
+        return shortcode_register_get('priority',$name,$handler);
+}
 
-        unset($shortcode_tags[$tag]);
+/**
+ * removes all shortcode hooks
+*/
+function remove_all_shortcodes($name) {
+        $name = strtolower($name);
+        shortcode_register_unset('priority',$name);
+        shortcode_register_unset('callback',$name);
 }
 
 /**
- * Clear all shortcodes.
- *
- * This function is simple, it clears all of the shortcode tags by replacing the
- * shortcodes global by a empty array. This is actually a very efficient method
- * for removing all shortcodes.
- *
- * @since 2.5
- * @uses $shortcode_tags
- */
-function remove_all_shortcodes() {
-        global $shortcode_tags;
+ * retrieves all shortcode hooks associated with a tag
+ * returns order FCFS by priority
+*/
+function get_shortcodes($name) {
+        $name = strtolower($name);
+        $priority_groups = shortcode_register_get('callback',$name);
+        $callbacks = array();
+        if (is_array($priority_groups)) {
+                foreach ($priority_groups as $priority_group) {
+                        $callbacks = array_merge($callbacks,$priority_group);
+                }
+        }
+        return array_keys($callbacks);
+}
 
-        $shortcode_tags = array();
+/**
+ * executes the shortcode hooks for the shortcode tag with specified attributes
+ * initial content is $content, but is actively modified by each handler
+*/
+function apply_shortcodes($attrs,$content,$name) {
+        $name = strtolower($name);
+        $callbacks = get_shortcodes($name);
+
+        if (is_array($callbacks)) {
+                foreach ($callbacks as $callback) {
+                        if (function_exists($callback)) {
+                                $content = $callback($attrs,$content,$name);
+                        }
+                }
+        }
+
+        return $content;
 }
 
 /**
- * Search content for shortcodes and filter shortcodes through their hooks.
- *
- * If there are no shortcode tags defined, then the content will be returned
- * without any filtering. This might cause issues when plugins are disabled but
- * the shortcode will still show up in the post or content.
- *
- * @since 2.5
- * @uses $shortcode_tags
- * @uses get_shortcode_regex() Gets the search pattern for searching shortcodes.
- *
- * @param string $content Content to search for shortcodes
- * @return string Content with shortcodes filtered out.
- */
-function do_shortcode($content) {
-        global $shortcode_tags;
+ * removes shortcodes with registered handlers from page
+*/
+function strip_shortcodes($content) {
+        $sc_re = "/" . shortcode_re_combine(array('tag_inline','tag_open','tag_close')) . "/";
+        $content = preg_replace($sc_re,'',$content);
+        return $content;
+}
 
-        if (empty($shortcode_tags) || !is_array($shortcode_tags))
-                return $content;
+/**
+ * alias of array_merge, unless we want to special case positional attributes
+*/
+function shortcode_atts($defaults, $attrs) {
+        return array_merge($defaults, $attrs);
+}
 
-        $pattern = get_shortcode_regex();
-        return preg_replace_callback('/'.$pattern.'/s', 'do_shortcode_tag', $content);
+/* run main eval function */
+function do_shortcode($expr) {
+        return shortcode_eval($expr);
 }
 
+
+
+/* +++++++++++++ THE UNDERPINNINGS +++++++++++ */
+
 /**
- * Retrieve the shortcode regular expression for searching.
- *
- * The regular expression combines the shortcode tags in the regular expression
- * in a regex class.
- *
- * The regular expresion contains 6 different sub matches to help with parsing.
- *
- * 1/6 - An extra [ or ] to allow for escaping shortcodes with double [[]]
- * 2 - The shortcode name
- * 3 - The shortcode argument list
- * 4 - The self closing /
- * 5 - The content of a shortcode when it wraps some content.
- *
- * @since 2.5
- * @uses $shortcode_tags
- *
- * @return string The shortcode search regular expression
- */
-function get_shortcode_regex() {
-        global $shortcode_tags;
-        $tagnames = array_keys($shortcode_tags);
-        $tagregexp = join( '|', array_map('preg_quote', $tagnames) );
+ * retrieves all shortcode tags that have at least one registered hook
+*/
+function shortcode_tags() {
+        $tags = array_keys(shortcode_register_get('callback'));
+        return $tags;
+}
 
-        // WARNING! Do not change this regex without changing do_shortcode_tag() and strip_shortcodes()
-        return '(.?)\[('.$tagregexp.')\b(.*?)(?:(\/))?\](?:(.+?)\[\/\2\])?(.?)';
+/**
+ * keeps track of information shared between many shortcode functions
+*/
+//I'm at war with global variables, so I used a static variable instead.
+function shortcode_register($assignment=null) {
+        static $register = array();
+        if ($assignment !== null) {
+                $register = $assignment;
+        }
+        return $register;
 }
 
 /**
- * Regular Expression callable for do_shortcode() for calling shortcode hook.
- * @see get_shortcode_regex for details of the match array contents.
- *
- * @since 2.5
- * @access private
- * @uses $shortcode_tags
- *
- * @param array $m Regular expression match array
- * @return mixed False on failure.
- */
-function do_shortcode_tag( $m ) {
-        global $shortcode_tags;
+ * gets a value from the register based on attributes
+*/
+function shortcode_register_get() {
+        $arguments = func_get_args();
+        $register  = shortcode_register();
 
-        // allow [[foo]] syntax for escaping a tag
-        if ( $m[1] == '[' && $m[6] == ']' ) {
-                return substr($m[0], 1, -1);
+        $value = $register;
+        while (count($arguments) && $value != null) {
+                $key = array_shift($arguments);
+                if (isset($value[$key])) {
+                        $value = $value[$key];
+                } else {
+                        $value = null;
+                }
         }
+        return $value;
+}
 
-        $tag = $m[2];
-        $attr = shortcode_parse_atts( $m[3] );
+/**
+ * sets a value in the register
+*/
+function shortcode_register_set() {
+        $arguments = func_get_args();
+        $register  = shortcode_register();
+        $value     = array_pop($arguments);
 
-        if ( isset( $m[5] ) ) {
-                // enclosing tag - extra parameter
-                return $m[1] . call_user_func( $shortcode_tags[$tag], $attr, $m[5], $tag ) . $m[6];
-        } else {
-                // self-closing tag
-                return $m[1] . call_user_func( $shortcode_tags[$tag], $attr, NULL,  $tag ) . $m[6];
+        $group =& $register;
+        while (count($arguments)) {
+                $key = array_shift($arguments);
+                if (!is_array($group[$key])) {
+                        $group[$key] = array();
+                }
+                $group =& $group[$key];
         }
+        $group = $value;
+        shortcode_register($register);
 }
 
 /**
- * Retrieve all attributes from the shortcodes tag.
- *
- * The attributes list has the attribute name as the key and the value of the
- * attribute as the value in the key/value pair. This allows for easier
- * retrieval of the attributes, since all attributes have to be known.
- *
- * @since 2.5
- *
- * @param string $text
- * @return array List of attributes and their value.
- */
-function shortcode_parse_atts($text) {
-        $atts = array();
-        $pattern = '/(\w+)\s*=\s*"([^"]*)"(?:\s|$)|(\w+)\s*=\s*\'([^\']*)\'(?:\s|$)|(\w+)\s*=\s*([^\s\'"]+)(?:\s|$)|"([^"]*)"(?:\s|$)|(\S+)(?:\s|$)/';
-        $text = preg_replace("/[\x{00a0}\x{200b}]+/u", " ", $text);
-        if ( preg_match_all($pattern, $text, $match, PREG_SET_ORDER) ) {
-                foreach ($match as $m) {
-                        if (!empty($m[1]))
-                                $atts[strtolower($m[1])] = stripcslashes($m[2]);
-                        elseif (!empty($m[3]))
-                                $atts[strtolower($m[3])] = stripcslashes($m[4]);
-                        elseif (!empty($m[5]))
-                                $atts[strtolower($m[5])] = stripcslashes($m[6]);
-                        elseif (isset($m[7]) and strlen($m[7]))
-                                $atts[] = stripcslashes($m[7]);
-                        elseif (isset($m[8]))
-                                $atts[] = stripcslashes($m[8]);
+ * unsets/deletes a value from the register
+*/
+function shortcode_register_unset() {
+        $arguments = func_get_args();
+        $register = short_code_register();
+        $group =& $register;
+
+        $exists = true;
+        while (count($arguments) > 1 && !$exists) {
+                $key = array_shift($arguments);
+                if (!is_array($group[$key])) {
+                        $exists = false;
+                } else {
+                        $group =& $group[$key];
                 }
-        } else {
-                $atts = ltrim($text);
         }
-        return $atts;
+        if ($exists) {
+                $key = array_shift($arguments);
+                unset($group[$key]);
+        }
+        shortcode_register($register);
 }
 
+/*
+ * types of shortcodes to be parsed
+*/
+function shortcode_types() {
+        return array(
+                'esc_lsqbr',
+                'esc_rsqbr',
+                'tag_inline',
+                'tag_open',
+                'tag_close',
+                'attr',
+                'literal',
+                'entity_ref',
+                'char_ref',
+                'char_str',
+                'name',
+                'text'
+        );
+}
+
+/*
+ * subtypes of a root (raw) expression
+*/
+function shortcode_sub_root() {
+        return array('esc_rsqbr','esc_lsqbr','tag_inline','tag_open','tag_close','text');
+}
+
+/*
+ * subtypes of a tag_inline expression
+*/
+function shortcode_sub_tag_inline() {
+        return array('attr','name');
+}
+
+/*
+ * i bet you get the point by now
+*/
+function shortcode_sub_tag_open() {
+        return array('attr','name');
+}
+
+function shortcode_sub_tag_close() {
+        return array('name');
+}
+
+function shortcode_sub_text() {
+        return null;
+}
+
+function shortcode_sub_name() {
+        return null;
+}
+
+function shortcode_sub_attr() {
+        return array('literal','name');
+}
+
+function shortcode_sub_literal() {
+        return array('char_ref','entity_ref','char_str');
+}
+
+function shortcode_sub_char_str() {
+        return null;
+}
+
+function shortcode_sub_char_ref() {
+        return null;
+}
+
+function shortcode_sub_entity_ref() {
+        //formally it's a name, but it's easier to interpret it with the & and ;
+        return null; //array('name');
+}
+
+function shortcode_sub_esc_lsqbr() {
+        return null;
+}
+
+function shortcode_sub_esc_rsqbr() {
+        return null;
+}
+
 /**
- * Combine user attributes with known attributes and fill in defaults when needed.
- *
- * The pairs should be considered to be all of the attributes which are
- * supported by the caller and given as a list. The returned attributes will
- * only contain the attributes in the $pairs list.
- *
- * If the $atts list has unsupported attributes, then they will be ignored and
- * removed from the final returned list.
- *
- * @since 2.5
- *
- * @param array $pairs Entire list of supported attributes and their defaults.
- * @param array $atts User defined attributes in shortcode tag.
- * @return array Combined and filtered attribute list.
- */
-function shortcode_atts($pairs, $atts) {
-        $atts = (array)$atts;
-        $out = array();
-        foreach($pairs as $name => $default) {
-                if ( array_key_exists($name, $atts) )
-                        $out[$name] = $atts[$name];
-                else
-                        $out[$name] = $default;
+ * returns subtypes of type specified by $type
+*/
+function shortcode_sub($type='root') {
+        if (in_array($type,shortcode_types()) || $type == 'root') {
+                $func = "shortcode_sub_{$type}";
+                $subtypes = $func();
         }
-        return $out;
+        return $subtypes;
 }
 
+
+// started writing backwards compatibility function
+// but would really prefer not to support these
+
+function shortcode_re_compat_name($named=false) {
+        $expr = '\w+';
+        if ($named) {
+                $expr = "(?P<compat_name>{$expr})";
+        }
+        return $expr;
+}
+
+function shortcode_re_compat_literal($named=false) {
+        $nq = shortcode_re_compat_literal_nq();
+        $sq = shortcode_re_compat_literal_sq();
+        $dq = shortcode_re_compat_literal_dq();
+        $expr = "(?:{$nq}|{$sq}|{$dq})";
+        if ($named) {
+                $expr = "(?P<compat_literal>{$expr})";
+        }
+        return $expr;
+}
+
+function shortcode_re_compat_literal_dq() {
+        $expr = '"[^"]*"';
+        return $expr;
+}
+
+function shortcode_re_compat_literal_sq() {
+        $expr = "'[^']*'";
+        return $expr;
+}
+
+function shortcode_re_compat_literal_nq() {
+        $expr = '\S+?(?=\])';
+        return $expr;
+}
+
+function shortcode_re_compat_attr($named=false) {
+        $name = shortcode_re_compat_name();
+        $literal = shortcode_re_compat_literal();
+        $expr = "(?:{$name}\\s*=)?\\s*{$literal}";
+        if ($named) {
+                $expr = "(?P<compat_attr>{$expr})";
+        }
+        return $expr;   
+}
+
 /**
- * Remove all shortcode tags from the given content.
- *
- * @since 2.5
- * @uses $shortcode_tags
- *
- * @param string $content Content to remove shortcode tags.
- * @return string Content without shortcode tags.
- */
-function strip_shortcodes( $content ) {
-        global $shortcode_tags;
+ * regular expression to match a valid name
+*/
+function shortcode_re_name($named=false) {
+        $expr = '[A-Za-z][-A-Za-z0-9_:.]*';
+        if ($named) {
+                $expr = "(?P<name>{$expr})";
+        }
+        return $expr;
+}
 
-        if (empty($shortcode_tags) || !is_array($shortcode_tags))
-                return $content;
+/**
+ * regular expression to match a name that's registered as a shortcode
+*/
+function shortcode_re_registered_name($named=false) {
+        $tags = array_map('preg_quote',shortcode_tags());
+        $expr = join('|',$tags);
+        $expr = "(?i:{$expr})";
+        if ($named) {
+                $expr = "(?P<name>{$expr})";
+        }
+        return $expr;
+}
 
-        $pattern = get_shortcode_regex();
+/**
+ * you probably get the point by now
+*/
+function shortcode_re_char_str($named=false) {
+        $expr =  "[^%&]+";
+        if ($named) {
+                $expr = "(?P<char_str>{$expr})";
+        }
+        return $expr;
+}
 
-        return preg_replace('/'.$pattern.'/s', '$1$6', $content);
+/**
+ * single quote version for shortcode_re_char_str
+*/
+function shortcode_re_char_str_sq($named=false) {
+        $expr =  "[^%&']+";
+        if ($named) {
+                $expr = "(?P<char_str>{$expr})";
+        }
+        return $expr;
 }
 
-add_filter('the_content', 'do_shortcode', 11); // AFTER wpautop()
+/**
+ * double quote version for shortcode_re_char_str
+*/
+function shortcode_re_char_str_dq($named=false) {
+        $expr = '[^%&"]+';
+        if ($named) {
+                $expr = "(?P<char_str>{$expr})";
+        }
+        return $expr;
+}
 
-?>
- No newline at end of file
+function shortcode_re_char_ref($named=false) {
+        $expr = "(?:[0-9]+|x[0-9a-fA-F]+)";
+        if ($named) {
+                $expr = "(?P<char_ref>{$expr})";
+        }
+        $expr = "&#{$expr};";
+        return $expr;
+}
+
+function shortcode_re_entity_ref($named=false) {
+        $name = shortcode_re_name();
+
+        $expr = "&{$name};";
+        if ($named) {
+                $expr = "(?P<entity_ref>{$expr})";
+        }
+        return $expr;
+}
+
+function shortcode_re_literal($named=false) {
+        $nq = shortcode_re_literal_nq();
+        $sq = shortcode_re_literal_sq();
+        $dq = shortcode_re_literal_dq();
+        $expr = "(?:{$nq}|{$sq}|{$dq})";
+        if ($named) {
+                $expr = "(?P<literal>{$expr})";
+        }
+        return $expr;
+}
+
+function shortcode_re_literal_nq($named=false) {
+        $expr = "[-a-zA-Z0-9_:.]+";
+        return $expr;
+}
+
+function shortcode_re_literal_sq($named=false) {
+        $char_str = shortcode_re_char_str_sq();
+        $char_ref = shortcode_re_char_ref();
+        $entity_ref = shortcode_re_entity_ref();
+
+        $expr = "'(?:{$char_str}|{$char_ref}|{$entity_ref})*'";
+        return $expr;
+}
+
+function shortcode_re_literal_dq($named=false) {
+        $char_str = shortcode_re_char_str_dq();
+        $char_ref = shortcode_re_char_ref();
+        $entity_ref = shortcode_re_entity_ref();
+
+        $expr =  "\"(?:{$char_str}|{$char_ref}|{$entity_ref})*\"";
+        return $expr;
+}
+
+function shortcode_re_attr($named=false) {
+        $name  = shortcode_re_name();
+        $literal = shortcode_re_literal();
+
+        $expr = "{$name}(?:={$literal})?";
+        if ($named) {
+                $expr = "(?P<attr>{$expr})";
+        }
+        return $expr;
+}
+
+function shortcode_re_esc_lsqbr($named=false) {
+        $expr = "\\[\\[";
+        if ($named) {
+                $expr = "(?P<esc_lsqbr>{$expr})";
+        }
+        return $expr;
+}
+
+function shortcode_re_esc_rsqbr($named=false) {
+        //two right square brackets not immediately followed by an odd number of right square brackets
+        $expr = '\]\](?=(?:\]\])*(?!\]))';
+        if ($named) {
+                $expr = "(?P<esc_rsqbr>{$expr})";
+        }
+        return $expr;
+}
+
+function shortcode_re_tag_inline($named=false) {
+        $name = shortcode_re_registered_name();
+        $attr = shortcode_re_attr();
+
+        $expr = "{$name}(?:\\s+{$attr})*";
+        if ($named) {
+                $expr = "(?P<tag_inline>{$expr})";
+        }
+        $expr = "\\[{$expr}\\s*\\/\\]";
+        return $expr;
+}
+
+function shortcode_re_tag_open($named=false) {
+        $name = shortcode_re_registered_name();
+        $attr = shortcode_re_attr();
+
+        $expr = "{$name}(?:\\s+{$attr})*";
+        if ($named) {
+                $expr = "(?P<tag_open>{$expr})";
+        }
+        $expr = "\\[{$expr}\\s*\\]";
+        return $expr;
+}
+
+function shortcode_re_tag_close($named=false) {
+        $name = shortcode_re_registered_name();
+        $expr = $name;
+        if ($named) {
+                $expr = "(?P<tag_close>{$expr})";
+        }
+        $expr = "\\[\\/{$expr}\\s*\\]";
+        return $expr;
+}
+
+function shortcode_re_text($named=false) {
+        $expr = '(?s:.[^\[\]]*)';
+        if ($named) {
+                $expr = "(?P<text>{$expr})";
+        }
+        return $expr;
+}
+
+/**
+ * combines shortcode regex of types specified in parameters, returns delimited regex
+*/
+function shortcode_re_combine() {
+        $types = func_get_args();
+
+        $regexps = array();
+        foreach ($types as $type) {
+                $re_func = "shortcode_re_$type";
+                array_push($regexps,$re_func(1));
+        }
+        $statement = '/' . join('|',$regexps) . '/';
+        return $statement;
+}
+
+/**
+ * returns regular expression to match subtypes of an expression (ex. attr => {$name}={$literal})
+*/
+function shortcode_re_subtypes($type) {
+        $subtypes = shortcode_sub($type);
+        $re = null;
+        if (count($subtypes)) {
+                $re = call_user_func_array('shortcode_re_combine',$subtypes);
+        }
+        return $re;
+}
+
+/**
+ * evaluates a name expression
+*/
+function shortcode_eval_name($name) {
+        return strtolower($name['expression']);
+}
+
+/**
+ * evaluates a char_str expression
+*/
+function shortcode_eval_char_str($char_str) {
+        return $char_str['expression'];
+}
+
+/**
+ * did you get the point yet?
+*/
+function shortcode_eval_char_ref($char_ref) {
+        $expr = $char_ref['expression'];
+        if ($expr[0] == 'x') {
+                $expr = hexdec($expr);
+        }
+        $expr = chr($expr);
+        return $expr;
+}
+
+function shortcode_eval_entity_ref($entity_ref) {
+        $expr = strtolower($entity_ref['expression']);
+        $lookup = array_flip(get_html_translation_table(HTML_ENTITIES));
+        return $lookup[$expr];
+}
+
+function shortcode_eval_literal($literal) {
+        $expr = "";
+        foreach ($literal['children'] as $child) {
+                $eval_func = "shortcode_eval_{$child['type']}";
+                $expr .= $eval_func($child);
+        }
+        if ($expr[0] == "'" || $expr[0] == '"') {
+                $expr = substr($expr,1,strlen($expr)-2);
+        }
+        return $expr;
+}
+
+function shortcode_eval_attr($attr) {
+        $children = $attr['children'];
+        $key = shortcode_eval_name($children[0]);
+        if (isset($children[1])) {
+                $value = shortcode_eval_literal($children[1]);
+        } else {
+                $value = $key;
+        }
+        return array('key' => $key, 'value' => $value);
+}
+
+function shortcode_eval_tag_inline($tag_inline,&$stack) {
+        $children = $tag_inline['children'];
+
+        $name = shortcode_eval_name($children[0]);
+        $attrs = array();
+
+        foreach ($children as $child) {
+                if ($child['type'] == 'attr') {
+                        $attr = shortcode_eval_attr($child);
+                        $key = $attr['key'];
+                        $value = $attr['value'];
+                        $attrs[$key] = $value;
+                }
+        }
+
+        $content = apply_shortcodes($attrs,'',$name);
+
+        // adds evaluated content to next on the stack
+        $node = array_pop($stack);
+        $node['content'] .= $content;
+        array_push($stack,$node);
+
+        return $node;
+}
+
+function shortcode_eval_esc_lsqbr($esc_lsqbr,&$stack) {
+        $node = array_pop($stack);
+        $node['content'] .= "[";
+        array_push($stack,$node);
+
+        return $node;
+}
+
+function shortcode_eval_esc_rsqbr($esc_rsqbr,&$stack) {
+        $node = array_pop($stack);
+        $node['content'] .= "]";
+        array_push($stack,$node);
+
+        return $node;   
+}
+
+function shortcode_eval_tag_open($tag_open,&$stack,&$refs) {
+        $children = $tag_open['children'];
+
+        $name = shortcode_eval_name($children[0]);
+        $attrs = array();
+
+        foreach ($children as $child) {
+                if ($child['type'] == 'attr') {
+                        $attr = shortcode_eval_attr($child);
+                        $key = $attr['key'];
+                        $value = $attr['value'];
+                        $attrs[$key] = $value;
+                }
+        }
+
+        $data = array('name' => $name, 'attrs' => $attrs);
+        $node = array('node' => $data, 'content' => '');
+
+        //throws itself on the stack with attributes, etc.
+        array_push($stack,$node);
+        $refs[$name] += 1;
+
+        return $node;
+}
+
+function shortcode_eval_tag_close($tag_close,&$stack,&$refs) {
+        $value = null;
+
+        $name = shortcode_eval_name($tag_close['children'][0]);
+
+        if ($refs[$name] > 0) {
+                do {
+                        $child = array_pop($stack);
+                        $child_node  = $child['node'];
+                        $child_name  = $child['node']['name'];
+                        $child_attrs = $child['node']['attrs'];
+
+                        $parent = array_pop($stack);
+                        $parent['content'] .= apply_shortcodes($child_attrs,'',$child_name);
+                        $parent['content'] .= $child['content'];
+
+                        $refs[$name] -= 1;
+                        array_push($stack,$parent);
+                } while ($child_name != $name);
+        }
+
+        return array('name' => $name);
+}
+
+function shortcode_eval_text($text,&$stack) {
+        $node = array_pop($stack);
+        $node['content'] .= $text['expression'];
+        array_push($stack,$node);
+        return $text['expression'];
+}
+
+function shortcode_eval($expr) {
+        $stack = array();
+        $refs  = array();
+
+        //build parse tree
+        $root = shortcode_build_tree($expr);
+
+        //create root content node, throw on stack
+        $root_node = array('node' => 'root', 'content' => '');
+        array_push($stack,$root_node);
+
+        //evaluate immediate children
+        $subs = shortcode_sub();
+        foreach ($root['children'] as $child) {
+                if (in_array($child['type'],$subs)) {
+                        $func = "shortcode_eval_{$child['type']}";
+                        $func($child,$stack,$refs);
+                }
+        }
+
+        //evaluate children remaining on stack
+        $child = array_pop($stack);
+        while ($child['node'] != 'root') {
+                $parent = array_pop($stack);
+
+                $child_node  = $child['node'];
+                $child_name  = $child['node']['name'];
+                $child_attrs = $child['node']['attrs'];
+
+                $parent['content'] .= apply_shortcodes($child_attrs,'',$child_name);
+                $parent['content'] .= $child['content'];
+                $child = $parent;
+        }
+
+        return $child['content'];
+}
+
+/**
+* builds a tree from a shortcode expression
+*/
+function shortcode_build_tree($parent) {
+        if (is_string($parent)) {
+                $parent = array('type' => 'root', 'expression' => $parent);
+        }
+        $parent_type = $parent['type'];
+        $parent_expression = $parent['expression'];
+
+        $re_subtypes = shortcode_re_subtypes($parent_type);
+        $nodes = array();
+        if ($re_subtypes) {
+                $match_set = array();
+                preg_match_all($re_subtypes,$parent_expression,$match_set,PREG_SET_ORDER);
+
+                foreach ($match_set as $index => $match) {
+                        foreach (shortcode_types() as $type) {
+                                if (strlen($match[$type]) > 0) {
+                                        $nodes[$index] = array('type' => $type, 'expression' => $match[$type]);
+                                }
+                        }
+                }
+        }
+
+
+        $parent['children'] = array_map('shortcode_build_tree',$nodes);
+        return $parent;
+}
+
+
+add_filter('the_content','shortcode_eval',11);
+ No newline at end of file