1 <?php

     2 /**

     3  * Rewrite API: WP_Rewrite class

     4  *

     5  * @package WordPress

     6  * @subpackage Rewrite

     7  * @since 1.5.0

     8  */

     9 

    10 /**

    11  * Core class used to implement a rewrite component API.

    12  *

    13  * The WordPress Rewrite class writes the rewrite module rules to the .htaccess

    14  * file. It also handles parsing the request to get the correct setup for the

    15  * WordPress Query class.

    16  *

    17  * The Rewrite along with WP class function as a front controller for WordPress.

    18  * You can add rules to trigger your page view and processing using this

    19  * component. The full functionality of a front controller does not exist,

    20  * meaning you can't define how the template files load based on the rewrite

    21  * rules.

    22  *

    23  * @since 1.5.0

    24  */

    25 class WP_Rewrite {

    26 	/**

    27 	 * Permalink structure for posts.

    28 	 *

    29 	 * @since 1.5.0

    30 	 * @var string

    31 	 */

    32 	public $permalink_structure;

    33 

    34 	/**

    35 	 * Whether to add trailing slashes.

    36 	 *

    37 	 * @since 2.2.0

    38 	 * @var bool

    39 	 */

    40 	public $use_trailing_slashes;

    41 

    42 	/**

    43 	 * Base for the author permalink structure (example.com/$author_base/authorname).

    44 	 *

    45 	 * @since 1.5.0

    46 	 * @var string

    47 	 */

    48 	var $author_base = 'author';

    49 

    50 	/**

    51 	 * Permalink structure for author archives.

    52 	 *

    53 	 * @since 1.5.0

    54 	 * @var string

    55 	 */

    56 	var $author_structure;

    57 

    58 	/**

    59 	 * Permalink structure for date archives.

    60 	 *

    61 	 * @since 1.5.0

    62 	 * @var string

    63 	 */

    64 	var $date_structure;

    65 

    66 	/**

    67 	 * Permalink structure for pages.

    68 	 *

    69 	 * @since 1.5.0

    70 	 * @var string

    71 	 */

    72 	var $page_structure;

    73 

    74 	/**

    75 	 * Base of the search permalink structure (example.com/$search_base/query).

    76 	 *

    77 	 * @since 1.5.0

    78 	 * @var string

    79 	 */

    80 	var $search_base = 'search';

    81 

    82 	/**

    83 	 * Permalink structure for searches.

    84 	 *

    85 	 * @since 1.5.0

    86 	 * @var string

    87 	 */

    88 	var $search_structure;

    89 

    90 	/**

    91 	 * Comments permalink base.

    92 	 *

    93 	 * @since 1.5.0

    94 	 * @var string

    95 	 */

    96 	var $comments_base = 'comments';

    97 

    98 	/**

    99 	 * Pagination permalink base.

   100 	 *

   101 	 * @since 3.1.0

   102 	 * @var string

   103 	 */

   104 	public $pagination_base = 'page';

   105 

   106 	/**

   107 	 * Comments pagination permalink base.

   108 	 *

   109 	 * @since 4.2.0

   110 	 * @var string

   111 	 */

   112 	var $comments_pagination_base = 'comment-page';

   113 

   114 	/**

   115 	 * Feed permalink base.

   116 	 *

   117 	 * @since 1.5.0

   118 	 * @var string

   119 	 */

   120 	var $feed_base = 'feed';

   121 

   122 	/**

   123 	 * Comments feed permalink structure.

   124 	 *

   125 	 * @since 1.5.0

   126 	 * @var string

   127 	 */

   128 	var $comment_feed_structure;

   129 

   130 	/**

   131 	 * Feed request permalink structure.

   132 	 *

   133 	 * @since 1.5.0

   134 	 * @var string

   135 	 */

   136 	var $feed_structure;

   137 

   138 	/**

   139 	 * The static portion of the post permalink structure.

   140 	 *

   141 	 * If the permalink structure is "/archive/%post_id%" then the front

   142 	 * is "/archive/". If the permalink structure is "/%year%/%postname%/"

   143 	 * then the front is "/".

   144 	 *

   145 	 * @since 1.5.0

   146 	 * @var string

   147 	 *

   148 	 * @see WP_Rewrite::init()

   149 	 */

   150 	public $front;

   151 

   152 	/**

   153 	 * The prefix for all permalink structures.

   154 	 *

   155 	 * If PATHINFO/index permalinks are in use then the root is the value of

   156 	 * `WP_Rewrite::$index` with a trailing slash appended. Otherwise the root

   157 	 * will be empty.

   158 	 *

   159 	 * @since 1.5.0

   160 	 * @var string

   161 	 *

   162 	 * @see WP_Rewrite::init()

   163 	 * @see WP_Rewrite::using_index_permalinks()

   164 	 */

   165 	public $root = '';

   166 

   167 	/**

   168 	 * The name of the index file which is the entry point to all requests.

   169 	 *

   170 	 * @since 1.5.0

   171 	 * @var string

   172 	 */

   173 	public $index = 'index.php';

   174 

   175 	/**

   176 	 * Variable name to use for regex matches in the rewritten query.

   177 	 *

   178 	 * @since 1.5.0

   179 	 * @var string

   180 	 */

   181 	var $matches = '';

   182 

   183 	/**

   184 	 * Rewrite rules to match against the request to find the redirect or query.

   185 	 *

   186 	 * @since 1.5.0

   187 	 * @var array

   188 	 */

   189 	var $rules;

   190 

   191 	/**

   192 	 * Additional rules added external to the rewrite class.

   193 	 *

   194 	 * Those not generated by the class, see add_rewrite_rule().

   195 	 *

   196 	 * @since 2.1.0

   197 	 * @var array

   198 	 */

   199 	var $extra_rules = array();

   200 

   201 	/**

   202 	 * Additional rules that belong at the beginning to match first.

   203 	 *

   204 	 * Those not generated by the class, see add_rewrite_rule().

   205 	 *

   206 	 * @since 2.3.0

   207 	 * @var array

   208 	 */

   209 	var $extra_rules_top = array();

   210 

   211 	/**

   212 	 * Rules that don't redirect to WordPress' index.php.

   213 	 *

   214 	 * These rules are written to the mod_rewrite portion of the .htaccess,

   215 	 * and are added by add_external_rule().

   216 	 *

   217 	 * @since 2.1.0

   218 	 * @var array

   219 	 */

   220 	var $non_wp_rules = array();

   221 

   222 	/**

   223 	 * Extra permalink structures, e.g. categories, added by add_permastruct().

   224 	 *

   225 	 * @since 2.1.0

   226 	 * @var array

   227 	 */

   228 	var $extra_permastructs = array();

   229 

   230 	/**

   231 	 * Endpoints (like /trackback/) added by add_rewrite_endpoint().

   232 	 *

   233 	 * @since 2.1.0

   234 	 * @var array

   235 	 */

   236 	var $endpoints;

   237 

   238 	/**

   239 	 * Whether to write every mod_rewrite rule for WordPress into the .htaccess file.

   240 	 *

   241 	 * This is off by default, turning it on might print a lot of rewrite rules

   242 	 * to the .htaccess file.

   243 	 *

   244 	 * @since 2.0.0

   245 	 * @var bool

   246 	 *

   247 	 * @see WP_Rewrite::mod_rewrite_rules()

   248 	 */

   249 	public $use_verbose_rules = false;

   250 

   251 	/**

   252 	 * Could post permalinks be confused with those of pages?

   253 	 *

   254 	 * If the first rewrite tag in the post permalink structure is one that could

   255 	 * also match a page name (e.g. %postname% or %author%) then this flag is

   256 	 * set to true. Prior to WordPress 3.3 this flag indicated that every page

   257 	 * would have a set of rules added to the top of the rewrite rules array.

   258 	 * Now it tells WP::parse_request() to check if a URL matching the page

   259 	 * permastruct is actually a page before accepting it.

   260 	 *

   261 	 * @since 2.5.0

   262 	 * @var bool

   263 	 *

   264 	 * @see WP_Rewrite::init()

   265 	 */

   266 	public $use_verbose_page_rules = true;

   267 

   268 	/**

   269 	 * Rewrite tags that can be used in permalink structures.

   270 	 *

   271 	 * These are translated into the regular expressions stored in

   272 	 * `WP_Rewrite::$rewritereplace` and are rewritten to the query

   273 	 * variables listed in WP_Rewrite::$queryreplace.

   274 	 *

   275 	 * Additional tags can be added with add_rewrite_tag().

   276 	 *

   277 	 * @since 1.5.0

   278 	 * @var array

   279 	 */

   280 	var $rewritecode = array(

   281 		'%year%',

   282 		'%monthnum%',

   283 		'%day%',

   284 		'%hour%',

   285 		'%minute%',

   286 		'%second%',

   287 		'%postname%',

   288 		'%post_id%',

   289 		'%author%',

   290 		'%pagename%',

   291 		'%search%'

   292 	);

   293 

   294 	/**

   295 	 * Regular expressions to be substituted into rewrite rules in place

   296 	 * of rewrite tags, see WP_Rewrite::$rewritecode.

   297 	 *

   298 	 * @since 1.5.0

   299 	 * @var array

   300 	 */

   301 	var $rewritereplace = array(

   302 		'([0-9]{4})',

   303 		'([0-9]{1,2})',

   304 		'([0-9]{1,2})',

   305 		'([0-9]{1,2})',

   306 		'([0-9]{1,2})',

   307 		'([0-9]{1,2})',

   308 		'([^/]+)',

   309 		'([0-9]+)',

   310 		'([^/]+)',

   311 		'([^/]+?)',

   312 		'(.+)'

   313 	);

   314 

   315 	/**

   316 	 * Query variables that rewrite tags map to, see WP_Rewrite::$rewritecode.

   317 	 *

   318 	 * @since 1.5.0

   319 	 * @var array

   320 	 */

   321 	var $queryreplace = array(

   322 		'year=',

   323 		'monthnum=',

   324 		'day=',

   325 		'hour=',

   326 		'minute=',

   327 		'second=',

   328 		'name=',

   329 		'p=',

   330 		'author_name=',

   331 		'pagename=',

   332 		's='

   333 	);

   334 

   335 	/**

   336 	 * Supported default feeds.

   337 	 *

   338 	 * @since 1.5.0

   339 	 * @var array

   340 	 */

   341 	public $feeds = array( 'feed', 'rdf', 'rss', 'rss2', 'atom' );

   342 

   343 	/**

   344 	 * Determines whether permalinks are being used.

   345 	 *

   346 	 * This can be either rewrite module or permalink in the HTTP query string.

   347 	 *

   348 	 * @since 1.5.0

   349 	 *

   350 	 * @return bool True, if permalinks are enabled.

   351 	 */

   352 	public function using_permalinks() {

   353 		return ! empty($this->permalink_structure);

   354 	}

   355 

   356 	/**

   357 	 * Determines whether permalinks are being used and rewrite module is not enabled.

   358 	 *

   359 	 * Means that permalink links are enabled and index.php is in the URL.

   360 	 *

   361 	 * @since 1.5.0

   362 	 *

   363 	 * @return bool Whether permalink links are enabled and index.php is in the URL.

   364 	 */

   365 	public function using_index_permalinks() {

   366 		if ( empty( $this->permalink_structure ) ) {

   367 			return false;

   368 		}

   369 

   370 		// If the index is not in the permalink, we're using mod_rewrite.

   371 		return preg_match( '#^/*' . $this->index . '#', $this->permalink_structure );

   372 	}

   373 

   374 	/**

   375 	 * Determines whether permalinks are being used and rewrite module is enabled.

   376 	 *

   377 	 * Using permalinks and index.php is not in the URL.

   378 	 *

   379 	 * @since 1.5.0

   380 	 *

   381 	 * @return bool Whether permalink links are enabled and index.php is NOT in the URL.

   382 	 */

   383 	public function using_mod_rewrite_permalinks() {

   384 		return $this->using_permalinks() && ! $this->using_index_permalinks();

   385 	}

   386 

   387 	/**

   388 	 * Indexes for matches for usage in preg_*() functions.

   389 	 *

   390 	 * The format of the string is, with empty matches property value, '$NUM'.

   391 	 * The 'NUM' will be replaced with the value in the $number parameter. With

   392 	 * the matches property not empty, the value of the returned string will

   393 	 * contain that value of the matches property. The format then will be

   394 	 * '$MATCHES[NUM]', with MATCHES as the value in the property and NUM the

   395 	 * value of the $number parameter.

   396 	 *

   397 	 * @since 1.5.0

   398 	 *

   399 	 * @param int $number Index number.

   400 	 * @return string

   401 	 */

   402 	public function preg_index($number) {

   403 		$match_prefix = '$';

   404 		$match_suffix = '';

   405 

   406 		if ( ! empty($this->matches) ) {

   407 			$match_prefix = '$' . $this->matches . '[';

   408 			$match_suffix = ']';

   409 		}

   410 

   411 		return "$match_prefix$number$match_suffix";

   412 	}

   413 

   414 	/**

   415 	 * Retrieves all page and attachments for pages URIs.

   416 	 *

   417 	 * The attachments are for those that have pages as parents and will be

   418 	 * retrieved.

   419 	 *

   420 	 * @since 2.5.0

   421 	 *

   422 	 * @global wpdb $wpdb WordPress database abstraction object.

   423 	 *

   424 	 * @return array Array of page URIs as first element and attachment URIs as second element.

   425 	 */

   426 	public function page_uri_index() {

   427 		global $wpdb;

   428 

   429 		// Get pages in order of hierarchy, i.e. children after parents.

   430 		$pages = $wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'page' AND post_status != 'auto-draft'");

   431 		$posts = get_page_hierarchy( $pages );

   432 

   433 		// If we have no pages get out quick.

   434 		if ( !$posts )

   435 			return array( array(), array() );

   436 

   437 		// Now reverse it, because we need parents after children for rewrite rules to work properly.

   438 		$posts = array_reverse($posts, true);

   439 

   440 		$page_uris = array();

   441 		$page_attachment_uris = array();

   442 

   443 		foreach ( $posts as $id => $post ) {

   444 			// URL => page name

   445 			$uri = get_page_uri($id);

   446 			$attachments = $wpdb->get_results( $wpdb->prepare( "SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'attachment' AND post_parent = %d", $id ));

   447 			if ( !empty($attachments) ) {

   448 				foreach ( $attachments as $attachment ) {

   449 					$attach_uri = get_page_uri($attachment->ID);

   450 					$page_attachment_uris[$attach_uri] = $attachment->ID;

   451 				}

   452 			}

   453 

   454 			$page_uris[$uri] = $id;

   455 		}

   456 

   457 		return array( $page_uris, $page_attachment_uris );

   458 	}

   459 

   460 	/**

   461 	 * Retrieves all of the rewrite rules for pages.

   462 	 *

   463 	 * @since 1.5.0

   464 	 *

   465 	 * @return array Page rewrite rules.

   466 	 */

   467 	public function page_rewrite_rules() {

   468 		// The extra .? at the beginning prevents clashes with other regular expressions in the rules array.

   469 		$this->add_rewrite_tag( '%pagename%', '(.?.+?)', 'pagename=' );

   470 

   471 		return $this->generate_rewrite_rules( $this->get_page_permastruct(), EP_PAGES, true, true, false, false );

   472 	}

   473 

   474 	/**

   475 	 * Retrieves date permalink structure, with year, month, and day.

   476 	 *

   477 	 * The permalink structure for the date, if not set already depends on the

   478 	 * permalink structure. It can be one of three formats. The first is year,

   479 	 * month, day; the second is day, month, year; and the last format is month,

   480 	 * day, year. These are matched against the permalink structure for which

   481 	 * one is used. If none matches, then the default will be used, which is

   482 	 * year, month, day.

   483 	 *

   484 	 * Prevents post ID and date permalinks from overlapping. In the case of

   485 	 * post_id, the date permalink will be prepended with front permalink with

   486 	 * 'date/' before the actual permalink to form the complete date permalink

   487 	 * structure.

   488 	 *

   489 	 * @since 1.5.0

   490 	 *

   491 	 * @return string|false False on no permalink structure. Date permalink structure.

   492 	 */

   493 	public function get_date_permastruct() {

   494 		if ( isset($this->date_structure) )

   495 			return $this->date_structure;

   496 

   497 		if ( empty($this->permalink_structure) ) {

   498 			$this->date_structure = '';

   499 			return false;

   500 		}

   501 

   502 		// The date permalink must have year, month, and day separated by slashes.

   503 		$endians = array('%year%/%monthnum%/%day%', '%day%/%monthnum%/%year%', '%monthnum%/%day%/%year%');

   504 

   505 		$this->date_structure = '';

   506 		$date_endian = '';

   507 

   508 		foreach ( $endians as $endian ) {

   509 			if ( false !== strpos($this->permalink_structure, $endian) ) {

   510 				$date_endian= $endian;

   511 				break;

   512 			}

   513 		}

   514 

   515 		if ( empty($date_endian) )

   516 			$date_endian = '%year%/%monthnum%/%day%';

   517 

   518 		/*

   519 		 * Do not allow the date tags and %post_id% to overlap in the permalink

   520 		 * structure. If they do, move the date tags to $front/date/.

   521 		 */

   522 		$front = $this->front;

   523 		preg_match_all('/%.+?%/', $this->permalink_structure, $tokens);

   524 		$tok_index = 1;

   525 		foreach ( (array) $tokens[0] as $token) {

   526 			if ( '%post_id%' == $token && ($tok_index <= 3) ) {

   527 				$front = $front . 'date/';

   528 				break;

   529 			}

   530 			$tok_index++;

   531 		}

   532 

   533 		$this->date_structure = $front . $date_endian;

   534 

   535 		return $this->date_structure;

   536 	}

   537 

   538 	/**

   539 	 * Retrieves the year permalink structure without month and day.

   540 	 *

   541 	 * Gets the date permalink structure and strips out the month and day

   542 	 * permalink structures.

   543 	 *

   544 	 * @since 1.5.0

   545 	 *

   546 	 * @return false|string False on failure. Year structure on success.

   547 	 */

   548 	public function get_year_permastruct() {

   549 		$structure = $this->get_date_permastruct();

   550 

   551 		if ( empty($structure) )

   552 			return false;

   553 

   554 		$structure = str_replace('%monthnum%', '', $structure);

   555 		$structure = str_replace('%day%', '', $structure);

   556 		$structure = preg_replace('#/+#', '/', $structure);

   557 

   558 		return $structure;

   559 	}

   560 

   561 	/**

   562 	 * Retrieves the month permalink structure without day and with year.

   563 	 *

   564 	 * Gets the date permalink structure and strips out the day permalink

   565 	 * structures. Keeps the year permalink structure.

   566 	 *

   567 	 * @since 1.5.0

   568 	 *

   569 	 * @return false|string False on failure. Year/Month structure on success.

   570 	 */

   571 	public function get_month_permastruct() {

   572 		$structure = $this->get_date_permastruct();

   573 

   574 		if ( empty($structure) )

   575 			return false;

   576 

   577 		$structure = str_replace('%day%', '', $structure);

   578 		$structure = preg_replace('#/+#', '/', $structure);

   579 

   580 		return $structure;

   581 	}

   582 

   583 	/**

   584 	 * Retrieves the day permalink structure with month and year.

   585 	 *

   586 	 * Keeps date permalink structure with all year, month, and day.

   587 	 *

   588 	 * @since 1.5.0

   589 	 *

   590 	 * @return string|false False on failure. Year/Month/Day structure on success.

   591 	 */

   592 	public function get_day_permastruct() {

   593 		return $this->get_date_permastruct();

   594 	}

   595 

   596 	/**

   597 	 * Retrieves the permalink structure for categories.

   598 	 *

   599 	 * If the category_base property has no value, then the category structure

   600 	 * will have the front property value, followed by 'category', and finally

   601 	 * '%category%'. If it does, then the root property will be used, along with

   602 	 * the category_base property value.

   603 	 *

   604 	 * @since 1.5.0

   605 	 *

   606 	 * @return string|false False on failure. Category permalink structure.

   607 	 */

   608 	public function get_category_permastruct() {

   609 		return $this->get_extra_permastruct('category');

   610 	}

   611 

   612 	/**

   613 	 * Retrieve the permalink structure for tags.

   614 	 *

   615 	 * If the tag_base property has no value, then the tag structure will have

   616 	 * the front property value, followed by 'tag', and finally '%tag%'. If it

   617 	 * does, then the root property will be used, along with the tag_base

   618 	 * property value.

   619 	 *

   620 	 * @since 2.3.0

   621 	 *

   622 	 * @return string|false False on failure. Tag permalink structure.

   623 	 */

   624 	public function get_tag_permastruct() {

   625 		return $this->get_extra_permastruct('post_tag');

   626 	}

   627 

   628 	/**

   629 	 * Retrieves an extra permalink structure by name.

   630 	 *

   631 	 * @since 2.5.0

   632 	 *

   633 	 * @param string $name Permalink structure name.

   634 	 * @return string|false False if not found. Permalink structure string.

   635 	 */

   636 	public function get_extra_permastruct($name) {

   637 		if ( empty($this->permalink_structure) )

   638 			return false;

   639 

   640 		if ( isset($this->extra_permastructs[$name]) )

   641 			return $this->extra_permastructs[$name]['struct'];

   642 

   643 		return false;

   644 	}

   645 

   646 	/**

   647 	 * Retrieves the author permalink structure.

   648 	 *

   649 	 * The permalink structure is front property, author base, and finally

   650 	 * '/%author%'. Will set the author_structure property and then return it

   651 	 * without attempting to set the value again.

   652 	 *

   653 	 * @since 1.5.0

   654 	 *

   655 	 * @return string|false False if not found. Permalink structure string.

   656 	 */

   657 	public function get_author_permastruct() {

   658 		if ( isset($this->author_structure) )

   659 			return $this->author_structure;

   660 

   661 		if ( empty($this->permalink_structure) ) {

   662 			$this->author_structure = '';

   663 			return false;

   664 		}

   665 

   666 		$this->author_structure = $this->front . $this->author_base . '/%author%';

   667 

   668 		return $this->author_structure;

   669 	}

   670 

   671 	/**

   672 	 * Retrieves the search permalink structure.

   673 	 *

   674 	 * The permalink structure is root property, search base, and finally

   675 	 * '/%search%'. Will set the search_structure property and then return it

   676 	 * without attempting to set the value again.

   677 	 *

   678 	 * @since 1.5.0

   679 	 *

   680 	 * @return string|false False if not found. Permalink structure string.

   681 	 */

   682 	public function get_search_permastruct() {

   683 		if ( isset($this->search_structure) )

   684 			return $this->search_structure;

   685 

   686 		if ( empty($this->permalink_structure) ) {

   687 			$this->search_structure = '';

   688 			return false;

   689 		}

   690 

   691 		$this->search_structure = $this->root . $this->search_base . '/%search%';

   692 

   693 		return $this->search_structure;

   694 	}

   695 

   696 	/**

   697 	 * Retrieves the page permalink structure.

   698 	 *

   699 	 * The permalink structure is root property, and '%pagename%'. Will set the

   700 	 * page_structure property and then return it without attempting to set the

   701 	 * value again.

   702 	 *

   703 	 * @since 1.5.0

   704 	 *

   705 	 * @return string|false False if not found. Permalink structure string.

   706 	 */

   707 	public function get_page_permastruct() {

   708 		if ( isset($this->page_structure) )

   709 			return $this->page_structure;

   710 

   711 		if (empty($this->permalink_structure)) {

   712 			$this->page_structure = '';

   713 			return false;

   714 		}

   715 

   716 		$this->page_structure = $this->root . '%pagename%';

   717 

   718 		return $this->page_structure;

   719 	}

   720 

   721 	/**

   722 	 * Retrieves the feed permalink structure.

   723 	 *

   724 	 * The permalink structure is root property, feed base, and finally

   725 	 * '/%feed%'. Will set the feed_structure property and then return it

   726 	 * without attempting to set the value again.

   727 	 *

   728 	 * @since 1.5.0

   729 	 *

   730 	 * @return string|false False if not found. Permalink structure string.

   731 	 */

   732 	public function get_feed_permastruct() {

   733 		if ( isset($this->feed_structure) )

   734 			return $this->feed_structure;

   735 

   736 		if ( empty($this->permalink_structure) ) {

   737 			$this->feed_structure = '';

   738 			return false;

   739 		}

   740 

   741 		$this->feed_structure = $this->root . $this->feed_base . '/%feed%';

   742 

   743 		return $this->feed_structure;

   744 	}

   745 

   746 	/**

   747 	 * Retrieves the comment feed permalink structure.

   748 	 *

   749 	 * The permalink structure is root property, comment base property, feed

   750 	 * base and finally '/%feed%'. Will set the comment_feed_structure property

   751 	 * and then return it without attempting to set the value again.

   752 	 *

   753 	 * @since 1.5.0

   754 	 *

   755 	 * @return string|false False if not found. Permalink structure string.

   756 	 */

   757 	public function get_comment_feed_permastruct() {

   758 		if ( isset($this->comment_feed_structure) )

   759 			return $this->comment_feed_structure;

   760 

   761 		if (empty($this->permalink_structure)) {

   762 			$this->comment_feed_structure = '';

   763 			return false;

   764 		}

   765 

   766 		$this->comment_feed_structure = $this->root . $this->comments_base . '/' . $this->feed_base . '/%feed%';

   767 

   768 		return $this->comment_feed_structure;

   769 	}

   770 

   771 	/**

   772 	 * Adds or updates existing rewrite tags (e.g. %postname%).

   773 	 *

   774 	 * If the tag already exists, replace the existing pattern and query for

   775 	 * that tag, otherwise add the new tag.

   776 	 *

   777 	 * @since 1.5.0

   778 	 *

   779 	 * @see WP_Rewrite::$rewritecode

   780 	 * @see WP_Rewrite::$rewritereplace

   781 	 * @see WP_Rewrite::$queryreplace

   782 	 *

   783 	 * @param string $tag   Name of the rewrite tag to add or update.

   784 	 * @param string $regex Regular expression to substitute the tag for in rewrite rules.

   785 	 * @param string $query String to append to the rewritten query. Must end in '='.

   786 	 */

   787 	public function add_rewrite_tag( $tag, $regex, $query ) {

   788 		$position = array_search( $tag, $this->rewritecode );

   789 		if ( false !== $position && null !== $position ) {

   790 			$this->rewritereplace[ $position ] = $regex;

   791 			$this->queryreplace[ $position ] = $query;

   792 		} else {

   793 			$this->rewritecode[] = $tag;

   794 			$this->rewritereplace[] = $regex;

   795 			$this->queryreplace[] = $query;

   796 		}

   797 	}

   798 

   799 

   800 	/**

   801 	 * Removes an existing rewrite tag.

   802 	 *

   803 	 * @since 4.5.0

   804 	 *

   805 	 * @see WP_Rewrite::$rewritecode

   806 	 * @see WP_Rewrite::$rewritereplace

   807 	 * @see WP_Rewrite::$queryreplace

   808 	 *

   809 	 * @param string $tag Name of the rewrite tag to remove.

   810 	 */

   811 	public function remove_rewrite_tag( $tag ) {

   812 		$position = array_search( $tag, $this->rewritecode );

   813 		if ( false !== $position && null !== $position ) {

   814 			unset( $this->rewritecode[ $position ] );

   815 			unset( $this->rewritereplace[ $position ] );

   816 			unset( $this->queryreplace[ $position ] );

   817 		}

   818 	}

   819 

   820 	/**

   821 	 * Generates rewrite rules from a permalink structure.

   822 	 *

   823 	 * The main WP_Rewrite function for building the rewrite rule list. The

   824 	 * contents of the function is a mix of black magic and regular expressions,

   825 	 * so best just ignore the contents and move to the parameters.

   826 	 *

   827 	 * @since 1.5.0

   828 	 *

   829 	 * @param string $permalink_structure The permalink structure.

   830 	 * @param int    $ep_mask             Optional. Endpoint mask defining what endpoints are added to the structure.

   831 	 *                                    Accepts `EP_NONE`, `EP_PERMALINK`, `EP_ATTACHMENT`, `EP_DATE`, `EP_YEAR`,

   832 	 *                                    `EP_MONTH`, `EP_DAY`, `EP_ROOT`, `EP_COMMENTS`, `EP_SEARCH`, `EP_CATEGORIES`,

   833 	 *                                    `EP_TAGS`, `EP_AUTHORS`, `EP_PAGES`, `EP_ALL_ARCHIVES`, and `EP_ALL`.

   834 	 *                                    Default `EP_NONE`.

   835 	 * @param bool   $paged               Optional. Whether archive pagination rules should be added for the structure.

   836 	 *                                    Default true.

   837 	 * @param bool   $feed                Optional Whether feed rewrite rules should be added for the structure.

   838 	 *                                    Default true.

   839 	 * @param bool   $forcomments         Optional. Whether the feed rules should be a query for a comments feed.

   840 	 *                                    Default false.

   841 	 * @param bool   $walk_dirs           Optional. Whether the 'directories' making up the structure should be walked

   842 	 *                                    over and rewrite rules built for each in-turn. Default true.

   843 	 * @param bool   $endpoints           Optional. Whether endpoints should be applied to the generated rewrite rules.

   844 	 *                                    Default true.

   845 	 * @return array Rewrite rule list.

   846 	 */

   847 	public function generate_rewrite_rules($permalink_structure, $ep_mask = EP_NONE, $paged = true, $feed = true, $forcomments = false, $walk_dirs = true, $endpoints = true) {

   848 		// Build a regex to match the feed section of URLs, something like (feed|atom|rss|rss2)/?

   849 		$feedregex2 = '';

   850 		foreach ( (array) $this->feeds as $feed_name)

   851 			$feedregex2 .= $feed_name . '|';

   852 		$feedregex2 = '(' . trim($feedregex2, '|') . ')/?$';

   853 

   854 		/*

   855 		 * $feedregex is identical but with /feed/ added on as well, so URLs like <permalink>/feed/atom

   856 		 * and <permalink>/atom are both possible

   857 		 */

   858 		$feedregex = $this->feed_base . '/' . $feedregex2;

   859 

   860 		// Build a regex to match the trackback and page/xx parts of URLs.

   861 		$trackbackregex = 'trackback/?$';

   862 		$pageregex = $this->pagination_base . '/?([0-9]{1,})/?$';

   863 		$commentregex = $this->comments_pagination_base . '-([0-9]{1,})/?$';

   864 		$embedregex = 'embed/?$';

   865 

   866 		// Build up an array of endpoint regexes to append => queries to append.

   867 		if ( $endpoints ) {

   868 			$ep_query_append = array ();

   869 			foreach ( (array) $this->endpoints as $endpoint) {

   870 				// Match everything after the endpoint name, but allow for nothing to appear there.

   871 				$epmatch = $endpoint[1] . '(/(.*))?/?$';

   872 

   873 				// This will be appended on to the rest of the query for each dir.

   874 				$epquery = '&' . $endpoint[2] . '=';

   875 				$ep_query_append[$epmatch] = array ( $endpoint[0], $epquery );

   876 			}

   877 		}

   878 

   879 		// Get everything up to the first rewrite tag.

   880 		$front = substr($permalink_structure, 0, strpos($permalink_structure, '%'));

   881 

   882 		// Build an array of the tags (note that said array ends up being in $tokens[0]).

   883 		preg_match_all('/%.+?%/', $permalink_structure, $tokens);

   884 

   885 		$num_tokens = count($tokens[0]);

   886 

   887 		$index = $this->index; //probably 'index.php'

   888 		$feedindex = $index;

   889 		$trackbackindex = $index;

   890 		$embedindex = $index;

   891 

   892 		/*

   893 		 * Build a list from the rewritecode and queryreplace arrays, that will look something

   894 		 * like tagname=$matches[i] where i is the current $i.

   895 		 */

   896 		$queries = array();

   897 		for ( $i = 0; $i < $num_tokens; ++$i ) {

   898 			if ( 0 < $i )

   899 				$queries[$i] = $queries[$i - 1] . '&';

   900 			else

   901 				$queries[$i] = '';

   902 

   903 			$query_token = str_replace($this->rewritecode, $this->queryreplace, $tokens[0][$i]) . $this->preg_index($i+1);

   904 			$queries[$i] .= $query_token;

   905 		}

   906 

   907 		// Get the structure, minus any cruft (stuff that isn't tags) at the front.

   908 		$structure = $permalink_structure;

   909 		if ( $front != '/' )

   910 			$structure = str_replace($front, '', $structure);

   911 

   912 		/*

   913 		 * Create a list of dirs to walk over, making rewrite rules for each level

   914 		 * so for example, a $structure of /%year%/%monthnum%/%postname% would create

   915 		 * rewrite rules for /%year%/, /%year%/%monthnum%/ and /%year%/%monthnum%/%postname%

   916 		 */

   917 		$structure = trim($structure, '/');

   918 		$dirs = $walk_dirs ? explode('/', $structure) : array( $structure );

   919 		$num_dirs = count($dirs);

   920 

   921 		// Strip slashes from the front of $front.

   922 		$front = preg_replace('|^/+|', '', $front);

   923 

   924 		// The main workhorse loop.

   925 		$post_rewrite = array();

   926 		$struct = $front;

   927 		for ( $j = 0; $j < $num_dirs; ++$j ) {

   928 			// Get the struct for this dir, and trim slashes off the front.

   929 			$struct .= $dirs[$j] . '/'; // Accumulate. see comment near explode('/', $structure) above.

   930 			$struct = ltrim($struct, '/');

   931 

   932 			// Replace tags with regexes.

   933 			$match = str_replace($this->rewritecode, $this->rewritereplace, $struct);

   934 

   935 			// Make a list of tags, and store how many there are in $num_toks.

   936 			$num_toks = preg_match_all('/%.+?%/', $struct, $toks);

   937 

   938 			// Get the 'tagname=$matches[i]'.

   939 			$query = ( ! empty( $num_toks ) && isset( $queries[$num_toks - 1] ) ) ? $queries[$num_toks - 1] : '';

   940 

   941 			// Set up $ep_mask_specific which is used to match more specific URL types.

   942 			switch ( $dirs[$j] ) {

   943 				case '%year%':

   944 					$ep_mask_specific = EP_YEAR;

   945 					break;

   946 				case '%monthnum%':

   947 					$ep_mask_specific = EP_MONTH;

   948 					break;

   949 				case '%day%':

   950 					$ep_mask_specific = EP_DAY;

   951 					break;

   952 				default:

   953 					$ep_mask_specific = EP_NONE;

   954 			}

   955 

   956 			// Create query for /page/xx.

   957 			$pagematch = $match . $pageregex;

   958 			$pagequery = $index . '?' . $query . '&paged=' . $this->preg_index($num_toks + 1);

   959 

   960 			// Create query for /comment-page-xx.

   961 			$commentmatch = $match . $commentregex;

   962 			$commentquery = $index . '?' . $query . '&cpage=' . $this->preg_index($num_toks + 1);

   963 

   964 			if ( get_option('page_on_front') ) {

   965 				// Create query for Root /comment-page-xx.

   966 				$rootcommentmatch = $match . $commentregex;

   967 				$rootcommentquery = $index . '?' . $query . '&page_id=' . get_option('page_on_front') . '&cpage=' . $this->preg_index($num_toks + 1);

   968 			}

   969 

   970 			// Create query for /feed/(feed|atom|rss|rss2|rdf).

   971 			$feedmatch = $match . $feedregex;

   972 			$feedquery = $feedindex . '?' . $query . '&feed=' . $this->preg_index($num_toks + 1);

   973 

   974 			// Create query for /(feed|atom|rss|rss2|rdf) (see comment near creation of $feedregex).

   975 			$feedmatch2 = $match . $feedregex2;

   976 			$feedquery2 = $feedindex . '?' . $query . '&feed=' . $this->preg_index($num_toks + 1);

   977 

   978 			// Create query and regex for embeds.

   979 			$embedmatch = $match . $embedregex;

   980 			$embedquery = $embedindex . '?' . $query . '&embed=true';

   981 

   982 			// If asked to, turn the feed queries into comment feed ones.

   983 			if ( $forcomments ) {

   984 				$feedquery .= '&withcomments=1';

   985 				$feedquery2 .= '&withcomments=1';

   986 			}

   987 

   988 			// Start creating the array of rewrites for this dir.

   989 			$rewrite = array();

   990 

   991 			// ...adding on /feed/ regexes => queries

   992 			if ( $feed ) {

   993 				$rewrite = array( $feedmatch => $feedquery, $feedmatch2 => $feedquery2, $embedmatch => $embedquery );

   994 			}

   995 

   996 			//...and /page/xx ones

   997 			if ( $paged ) {

   998 				$rewrite = array_merge( $rewrite, array( $pagematch => $pagequery ) );

   999 			}

  1000 

  1001 			// Only on pages with comments add ../comment-page-xx/.

  1002 			if ( EP_PAGES & $ep_mask || EP_PERMALINK & $ep_mask ) {

  1003 				$rewrite = array_merge($rewrite, array($commentmatch => $commentquery));

  1004 			} elseif ( EP_ROOT & $ep_mask && get_option('page_on_front') ) {

  1005 				$rewrite = array_merge($rewrite, array($rootcommentmatch => $rootcommentquery));

  1006 			}

  1007 

  1008 			// Do endpoints.

  1009 			if ( $endpoints ) {

  1010 				foreach ( (array) $ep_query_append as $regex => $ep) {

  1011 					// Add the endpoints on if the mask fits.

  1012 					if ( $ep[0] & $ep_mask || $ep[0] & $ep_mask_specific )

  1013 						$rewrite[$match . $regex] = $index . '?' . $query . $ep[1] . $this->preg_index($num_toks + 2);

  1014 				}

  1015 			}

  1016 

  1017 			// If we've got some tags in this dir.

  1018 			if ( $num_toks ) {

  1019 				$post = false;

  1020 				$page = false;

  1021 

  1022 				/*

  1023 				 * Check to see if this dir is permalink-level: i.e. the structure specifies an

  1024 				 * individual post. Do this by checking it contains at least one of 1) post name,

  1025 				 * 2) post ID, 3) page name, 4) timestamp (year, month, day, hour, second and

  1026 				 * minute all present). Set these flags now as we need them for the endpoints.

  1027 				 */

  1028 				if ( strpos($struct, '%postname%') !== false

  1029 						|| strpos($struct, '%post_id%') !== false

  1030 						|| strpos($struct, '%pagename%') !== false

  1031 						|| (strpos($struct, '%year%') !== false && strpos($struct, '%monthnum%') !== false && strpos($struct, '%day%') !== false && strpos($struct, '%hour%') !== false && strpos($struct, '%minute%') !== false && strpos($struct, '%second%') !== false)

  1032 						) {

  1033 					$post = true;

  1034 					if ( strpos($struct, '%pagename%') !== false )

  1035 						$page = true;

  1036 				}

  1037 

  1038 				if ( ! $post ) {

  1039 					// For custom post types, we need to add on endpoints as well.

  1040 					foreach ( get_post_types( array('_builtin' => false ) ) as $ptype ) {

  1041 						if ( strpos($struct, "%$ptype%") !== false ) {

  1042 							$post = true;

  1043 

  1044 							// This is for page style attachment URLs.

  1045 							$page = is_post_type_hierarchical( $ptype );

  1046 							break;

  1047 						}

  1048 					}

  1049 				}

  1050 

  1051 				// If creating rules for a permalink, do all the endpoints like attachments etc.

  1052 				if ( $post ) {

  1053 					// Create query and regex for trackback.

  1054 					$trackbackmatch = $match . $trackbackregex;

  1055 					$trackbackquery = $trackbackindex . '?' . $query . '&tb=1';

  1056 

  1057 					// Create query and regex for embeds.

  1058 					$embedmatch = $match . $embedregex;

  1059 					$embedquery = $embedindex . '?' . $query . '&embed=true';

  1060 

  1061 					// Trim slashes from the end of the regex for this dir.

  1062 					$match = rtrim($match, '/');

  1063 

  1064 					// Get rid of brackets.

  1065 					$submatchbase = str_replace( array('(', ')'), '', $match);

  1066 

  1067 					// Add a rule for at attachments, which take the form of <permalink>/some-text.

  1068 					$sub1 = $submatchbase . '/([^/]+)/';

  1069 

  1070 					// Add trackback regex <permalink>/trackback/...

  1071 					$sub1tb = $sub1 . $trackbackregex;

  1072 

  1073 					// And <permalink>/feed/(atom|...)

  1074 					$sub1feed = $sub1 . $feedregex;

  1075 

  1076 					// And <permalink>/(feed|atom...)

  1077 					$sub1feed2 = $sub1 . $feedregex2;

  1078 

  1079 					// And <permalink>/comment-page-xx

  1080 					$sub1comment = $sub1 . $commentregex;

  1081 

  1082 					// And <permalink>/embed/...

  1083 					$sub1embed = $sub1 . $embedregex;

  1084 

  1085 					/*

  1086 					 * Add another rule to match attachments in the explicit form:

  1087 					 * <permalink>/attachment/some-text

  1088 					 */

  1089 					$sub2 = $submatchbase . '/attachment/([^/]+)/';

  1090 

  1091 					// And add trackbacks <permalink>/attachment/trackback.

  1092 					$sub2tb = $sub2 . $trackbackregex;

  1093 

  1094 					// Feeds, <permalink>/attachment/feed/(atom|...)

  1095 					$sub2feed = $sub2 . $feedregex;

  1096 

  1097 					// And feeds again on to this <permalink>/attachment/(feed|atom...)

  1098 					$sub2feed2 = $sub2 . $feedregex2;

  1099 

  1100 					// And <permalink>/comment-page-xx

  1101 					$sub2comment = $sub2 . $commentregex;

  1102 

  1103 					// And <permalink>/embed/...

  1104 					$sub2embed = $sub2 . $embedregex;

  1105 

  1106 					// Create queries for these extra tag-ons we've just dealt with.

  1107 					$subquery = $index . '?attachment=' . $this->preg_index(1);

  1108 					$subtbquery = $subquery . '&tb=1';

  1109 					$subfeedquery = $subquery . '&feed=' . $this->preg_index(2);

  1110 					$subcommentquery = $subquery . '&cpage=' . $this->preg_index(2);

  1111 					$subembedquery = $subquery . '&embed=true';

  1112 

  1113 					// Do endpoints for attachments.

  1114 					if ( !empty($endpoints) ) {

  1115 						foreach ( (array) $ep_query_append as $regex => $ep ) {

  1116 							if ( $ep[0] & EP_ATTACHMENT ) {

  1117 								$rewrite[$sub1 . $regex] = $subquery . $ep[1] . $this->preg_index(3);

  1118 								$rewrite[$sub2 . $regex] = $subquery . $ep[1] . $this->preg_index(3);

  1119 							}

  1120 						}

  1121 					}

  1122 

  1123 					/*

  1124 					 * Now we've finished with endpoints, finish off the $sub1 and $sub2 matches

  1125 					 * add a ? as we don't have to match that last slash, and finally a $ so we

  1126 					 * match to the end of the URL

  1127 					 */

  1128 					$sub1 .= '?$';

  1129 					$sub2 .= '?$';

  1130 

  1131 					/*

  1132 					 * Post pagination, e.g. <permalink>/2/

  1133 					 * Previously: '(/[0-9]+)?/?$', which produced '/2' for page.

  1134 					 * When cast to int, returned 0.

  1135 					 */