2004-06-30 11:31:49 -04:00
< ? php
2004-08-08 11:31:50 -04:00
class WP_Query {
2004-09-05 16:00:09 -04:00
var $query ;
var $query_vars ;
2004-10-02 15:24:40 -04:00
var $queried_object ;
var $queried_object_id ;
2006-01-11 06:06:26 -05:00
var $request ;
2004-09-05 16:00:09 -04:00
var $posts ;
var $post_count = 0 ;
var $current_post = - 1 ;
2005-07-17 12:58:13 -04:00
var $in_the_loop = false ;
2004-09-05 16:00:09 -04:00
var $post ;
var $is_single = false ;
2005-11-06 02:04:46 -05:00
var $is_preview = false ;
2004-09-05 16:00:09 -04:00
var $is_page = false ;
var $is_archive = false ;
var $is_date = false ;
var $is_year = false ;
var $is_month = false ;
var $is_day = false ;
var $is_time = false ;
var $is_author = false ;
var $is_category = false ;
var $is_search = false ;
var $is_feed = false ;
2004-12-17 19:28:24 -05:00
var $is_trackback = false ;
2004-09-05 16:00:09 -04:00
var $is_home = false ;
var $is_404 = false ;
2005-02-14 04:17:23 -05:00
var $is_comments_popup = false ;
2004-12-26 11:37:55 -05:00
var $is_admin = false ;
2005-11-15 17:55:24 -05:00
var $is_attachment = false ;
2004-09-05 16:00:09 -04:00
2005-09-15 23:16:12 -04:00
function init_query_flags () {
2004-09-05 16:00:09 -04:00
$this -> is_single = false ;
$this -> is_page = false ;
$this -> is_archive = false ;
$this -> is_date = false ;
$this -> is_year = false ;
$this -> is_month = false ;
$this -> is_day = false ;
$this -> is_time = false ;
$this -> is_author = false ;
$this -> is_category = false ;
$this -> is_search = false ;
$this -> is_feed = false ;
2004-12-17 19:28:24 -05:00
$this -> is_trackback = false ;
2004-09-05 16:00:09 -04:00
$this -> is_home = false ;
$this -> is_404 = false ;
2004-11-20 13:32:31 -05:00
$this -> is_paged = false ;
2004-12-26 11:37:55 -05:00
$this -> is_admin = false ;
2005-11-15 17:55:24 -05:00
$this -> is_attachment = false ;
2005-09-15 23:16:12 -04:00
}
function init () {
2004-09-05 16:00:09 -04:00
unset ( $this -> posts );
unset ( $this -> query );
unset ( $this -> query_vars );
2004-10-02 15:24:40 -04:00
unset ( $this -> queried_object );
unset ( $this -> queried_object_id );
2004-09-05 16:00:09 -04:00
$this -> post_count = 0 ;
$this -> current_post = - 1 ;
2005-07-17 12:58:13 -04:00
$this -> in_the_loop = false ;
2005-09-15 23:16:12 -04:00
$this -> init_query_flags ();
2004-09-05 16:00:09 -04:00
}
2005-02-01 03:34:19 -05:00
// Reparse the query vars.
function parse_query_vars () {
$this -> parse_query ( '' );
}
// Parse a query string and set query type booleans.
2004-09-05 16:00:09 -04:00
function parse_query ( $query ) {
2005-02-01 03:34:19 -05:00
if ( ! empty ( $query ) || ! isset ( $this -> query ) ) {
$this -> init ();
parse_str ( $query , $qv );
$this -> query = $query ;
$this -> query_vars = $qv ;
}
2005-09-15 23:16:12 -04:00
if ( '404' == $qv [ 'error' ]) {
$this -> is_404 = true ;
if ( ! empty ( $query ) ) {
do_action ( 'parse_query' , array ( & $this ));
}
return ;
}
2004-12-12 15:41:19 -05:00
$qv [ 'm' ] = ( int ) $qv [ 'm' ];
2004-12-30 06:08:42 -05:00
$qv [ 'p' ] = ( int ) $qv [ 'p' ];
2004-09-05 16:00:09 -04:00
2005-11-15 17:55:24 -05:00
// Compat. Map subpost to attachment.
if ( '' != $qv [ 'subpost' ] )
$qv [ 'attachment' ] = $qv [ 'subpost' ];
if ( '' != $qv [ 'subpost_id' ] )
$qv [ 'attachment_id' ] = $qv [ 'subpost_id' ];
2005-12-13 14:19:56 -05:00
if ( ( '' != $qv [ 'attachment' ]) || ( int ) $qv [ 'attachment_id' ] ) {
2005-10-20 16:48:32 -04:00
$this -> is_single = true ;
2005-11-15 17:55:24 -05:00
$this -> is_attachment = true ;
2005-12-13 14:19:56 -05:00
} elseif ( '' != $qv [ 'name' ]) {
2004-09-05 16:00:09 -04:00
$this -> is_single = true ;
2005-01-31 20:49:51 -05:00
} elseif ( $qv [ 'p' ] ) {
2004-12-30 06:08:42 -05:00
$this -> is_single = true ;
2004-12-30 05:58:06 -05:00
} elseif (( '' != $qv [ 'hour' ]) && ( '' != $qv [ 'minute' ]) && ( '' != $qv [ 'second' ]) && ( '' != $qv [ 'year' ]) && ( '' != $qv [ 'monthnum' ]) && ( '' != $qv [ 'day' ])) {
2004-12-17 19:28:24 -05:00
// If year, month, day, hour, minute, and second are set, a single
2005-10-20 16:48:32 -04:00
// post is being queried.
2004-12-17 19:28:24 -05:00
$this -> is_single = true ;
2006-09-24 22:14:44 -04:00
} elseif ( '' != $qv [ 'static' ] || '' != $qv [ 'pagename' ] || ( int ) $qv [ 'page_id' ]) {
2004-10-08 04:06:21 -04:00
$this -> is_page = true ;
$this -> is_single = false ;
2004-12-30 05:58:06 -05:00
} elseif ( ! empty ( $qv [ 's' ])) {
2004-12-17 19:28:24 -05:00
$this -> is_search = true ;
2005-12-13 14:19:56 -05:00
switch ( $qv [ 'show_post_type' ]) {
case 'page' :
$this -> is_page = true ;
break ;
case 'attachment' :
$this -> is_attachment = true ;
break ;
}
2004-12-17 19:28:24 -05:00
} else {
2004-12-30 06:10:00 -05:00
// Look for archive queries. Dates, categories, authors.
2004-09-05 16:00:09 -04:00
2004-12-17 19:28:24 -05:00
if ( ( int ) $qv [ 'second' ]) {
$this -> is_time = true ;
2004-09-05 16:00:09 -04:00
$this -> is_date = true ;
}
2004-12-17 19:28:24 -05:00
if ( ( int ) $qv [ 'minute' ]) {
$this -> is_time = true ;
2004-09-05 16:00:09 -04:00
$this -> is_date = true ;
}
2004-12-17 19:28:24 -05:00
if ( ( int ) $qv [ 'hour' ]) {
$this -> is_time = true ;
2004-09-05 16:00:09 -04:00
$this -> is_date = true ;
}
2004-12-17 19:28:24 -05:00
if ( ( int ) $qv [ 'day' ]) {
if ( ! $this -> is_date ) {
$this -> is_day = true ;
$this -> is_date = true ;
}
2004-12-12 15:41:19 -05:00
}
2004-09-05 16:00:09 -04:00
2004-12-17 19:28:24 -05:00
if ( ( int ) $qv [ 'monthnum' ]) {
if ( ! $this -> is_date ) {
$this -> is_month = true ;
$this -> is_date = true ;
}
}
2004-09-05 16:00:09 -04:00
2004-12-17 19:28:24 -05:00
if ( ( int ) $qv [ 'year' ]) {
if ( ! $this -> is_date ) {
$this -> is_year = true ;
$this -> is_date = true ;
}
}
2004-09-05 16:00:09 -04:00
2004-12-17 19:28:24 -05:00
if ( ( int ) $qv [ 'm' ]) {
$this -> is_date = true ;
if ( strlen ( $qv [ 'm' ]) > 9 ) {
$this -> is_time = true ;
} else if ( strlen ( $qv [ 'm' ]) > 7 ) {
$this -> is_day = true ;
} else if ( strlen ( $qv [ 'm' ]) > 5 ) {
$this -> is_month = true ;
} else {
$this -> is_year = true ;
}
}
2004-09-05 16:00:09 -04:00
2004-12-17 19:28:24 -05:00
if ( '' != $qv [ 'w' ]) {
$this -> is_date = true ;
}
2005-01-31 20:49:51 -05:00
if ( empty ( $qv [ 'cat' ]) || ( $qv [ 'cat' ] == '0' )) {
2004-09-05 16:00:09 -04:00
$this -> is_category = false ;
} else {
2004-12-17 19:28:24 -05:00
if ( stristr ( $qv [ 'cat' ], '-' )) {
$this -> is_category = false ;
} else {
$this -> is_category = true ;
}
2004-09-05 16:00:09 -04:00
}
2004-12-17 19:28:24 -05:00
if ( '' != $qv [ 'category_name' ]) {
$this -> is_category = true ;
}
2004-07-27 21:59:29 -04:00
2005-01-31 20:49:51 -05:00
if (( empty ( $qv [ 'author' ])) || ( $qv [ 'author' ] == '0' )) {
2004-12-17 19:28:24 -05:00
$this -> is_author = false ;
} else {
$this -> is_author = true ;
}
2004-09-05 16:00:09 -04:00
2004-12-17 19:28:24 -05:00
if ( '' != $qv [ 'author_name' ]) {
$this -> is_author = true ;
}
2004-09-05 16:00:09 -04:00
2004-12-17 19:28:24 -05:00
if ( ( $this -> is_date || $this -> is_author || $this -> is_category )) {
$this -> is_archive = true ;
}
2005-12-13 14:19:56 -05:00
if ( 'attachment' == $qv [ 'show_post_type' ] ) {
$this -> is_attachment = true ;
}
2004-09-05 16:00:09 -04:00
}
if ( '' != $qv [ 'feed' ]) {
$this -> is_feed = true ;
}
2004-12-17 19:28:24 -05:00
if ( '' != $qv [ 'tb' ]) {
$this -> is_trackback = true ;
}
2004-11-20 13:32:31 -05:00
if ( '' != $qv [ 'paged' ]) {
$this -> is_paged = true ;
}
2005-02-14 04:17:23 -05:00
if ( '' != $qv [ 'comments_popup' ]) {
$this -> is_comments_popup = true ;
}
2006-01-23 18:39:56 -05:00
//if we're previewing inside the write screen
if ( '' != $qv [ 'preview' ]) {
$this -> is_preview = true ;
}
2005-02-14 04:17:23 -05:00
2004-12-26 11:37:55 -05:00
if ( strstr ( $_SERVER [ 'PHP_SELF' ], 'wp-admin/' )) {
$this -> is_admin = true ;
}
2005-11-15 17:55:24 -05:00
if ( ! ( $this -> is_attachment || $this -> is_archive || $this -> is_single || $this -> is_page || $this -> is_search || $this -> is_feed || $this -> is_trackback || $this -> is_404 || $this -> is_admin || $this -> is_comments_popup )) {
2004-09-05 16:00:09 -04:00
$this -> is_home = true ;
}
2005-02-01 03:34:19 -05:00
if ( ! empty ( $query ) ) {
do_action ( 'parse_query' , array ( & $this ));
}
2004-08-08 11:31:50 -04:00
}
2005-09-15 23:16:12 -04:00
function set_404 () {
2006-09-24 21:51:37 -04:00
$is_feed = $this -> is_feed ;
2005-09-15 23:16:12 -04:00
$this -> init_query_flags ();
2006-09-24 21:51:37 -04:00
$this -> is_404 = true ;
$this -> is_feed = $is_feed ;
2005-09-15 23:16:12 -04:00
}
2004-09-05 16:00:09 -04:00
function get ( $query_var ) {
if ( isset ( $this -> query_vars [ $query_var ])) {
return $this -> query_vars [ $query_var ];
}
2004-08-08 11:31:50 -04:00
2004-09-05 16:00:09 -04:00
return '' ;
}
2004-08-10 01:35:59 -04:00
2005-01-31 20:04:08 -05:00
function set ( $query_var , $value ) {
$this -> query_vars [ $query_var ] = $value ;
}
2005-03-27 15:45:01 -05:00
function & get_posts () {
2006-01-11 06:06:26 -05:00
global $wpdb , $pagenow , $user_ID ;
2004-09-05 16:00:09 -04:00
2005-10-06 13:27:57 -04:00
do_action ( 'pre_get_posts' , array ( & $this ));
2004-09-05 16:00:09 -04:00
// Shorthand.
$q = $this -> query_vars ;
// First let's clear some variables
$whichcat = '' ;
$whichauthor = '' ;
2005-11-28 20:43:32 -05:00
$whichpage = '' ;
2004-09-05 16:00:09 -04:00
$result = '' ;
$where = '' ;
$limits = '' ;
$distinct = '' ;
$join = '' ;
if ( ! isset ( $q [ 'posts_per_page' ]) || $q [ 'posts_per_page' ] == 0 )
$q [ 'posts_per_page' ] = get_settings ( 'posts_per_page' );
if ( ! isset ( $q [ 'what_to_show' ]) )
$q [ 'what_to_show' ] = get_settings ( 'what_to_show' );
if ( isset ( $q [ 'showposts' ]) && $q [ 'showposts' ] ) {
$q [ 'showposts' ] = ( int ) $q [ 'showposts' ];
$q [ 'posts_per_page' ] = $q [ 'showposts' ];
}
2005-02-13 14:45:04 -05:00
if ( ( isset ( $q [ 'posts_per_archive_page' ]) && $q [ 'posts_per_archive_page' ] != 0 ) && ( $this -> is_archive || $this -> is_search ) )
2004-10-27 19:58:40 -04:00
$q [ 'posts_per_page' ] = $q [ 'posts_per_archive_page' ];
if ( ! isset ( $q [ 'nopaging' ]) ) {
if ( $q [ 'posts_per_page' ] == - 1 ) {
$q [ 'nopaging' ] = true ;
} else {
$q [ 'nopaging' ] = false ;
}
}
2005-03-23 16:39:22 -05:00
if ( $this -> is_feed ) {
2005-02-13 14:42:22 -05:00
$q [ 'posts_per_page' ] = get_settings ( 'posts_per_rss' );
2005-03-23 16:39:22 -05:00
$q [ 'what_to_show' ] = 'posts' ;
}
2005-04-14 00:24:22 -04:00
if ( isset ( $q [ 'page' ])) {
$q [ 'page' ] = trim ( $q [ 'page' ], '/' );
$q [ 'page' ] = ( int ) $q [ 'page' ];
2006-07-04 16:01:31 -04:00
$q [ 'page' ] = abs ( $q [ 'page' ]);
2005-04-14 00:24:22 -04:00
}
2004-10-27 19:58:40 -04:00
2004-09-05 16:00:09 -04:00
$add_hours = intval ( get_settings ( 'gmt_offset' ));
$add_minutes = intval ( 60 * ( get_settings ( 'gmt_offset' ) - $add_hours ));
$wp_posts_post_date_field = " post_date " ; // "DATE_ADD(post_date, INTERVAL '$add_hours:$add_minutes' HOUR_MINUTE)";
// If a month is specified in the querystring, load that month
2004-12-12 15:41:19 -05:00
if ( ( int ) $q [ 'm' ] ) {
2004-09-05 16:00:09 -04:00
$q [ 'm' ] = '' . preg_replace ( '|[^0-9]|' , '' , $q [ 'm' ]);
$where .= ' AND YEAR(post_date)=' . substr ( $q [ 'm' ], 0 , 4 );
if ( strlen ( $q [ 'm' ]) > 5 )
$where .= ' AND MONTH(post_date)=' . substr ( $q [ 'm' ], 4 , 2 );
if ( strlen ( $q [ 'm' ]) > 7 )
$where .= ' AND DAYOFMONTH(post_date)=' . substr ( $q [ 'm' ], 6 , 2 );
if ( strlen ( $q [ 'm' ]) > 9 )
$where .= ' AND HOUR(post_date)=' . substr ( $q [ 'm' ], 8 , 2 );
if ( strlen ( $q [ 'm' ]) > 11 )
$where .= ' AND MINUTE(post_date)=' . substr ( $q [ 'm' ], 10 , 2 );
if ( strlen ( $q [ 'm' ]) > 13 )
$where .= ' AND SECOND(post_date)=' . substr ( $q [ 'm' ], 12 , 2 );
}
2004-12-12 15:41:19 -05:00
if ( ( int ) $q [ 'hour' ] ) {
2004-09-05 16:00:09 -04:00
$q [ 'hour' ] = '' . intval ( $q [ 'hour' ]);
$where .= " AND HOUR(post_date)=' " . $q [ 'hour' ] . " ' " ;
}
2004-12-12 15:41:19 -05:00
if ( ( int ) $q [ 'minute' ] ) {
2004-09-05 16:00:09 -04:00
$q [ 'minute' ] = '' . intval ( $q [ 'minute' ]);
$where .= " AND MINUTE(post_date)=' " . $q [ 'minute' ] . " ' " ;
}
2004-12-12 15:41:19 -05:00
if ( ( int ) $q [ 'second' ] ) {
2004-09-05 16:00:09 -04:00
$q [ 'second' ] = '' . intval ( $q [ 'second' ]);
$where .= " AND SECOND(post_date)=' " . $q [ 'second' ] . " ' " ;
}
2004-12-12 15:41:19 -05:00
if ( ( int ) $q [ 'year' ] ) {
2004-09-05 16:00:09 -04:00
$q [ 'year' ] = '' . intval ( $q [ 'year' ]);
$where .= " AND YEAR(post_date)=' " . $q [ 'year' ] . " ' " ;
}
2004-12-12 15:41:19 -05:00
if ( ( int ) $q [ 'monthnum' ] ) {
2004-09-05 16:00:09 -04:00
$q [ 'monthnum' ] = '' . intval ( $q [ 'monthnum' ]);
$where .= " AND MONTH(post_date)=' " . $q [ 'monthnum' ] . " ' " ;
}
2004-12-12 15:41:19 -05:00
if ( ( int ) $q [ 'day' ] ) {
2004-09-05 16:00:09 -04:00
$q [ 'day' ] = '' . intval ( $q [ 'day' ]);
$where .= " AND DAYOFMONTH(post_date)=' " . $q [ 'day' ] . " ' " ;
}
2005-11-15 17:55:24 -05:00
// Compat. Map subpost to attachment.
if ( '' != $q [ 'subpost' ] )
$q [ 'attachment' ] = $q [ 'subpost' ];
if ( '' != $q [ 'subpost_id' ] )
$q [ 'attachment_id' ] = $q [ 'subpost_id' ];
2004-09-05 16:00:09 -04:00
if ( '' != $q [ 'name' ]) {
$q [ 'name' ] = sanitize_title ( $q [ 'name' ]);
$where .= " AND post_name = ' " . $q [ 'name' ] . " ' " ;
} else if ( '' != $q [ 'pagename' ]) {
2005-11-28 20:43:32 -05:00
$q [ 'pagename' ] = str_replace ( '%2F' , '/' , urlencode ( urldecode ( $q [ 'pagename' ])));
$page_paths = '/' . trim ( $q [ 'pagename' ], '/' );
$q [ 'pagename' ] = sanitize_title ( basename ( $page_paths ));
2004-09-05 16:00:09 -04:00
$q [ 'name' ] = $q [ 'pagename' ];
2005-11-28 20:43:32 -05:00
$page_paths = explode ( '/' , $page_paths );
foreach ( $page_paths as $pathdir )
$page_path .= ( $pathdir != '' ? '/' : '' ) . sanitize_title ( $pathdir );
$all_page_ids = get_all_page_ids ();
2005-12-24 11:26:55 -05:00
$reqpage = 0 ;
2006-01-20 16:07:10 -05:00
if ( is_array ( $all_page_ids )) { foreach ( $all_page_ids as $page_id ) {
2005-11-28 20:43:32 -05:00
$page = get_page ( $page_id );
if ( $page -> fullpath == $page_path ) {
$reqpage = $page_id ;
break ;
}
2006-01-20 16:07:10 -05:00
} }
2005-11-28 20:43:32 -05:00
$where .= " AND (ID = ' $reqpage ') " ;
2005-11-15 17:55:24 -05:00
} elseif ( '' != $q [ 'attachment' ]) {
2005-12-27 23:27:21 -05:00
$q [ 'attachment' ] = str_replace ( '%2F' , '/' , urlencode ( urldecode ( $q [ 'attachment' ])));
$attach_paths = '/' . trim ( $q [ 'attachment' ], '/' );
$q [ 'attachment' ] = sanitize_title ( basename ( $attach_paths ));
2005-11-15 17:55:24 -05:00
$q [ 'name' ] = $q [ 'attachment' ];
$where .= " AND post_name = ' " . $q [ 'attachment' ] . " ' " ;
2004-09-05 16:00:09 -04:00
}
2004-12-12 15:41:19 -05:00
if ( ( int ) $q [ 'w' ] ) {
2004-09-05 16:00:09 -04:00
$q [ 'w' ] = '' . intval ( $q [ 'w' ]);
$where .= " AND WEEK(post_date, 1)=' " . $q [ 'w' ] . " ' " ;
}
2005-02-14 04:17:23 -05:00
if ( intval ( $q [ 'comments_popup' ]) )
$q [ 'p' ] = intval ( $q [ 'comments_popup' ]);
2005-11-15 17:55:24 -05:00
// If a attachment is requested by number, let it supercede any post number.
if ( ( $q [ 'attachment_id' ] != '' ) && ( intval ( $q [ 'attachment_id' ]) != 0 ) )
$q [ 'p' ] = ( int ) $q [ 'attachment_id' ];
2005-10-20 16:48:32 -04:00
2004-09-05 16:00:09 -04:00
// If a post number is specified, load that post
2005-01-31 20:49:51 -05:00
if (( $q [ 'p' ] != '' ) && intval ( $q [ 'p' ]) != 0 ) {
2004-12-12 15:41:19 -05:00
$q [ 'p' ] = ( int ) $q [ 'p' ];
$where = ' AND ID = ' . $q [ 'p' ];
2004-09-05 16:00:09 -04:00
}
2005-01-31 20:49:51 -05:00
if (( $q [ 'page_id' ] != '' ) && ( intval ( $q [ 'page_id' ]) != 0 )) {
2004-10-08 04:06:21 -04:00
$q [ 'page_id' ] = intval ( $q [ 'page_id' ]);
$q [ 'p' ] = $q [ 'page_id' ];
$where = ' AND ID = ' . $q [ 'page_id' ];
}
2004-09-05 16:00:09 -04:00
// If a search pattern is specified, load the posts that match
if ( ! empty ( $q [ 's' ])) {
$q [ 's' ] = addslashes_gpc ( $q [ 's' ]);
$search = ' AND (' ;
$q [ 's' ] = preg_replace ( '/, +/' , ' ' , $q [ 's' ]);
$q [ 's' ] = str_replace ( ',' , ' ' , $q [ 's' ]);
$q [ 's' ] = str_replace ( '"' , ' ' , $q [ 's' ]);
$q [ 's' ] = trim ( $q [ 's' ]);
if ( $q [ 'exact' ]) {
$n = '' ;
} else {
$n = '%' ;
}
if ( ! $q [ 'sentence' ]) {
$s_array = explode ( ' ' , $q [ 's' ]);
2004-09-26 20:46:42 -04:00
$q [ 'search_terms' ] = $s_array ;
2004-09-05 16:00:09 -04:00
$search .= '((post_title LIKE \'' . $n . $s_array [ 0 ] . $n . '\') OR (post_content LIKE \'' . $n . $s_array [ 0 ] . $n . '\'))' ;
for ( $i = 1 ; $i < count ( $s_array ); $i = $i + 1 ) {
$search .= ' AND ((post_title LIKE \'' . $n . $s_array [ $i ] . $n . '\') OR (post_content LIKE \'' . $n . $s_array [ $i ] . $n . '\'))' ;
}
$search .= ' OR (post_title LIKE \'' . $n . $q [ 's' ] . $n . '\') OR (post_content LIKE \'' . $n . $q [ 's' ] . $n . '\')' ;
$search .= ')' ;
} else {
$search = ' AND ((post_title LIKE \'' . $n . $q [ 's' ] . $n . '\') OR (post_content LIKE \'' . $n . $q [ 's' ] . $n . '\'))' ;
}
}
// Category stuff
2005-01-31 20:49:51 -05:00
if (( empty ( $q [ 'cat' ])) || ( $q [ 'cat' ] == '0' ) ||
2004-09-05 16:00:09 -04:00
// Bypass cat checks if fetching specific posts
2005-02-13 14:45:04 -05:00
( $this -> is_single || $this -> is_page )) {
2004-09-05 16:00:09 -04:00
$whichcat = '' ;
} else {
$q [ 'cat' ] = '' . urldecode ( $q [ 'cat' ]) . '' ;
$q [ 'cat' ] = addslashes_gpc ( $q [ 'cat' ]);
if ( stristr ( $q [ 'cat' ], '-' )) {
// Note: if we have a negative, we ignore all the positives. It must
// always mean 'everything /except/ this one'. We should be able to do
// multiple negatives but we don't :-(
$eq = '!=' ;
$andor = 'AND' ;
$q [ 'cat' ] = explode ( '-' , $q [ 'cat' ]);
$q [ 'cat' ] = intval ( $q [ 'cat' ][ 1 ]);
} else {
$eq = '=' ;
$andor = 'OR' ;
}
$join = " LEFT JOIN $wpdb->post2cat ON ( $wpdb->posts .ID = $wpdb->post2cat .post_id) " ;
2005-02-13 12:52:58 -05:00
$cat_array = preg_split ( '/[,\s]+/' , $q [ 'cat' ]);
2004-09-05 16:00:09 -04:00
$whichcat .= ' AND (category_id ' . $eq . ' ' . intval ( $cat_array [ 0 ]);
$whichcat .= get_category_children ( $cat_array [ 0 ], ' ' . $andor . ' category_id ' . $eq . ' ' );
for ( $i = 1 ; $i < ( count ( $cat_array )); $i = $i + 1 ) {
$whichcat .= ' ' . $andor . ' category_id ' . $eq . ' ' . intval ( $cat_array [ $i ]);
$whichcat .= get_category_children ( $cat_array [ $i ], ' ' . $andor . ' category_id ' . $eq . ' ' );
}
$whichcat .= ')' ;
if ( $eq == '!=' ) {
$q [ 'cat' ] = '-' . $q [ 'cat' ]; // Put back the knowledge that we are excluding a category.
}
}
// Category stuff for nice URIs
2005-10-27 21:14:57 -04:00
global $cache_categories ;
2004-09-05 16:00:09 -04:00
if ( '' != $q [ 'category_name' ]) {
2005-10-27 21:14:57 -04:00
$cat_paths = '/' . trim ( urldecode ( $q [ 'category_name' ]), '/' );
$q [ 'category_name' ] = sanitize_title ( basename ( $cat_paths ));
$cat_paths = explode ( '/' , $cat_paths );
foreach ( $cat_paths as $pathdir )
$cat_path .= ( $pathdir != '' ? '/' : '' ) . sanitize_title ( $pathdir );
2005-11-07 16:56:03 -05:00
$all_cat_ids = get_all_category_ids ();
2005-12-31 16:53:13 -05:00
$q [ 'cat' ] = 0 ; $partial_match = 0 ;
2005-11-07 16:56:03 -05:00
foreach ( $all_cat_ids as $cat_id ) {
$cat = get_category ( $cat_id );
if ( $cat -> fullpath == $cat_path ) {
$q [ 'cat' ] = $cat_id ;
break ;
2005-12-31 16:53:13 -05:00
} elseif ( $cat -> category_nicename == $q [ 'category_name' ] ) {
$partial_match = $cat_id ;
2005-11-07 16:56:03 -05:00
}
2004-09-05 16:00:09 -04:00
}
2005-12-31 16:53:13 -05:00
//if we don't match the entire hierarchy fallback on just matching the nicename
if ( ! $q [ 'cat' ] && $partial_match ) {
$q [ 'cat' ] = $partial_match ;
}
2005-11-07 16:56:03 -05:00
2004-09-05 16:00:09 -04:00
$tables = " , $wpdb->post2cat , $wpdb->categories " ;
$join = " LEFT JOIN $wpdb->post2cat ON ( $wpdb->posts .ID = $wpdb->post2cat .post_id) LEFT JOIN $wpdb->categories ON ( $wpdb->post2cat .category_id = $wpdb->categories .cat_ID) " ;
2005-10-27 21:14:57 -04:00
$whichcat = " AND (category_id = ' " . $q [ 'cat' ] . " ' " ;
2004-09-05 16:00:09 -04:00
$whichcat .= get_category_children ( $q [ 'cat' ], " OR category_id = " );
$whichcat .= " ) " ;
}
// Author/user stuff
2005-01-31 20:49:51 -05:00
if (( empty ( $q [ 'author' ])) || ( $q [ 'author' ] == '0' )) {
2004-09-05 16:00:09 -04:00
$whichauthor = '' ;
} else {
$q [ 'author' ] = '' . urldecode ( $q [ 'author' ]) . '' ;
$q [ 'author' ] = addslashes_gpc ( $q [ 'author' ]);
if ( stristr ( $q [ 'author' ], '-' )) {
$eq = '!=' ;
$andor = 'AND' ;
$q [ 'author' ] = explode ( '-' , $q [ 'author' ]);
$q [ 'author' ] = '' . intval ( $q [ 'author' ][ 1 ]);
} else {
$eq = '=' ;
$andor = 'OR' ;
}
2005-02-13 12:52:58 -05:00
$author_array = preg_split ( '/[,\s]+/' , $q [ 'author' ]);
2004-09-05 16:00:09 -04:00
$whichauthor .= ' AND (post_author ' . $eq . ' ' . intval ( $author_array [ 0 ]);
for ( $i = 1 ; $i < ( count ( $author_array )); $i = $i + 1 ) {
$whichauthor .= ' ' . $andor . ' post_author ' . $eq . ' ' . intval ( $author_array [ $i ]);
}
$whichauthor .= ')' ;
}
// Author stuff for nice URIs
if ( '' != $q [ 'author_name' ]) {
if ( stristr ( $q [ 'author_name' ], '/' )) {
$q [ 'author_name' ] = explode ( '/' , $q [ 'author_name' ]);
if ( $q [ 'author_name' ][ count ( $q [ 'author_name' ]) - 1 ]) {
$q [ 'author_name' ] = $q [ 'author_name' ][ count ( $q [ 'author_name' ]) - 1 ]; #no trailing slash
} else {
$q [ 'author_name' ] = $q [ 'author_name' ][ count ( $q [ 'author_name' ]) - 2 ]; #there was a trailling slash
}
}
$q [ 'author_name' ] = sanitize_title ( $q [ 'author_name' ]);
$q [ 'author' ] = $wpdb -> get_var ( " SELECT ID FROM $wpdb->users WHERE user_nicename=' " . $q [ 'author_name' ] . " ' " );
$whichauthor .= ' AND (post_author = ' . intval ( $q [ 'author' ]) . ')' ;
}
2005-11-28 20:43:32 -05:00
2004-09-05 16:00:09 -04:00
$where .= $search . $whichcat . $whichauthor ;
if (( empty ( $q [ 'order' ])) || (( strtoupper ( $q [ 'order' ]) != 'ASC' ) && ( strtoupper ( $q [ 'order' ]) != 'DESC' ))) {
$q [ 'order' ] = 'DESC' ;
}
// Order by
if ( empty ( $q [ 'orderby' ])) {
$q [ 'orderby' ] = 'date ' . $q [ 'order' ];
} else {
// Used to filter values
2005-11-14 05:12:22 -05:00
$allowed_keys = array ( 'author' , 'date' , 'category' , 'title' , 'modified' );
2004-09-05 16:00:09 -04:00
$q [ 'orderby' ] = urldecode ( $q [ 'orderby' ]);
$q [ 'orderby' ] = addslashes_gpc ( $q [ 'orderby' ]);
$orderby_array = explode ( ' ' , $q [ 'orderby' ]);
if ( ! in_array ( $orderby_array [ 0 ], $allowed_keys )) {
$orderby_array [ 0 ] = 'date' ;
}
$q [ 'orderby' ] = $orderby_array [ 0 ] . ' ' . $q [ 'order' ];
if ( count ( $orderby_array ) > 1 ) {
for ( $i = 1 ; $i < ( count ( $orderby_array )); $i = $i + 1 ) {
// Only allow certain values for safety
if ( in_array ( $orderby_array [ $i ], $allowed_keys )) {
$q [ 'orderby' ] .= ',post_' . $orderby_array [ $i ] . ' ' . $q [ 'order' ];
}
}
}
}
$now = gmdate ( 'Y-m-d H:i:59' );
2005-11-06 02:04:46 -05:00
//only select past-dated posts, except if a logged in user is viewing a single: then, if they
//can edit the post, we let them through
if ( $pagenow != 'post.php' && $pagenow != 'edit.php' && ! ( $this -> is_single && $user_ID )) {
2005-01-31 20:49:51 -05:00
$where .= " AND post_date_gmt <= ' $now ' " ;
2004-09-05 16:00:09 -04:00
$distinct = 'DISTINCT' ;
}
2005-11-15 17:55:24 -05:00
if ( $this -> is_attachment ) {
$where .= ' AND (post_status = "attachment")' ;
2005-10-20 16:48:32 -04:00
} elseif ( $this -> is_page ) {
2005-04-09 13:12:36 -04:00
$where .= ' AND (post_status = "static")' ;
} elseif ( $this -> is_single ) {
$where .= ' AND (post_status != "static")' ;
2004-09-05 16:00:09 -04:00
} else {
$where .= ' AND (post_status = "publish"' ;
2005-04-09 13:12:36 -04:00
if ( isset ( $user_ID ) && ( '' != intval ( $user_ID )))
$where .= " OR post_author = $user_ID AND post_status != 'draft' AND post_status != 'static') " ;
else
$where .= ')' ;
}
2004-09-05 16:00:09 -04:00
2005-11-15 17:55:24 -05:00
if ( ! $this -> is_attachment )
$where .= ' AND post_status != "attachment"' ;
2005-09-23 19:24:19 -04:00
2004-12-24 19:32:50 -05:00
// Apply filters on where and join prior to paging so that any
// manipulations to them are reflected in the paging by day queries.
$where = apply_filters ( 'posts_where' , $where );
$join = apply_filters ( 'posts_join' , $join );
2004-09-05 16:00:09 -04:00
// Paging
2006-04-25 19:00:56 -04:00
if ( empty ( $q [ 'nopaging' ]) && ! $this -> is_single && ! $this -> is_page ) {
2006-07-04 16:01:31 -04:00
$page = abs ( intval ( $q [ 'paged' ]));
2004-09-05 16:00:09 -04:00
if ( empty ( $page )) {
$page = 1 ;
}
if (( $q [ 'what_to_show' ] == 'posts' )) {
2006-07-04 16:01:31 -04:00
$q [ 'offset' ] = abs ( intval ( $q [ 'offset' ]));
if ( empty ( $q [ 'offset' ]) ) {
$pgstrt = '' ;
$pgstrt = ( intval ( $page ) - 1 ) * $q [ 'posts_per_page' ] . ', ' ;
$limits = 'LIMIT ' . $pgstrt . $q [ 'posts_per_page' ];
} else { // we're ignoring $page and using 'offset'
$pgstrt = $q [ 'offset' ] . ', ' ;
$limits = 'LIMIT ' . $pgstrt . $q [ 'posts_per_page' ];
}
2004-09-05 16:00:09 -04:00
} elseif ( $q [ 'what_to_show' ] == 'days' ) {
2004-09-06 16:03:16 -04:00
$startrow = $q [ 'posts_per_page' ] * ( intval ( $page ) - 1 );
$start_date = $wpdb -> get_var ( " SELECT max(post_date) FROM $wpdb->posts $join WHERE (1=1) $where GROUP BY year(post_date), month(post_date), dayofmonth(post_date) ORDER BY post_date DESC LIMIT $startrow ,1 " );
2004-09-07 20:02:53 -04:00
$endrow = $startrow + $q [ 'posts_per_page' ] - 1 ;
$end_date = $wpdb -> get_var ( " SELECT min(post_date) FROM $wpdb->posts $join WHERE (1=1) $where GROUP BY year(post_date), month(post_date), dayofmonth(post_date) ORDER BY post_date DESC LIMIT $endrow ,1 " );
2004-09-05 16:00:09 -04:00
if ( $page > 1 ) {
2004-09-06 16:03:16 -04:00
$where .= " AND post_date >= ' $end_date ' AND post_date <= ' $start_date ' " ;
2004-09-05 16:00:09 -04:00
} else {
2004-09-06 16:03:16 -04:00
$where .= " AND post_date >= ' $end_date ' " ;
2004-09-05 16:00:09 -04:00
}
}
}
2004-12-24 19:32:50 -05:00
// Apply post-paging filters on where and join. Only plugins that
// manipulate paging queries should use these hooks.
$where = apply_filters ( 'posts_where_paged' , $where );
2005-11-17 04:10:18 -05:00
$groupby = " $wpdb->posts .ID " ;
$groupby = apply_filters ( 'posts_groupby' , $groupby );
2004-12-24 19:32:50 -05:00
$join = apply_filters ( 'posts_join_paged' , $join );
2005-03-21 20:55:07 -05:00
$orderby = " post_ " . $q [ 'orderby' ];
$orderby = apply_filters ( 'posts_orderby' , $orderby );
2005-11-17 04:10:18 -05:00
$request = " SELECT $distinct * FROM $wpdb->posts $join WHERE 1=1 " . $where . " GROUP BY " . $groupby . " ORDER BY " . $orderby . " $limits " ;
2006-01-11 06:06:26 -05:00
$this -> request = apply_filters ( 'posts_request' , $request );
2004-09-05 16:00:09 -04:00
2006-01-11 06:06:26 -05:00
$this -> posts = $wpdb -> get_results ( $this -> request );
2005-04-09 13:12:36 -04:00
// Check post status to determine if post should be displayed.
2006-03-02 21:18:55 -05:00
if ( ! empty ( $this -> posts ) && $this -> is_single ) {
2005-10-20 16:48:32 -04:00
$status = get_post_status ( $this -> posts [ 0 ]);
2005-12-11 20:33:46 -05:00
if ( ( 'publish' != $status ) && ( 'static' != $status ) ) {
2005-04-09 13:12:36 -04:00
if ( ! ( isset ( $user_ID ) && ( '' != intval ( $user_ID ))) ) {
// User must be logged in to view unpublished posts.
$this -> posts = array ();
} else {
2005-10-20 16:48:32 -04:00
if ( 'draft' == $status ) {
2005-04-09 13:12:36 -04:00
// User must have edit permissions on the draft to preview.
2005-11-15 19:50:02 -05:00
if ( ! current_user_can ( 'edit_post' , $this -> posts [ 0 ] -> ID )) {
2005-04-09 13:12:36 -04:00
$this -> posts = array ();
2005-11-06 02:04:46 -05:00
} else {
$this -> is_preview = true ;
2006-01-18 14:30:28 -05:00
$this -> posts [ 0 ] -> post_date = current_time ( 'mysql' );
2005-11-06 02:04:46 -05:00
}
2005-12-12 19:54:52 -05:00
} else {
if ( ! current_user_can ( 'read_post' , $this -> posts [ 0 ] -> ID ))
2005-04-09 13:12:36 -04:00
$this -> posts = array ();
}
}
2005-11-06 02:04:46 -05:00
} else {
2005-11-14 18:28:10 -05:00
if ( mysql2date ( 'U' , $this -> posts [ 0 ] -> post_date_gmt ) > mysql2date ( 'U' , $now )) { //it's future dated
2005-11-06 02:04:46 -05:00
$this -> is_preview = true ;
if ( ! current_user_can ( 'edit_post' , $this -> posts [ 0 ] -> ID )) {
$this -> posts = array ( );
}
}
2004-09-05 16:00:09 -04:00
}
}
2005-12-12 22:49:09 -05:00
update_post_caches ( $this -> posts );
2004-09-05 16:00:09 -04:00
$this -> posts = apply_filters ( 'the_posts' , $this -> posts );
$this -> post_count = count ( $this -> posts );
if ( $this -> post_count > 0 ) {
2004-10-02 15:24:40 -04:00
$this -> post = $this -> posts [ 0 ];
2004-09-05 16:00:09 -04:00
}
2004-09-08 23:45:51 -04:00
// Save any changes made to the query vars.
$this -> query_vars = $q ;
2004-09-05 16:00:09 -04:00
return $this -> posts ;
2004-08-10 01:35:59 -04:00
}
2004-08-08 11:31:50 -04:00
2004-09-05 16:00:09 -04:00
function next_post () {
2004-08-08 11:31:50 -04:00
2004-09-05 16:00:09 -04:00
$this -> current_post ++ ;
2004-08-08 11:31:50 -04:00
2004-09-05 16:00:09 -04:00
$this -> post = $this -> posts [ $this -> current_post ];
return $this -> post ;
}
2004-08-08 11:31:50 -04:00
2005-01-18 21:21:36 -05:00
function the_post () {
global $post ;
2005-07-17 12:58:13 -04:00
$this -> in_the_loop = true ;
2005-01-18 21:21:36 -05:00
$post = $this -> next_post ();
setup_postdata ( $post );
2005-08-02 20:28:09 -04:00
if ( $this -> current_post == 0 ) // loop has just started
do_action ( 'loop_start' );
2005-01-18 21:21:36 -05:00
}
2004-09-05 16:00:09 -04:00
function have_posts () {
if ( $this -> current_post + 1 < $this -> post_count ) {
return true ;
2005-07-17 12:58:13 -04:00
} elseif ( $this -> current_post + 1 == $this -> post_count ) {
2005-08-02 20:28:09 -04:00
do_action ( 'loop_end' );
2005-07-17 12:58:13 -04:00
// Do some cleaning up after the loop
$this -> rewind_posts ();
2004-09-05 16:00:09 -04:00
}
2004-08-08 11:31:50 -04:00
2005-07-17 12:58:13 -04:00
$this -> in_the_loop = false ;
2004-09-05 16:00:09 -04:00
return false ;
}
2004-12-31 16:49:48 -05:00
function rewind_posts () {
$this -> current_post = - 1 ;
if ( $this -> post_count > 0 ) {
$this -> post = $this -> posts [ 0 ];
}
}
2004-08-08 11:31:50 -04:00
2005-03-27 15:45:01 -05:00
function & query ( $query ) {
2004-09-05 16:00:09 -04:00
$this -> parse_query ( $query );
return $this -> get_posts ();
}
2004-10-02 15:24:40 -04:00
function get_queried_object () {
if ( isset ( $this -> queried_object )) {
return $this -> queried_object ;
}
$this -> queried_object = NULL ;
$this -> queried_object_id = 0 ;
if ( $this -> is_category ) {
2005-06-12 22:09:24 -04:00
$cat = $this -> get ( 'cat' );
$category = & get_category ( $cat );
2005-03-27 15:45:01 -05:00
$this -> queried_object = & $category ;
2005-06-12 22:09:24 -04:00
$this -> queried_object_id = $cat ;
2004-10-02 15:24:40 -04:00
} else if ( $this -> is_single ) {
$this -> queried_object = $this -> post ;
$this -> queried_object_id = $this -> post -> ID ;
} else if ( $this -> is_page ) {
$this -> queried_object = $this -> post ;
$this -> queried_object_id = $this -> post -> ID ;
} else if ( $this -> is_author ) {
2005-12-11 14:14:29 -05:00
$author_id = $this -> get ( 'author' );
$author = get_userdata ( $author_id );
$this -> queried_object = $author ;
$this -> queried_object_id = $author_id ;
2004-10-02 15:24:40 -04:00
}
return $this -> queried_object ;
}
function get_queried_object_id () {
$this -> get_queried_object ();
if ( isset ( $this -> queried_object_id )) {
return $this -> queried_object_id ;
}
return 0 ;
}
2004-09-05 16:00:09 -04:00
function WP_Query ( $query = '' ) {
if ( ! empty ( $query )) {
$this -> query ( $query );
}
}
2004-06-30 11:31:49 -04:00
}
2004-09-08 04:17:53 -04:00
class retrospam_mgr {
var $spam_words ;
var $comments_list ;
var $found_comments ;
function retrospam_mgr () {
global $wpdb ;
$list = explode ( " \n " , get_settings ( 'moderation_keys' ) );
$list = array_unique ( $list );
$this -> spam_words = $list ;
$this -> comment_list = $wpdb -> get_results ( " SELECT comment_ID AS ID, comment_content AS text, comment_approved AS approved, comment_author_url AS url, comment_author_ip AS ip, comment_author_email AS email FROM $wpdb->comments ORDER BY comment_ID ASC " );
} // End of class constructor
function move_spam ( $id_list ) {
global $wpdb ;
$cnt = 0 ;
$id_list = explode ( ',' , $id_list );
foreach ( $id_list as $comment ) {
if ( $wpdb -> query ( " update $wpdb->comments set comment_approved = '0' where comment_ID = ' $comment ' " ) ) {
$cnt ++ ;
}
}
2006-09-24 22:38:55 -04:00
echo " <div class='updated'><p> " ;
printf ( __ ( '%d comment(s) moved to the moderation queue.' ), $cnt );
echo " </p></div> \n " ;
2004-09-08 04:17:53 -04:00
} // End function move_spam
function find_spam () {
$in_queue = 0 ;
foreach ( $this -> comment_list as $comment ) {
if ( $comment -> approved == 1 ) {
foreach ( $this -> spam_words as $word ) {
2005-09-18 22:49:53 -04:00
$word = trim ( $word );
if ( empty ( $word ) )
2005-02-10 21:16:38 -05:00
continue ;
2004-09-08 04:17:53 -04:00
$fulltext = strtolower ( $comment -> email . ' ' . $comment -> url . ' ' . $comment -> ip . ' ' . $comment -> text );
2006-04-21 17:18:32 -04:00
if ( false !== strpos ( $fulltext , strtolower ( $word ) ) ) {
2004-09-08 04:17:53 -04:00
$this -> found_comments [] = $comment -> ID ;
break ;
}
}
} else {
$in_queue ++ ;
}
}
return array ( 'found' => $this -> found_comments , 'in_queue' => $in_queue );
} // End function find_spam
function display_edit_form ( $counters ) {
$numfound = count ( $counters [ found ]);
$numqueue = $counters [ in_queue ];
2006-09-24 22:38:55 -04:00
$body = '<p>' . sprintf ( __ ( 'Suspected spam comments: %s' ), " <strong> $numfound </strong> " ) . '</p>' ;
2004-09-08 04:17:53 -04:00
if ( count ( $counters [ found ]) > 0 ) {
$id_list = implode ( ',' , $counters [ found ] );
2004-12-20 12:10:15 -05:00
$body .= '<p><a href="options-discussion.php?action=retrospam&move=true&ids=' . $id_list . '">' . __ ( 'Move suspect comments to moderation queue »' ) . '</a></p>' ;
2004-09-08 04:17:53 -04:00
}
$head = '<div class="wrap"><h2>' . __ ( 'Check Comments Results:' ) . '</h2>' ;
$foot .= '<p><a href="options-discussion.php">' . __ ( '« Return to Discussion Options page.' ) . '</a></p></div>' ;
return $head . $body . $foot ;
} // End function display_edit_form
}
2004-12-02 21:38:11 -05:00
class WP_Rewrite {
var $permalink_structure ;
var $category_base ;
var $category_structure ;
2005-01-26 17:46:40 -05:00
var $author_base = 'author' ;
2004-12-08 21:40:35 -05:00
var $author_structure ;
2004-12-02 21:38:11 -05:00
var $date_structure ;
2005-01-26 17:46:40 -05:00
var $page_structure ;
var $search_base = 'search' ;
var $search_structure ;
var $comments_base = 'comments' ;
var $feed_base = 'feed' ;
var $comments_feed_structure ;
var $feed_structure ;
2004-12-02 21:38:11 -05:00
var $front ;
2004-12-03 19:12:08 -05:00
var $root = '' ;
2004-12-02 21:38:11 -05:00
var $index = 'index.php' ;
var $matches = '' ;
2004-12-03 19:12:08 -05:00
var $rules ;
2005-06-12 22:09:24 -04:00
var $use_verbose_rules = false ;
2004-12-02 21:38:11 -05:00
var $rewritecode =
array (
'%year%' ,
'%monthnum%' ,
'%day%' ,
'%hour%' ,
'%minute%' ,
'%second%' ,
'%postname%' ,
'%post_id%' ,
'%category%' ,
'%author%' ,
'%pagename%' ,
'%search%'
);
var $rewritereplace =
array (
'([0-9]{4})' ,
'([0-9]{1,2})' ,
'([0-9]{1,2})' ,
'([0-9]{1,2})' ,
'([0-9]{1,2})' ,
'([0-9]{1,2})' ,
'([^/]+)' ,
'([0-9]+)' ,
'(.+?)' ,
'([^/]+)' ,
'([^/]+)' ,
'(.+)'
);
var $queryreplace =
array (
2005-10-20 16:48:32 -04:00
'year=' ,
'monthnum=' ,
'day=' ,
'hour=' ,
'minute=' ,
'second=' ,
'name=' ,
'p=' ,
'category_name=' ,
'author_name=' ,
'pagename=' ,
's='
);
2004-12-02 21:38:11 -05:00
2005-02-13 13:42:40 -05:00
var $feeds = array ( 'feed' , 'rdf' , 'rss' , 'rss2' , 'atom' );
2004-12-27 17:30:52 -05:00
function using_permalinks () {
if ( empty ( $this -> permalink_structure ))
return false ;
else
return true ;
}
2004-12-02 21:38:11 -05:00
function using_index_permalinks () {
2005-10-20 16:48:32 -04:00
if ( empty ( $this -> permalink_structure )) {
2004-12-02 21:38:11 -05:00
return false ;
2005-10-20 16:48:32 -04:00
}
2004-12-02 21:38:11 -05:00
2005-10-20 16:48:32 -04:00
// If the index is not in the permalink, we're using mod_rewrite.
if ( preg_match ( '#^/*' . $this -> index . '#' , $this -> permalink_structure )) {
return true ;
}
2004-12-02 21:38:11 -05:00
2005-10-20 16:48:32 -04:00
return false ;
2004-12-02 21:38:11 -05:00
}
2004-12-27 17:30:52 -05:00
function using_mod_rewrite_permalinks () {
if ( $this -> using_permalinks () && ! $this -> using_index_permalinks ())
return true ;
else
return false ;
}
2004-12-02 21:38:11 -05:00
function preg_index ( $number ) {
2005-10-20 16:48:32 -04:00
$match_prefix = '$' ;
$match_suffix = '' ;
if ( ! empty ( $this -> matches )) {
2004-12-02 21:38:11 -05:00
$match_prefix = '$' . $this -> matches . '[' ;
$match_suffix = ']' ;
2005-10-20 16:48:32 -04:00
}
return " $match_prefix $number $match_suffix " ;
2004-12-02 21:38:11 -05:00
}
function page_rewrite_rules () {
$uris = get_settings ( 'page_uris' );
2005-12-27 23:27:21 -05:00
$attachment_uris = get_settings ( 'page_attachment_uris' );
2004-12-02 21:38:11 -05:00
$rewrite_rules = array ();
2005-01-26 17:46:40 -05:00
$page_structure = $this -> get_page_permastruct ();
2005-12-27 23:27:21 -05:00
if ( is_array ( $attachment_uris ) ) {
foreach ( $attachment_uris as $uri => $pagename ) {
$this -> add_rewrite_tag ( '%pagename%' , " ( $uri ) " , 'attachment=' );
2006-01-23 18:20:17 -05:00
$rewrite_rules = array_merge ( $rewrite_rules , $this -> generate_rewrite_rules ( $page_structure ));
2005-12-27 23:27:21 -05:00
}
}
if ( is_array ( $uris ) ) {
foreach ( $uris as $uri => $pagename ) {
$this -> add_rewrite_tag ( '%pagename%' , " ( $uri ) " , 'pagename=' );
2006-01-23 18:20:17 -05:00
$rewrite_rules = array_merge ( $rewrite_rules , $this -> generate_rewrite_rules ( $page_structure ));
2004-12-02 21:38:11 -05:00
}
2005-12-27 23:27:21 -05:00
}
2004-12-02 21:38:11 -05:00
return $rewrite_rules ;
}
function get_date_permastruct () {
if ( isset ( $this -> date_structure )) {
return $this -> date_structure ;
}
2005-10-20 16:48:32 -04:00
if ( empty ( $this -> permalink_structure )) {
2004-12-02 21:38:11 -05:00
$this -> date_structure = '' ;
return false ;
}
// The date permalink must have year, month, and day separated by slashes.
$endians = array ( '%year%/%monthnum%/%day%' , '%day%/%monthnum%/%year%' , '%monthnum%/%day%/%year%' );
$this -> date_structure = '' ;
2005-03-05 13:13:31 -05:00
$date_endian = '' ;
2004-12-02 21:38:11 -05:00
foreach ( $endians as $endian ) {
if ( false !== strpos ( $this -> permalink_structure , $endian )) {
2005-03-05 13:13:31 -05:00
$date_endian = $endian ;
2004-12-02 21:38:11 -05:00
break ;
}
}
2005-03-05 13:13:31 -05:00
if ( empty ( $date_endian ) )
$date_endian = '%year%/%monthnum%/%day%' ;
2005-02-13 13:26:50 -05:00
// Do not allow the date tags and %post_id% to overlap in the permalink
// structure. If they do, move the date tags to $front/date/.
$front = $this -> front ;
2005-03-05 13:13:31 -05:00
preg_match_all ( '/%.+?%/' , $this -> permalink_structure , $tokens );
$tok_index = 1 ;
foreach ( $tokens [ 0 ] as $token ) {
if ( ( $token == '%post_id%' ) && ( $tok_index <= 3 ) ) {
$front = $front . 'date/' ;
break ;
}
2004-12-02 21:38:11 -05:00
}
2005-03-05 13:13:31 -05:00
$this -> date_structure = $front . $date_endian ;
2004-12-02 21:38:11 -05:00
return $this -> date_structure ;
}
function get_year_permastruct () {
2005-09-02 13:08:39 -04:00
$structure = $this -> get_date_permastruct ( $this -> permalink_structure );
2004-12-02 21:38:11 -05:00
if ( empty ( $structure )) {
return false ;
}
$structure = str_replace ( '%monthnum%' , '' , $structure );
$structure = str_replace ( '%day%' , '' , $structure );
$structure = preg_replace ( '#/+#' , '/' , $structure );
return $structure ;
}
function get_month_permastruct () {
2005-09-02 13:08:39 -04:00
$structure = $this -> get_date_permastruct ( $this -> permalink_structure );
2004-12-02 21:38:11 -05:00
if ( empty ( $structure )) {
return false ;
}
$structure = str_replace ( '%day%' , '' , $structure );
$structure = preg_replace ( '#/+#' , '/' , $structure );
return $structure ;
}
function get_day_permastruct () {
2005-09-02 13:08:39 -04:00
return $this -> get_date_permastruct ( $this -> permalink_structure );
2004-12-02 21:38:11 -05:00
}
function get_category_permastruct () {
if ( isset ( $this -> category_structure )) {
return $this -> category_structure ;
}
2005-10-20 16:48:32 -04:00
if ( empty ( $this -> permalink_structure )) {
2004-12-02 21:38:11 -05:00
$this -> category_structure = '' ;
return false ;
}
if ( empty ( $this -> category_base ))
$this -> category_structure = $this -> front . 'category/' ;
else
$this -> category_structure = $this -> category_base . '/' ;
$this -> category_structure .= '%category%' ;
return $this -> category_structure ;
}
2004-12-08 21:40:35 -05:00
function get_author_permastruct () {
if ( isset ( $this -> author_structure )) {
return $this -> author_structure ;
}
2005-10-20 16:48:32 -04:00
if ( empty ( $this -> permalink_structure )) {
2004-12-08 21:40:35 -05:00
$this -> author_structure = '' ;
return false ;
}
2005-01-26 17:46:40 -05:00
$this -> author_structure = $this -> front . $this -> author_base . '/%author%' ;
2004-12-08 21:40:35 -05:00
return $this -> author_structure ;
}
2005-01-26 17:46:40 -05:00
function get_search_permastruct () {
if ( isset ( $this -> search_structure )) {
return $this -> search_structure ;
}
2005-10-20 16:48:32 -04:00
if ( empty ( $this -> permalink_structure )) {
2005-01-26 17:46:40 -05:00
$this -> search_structure = '' ;
return false ;
}
$this -> search_structure = $this -> root . $this -> search_base . '/%search%' ;
return $this -> search_structure ;
}
function get_page_permastruct () {
if ( isset ( $this -> page_structure )) {
return $this -> page_structure ;
}
2005-10-20 16:48:32 -04:00
if ( empty ( $this -> permalink_structure )) {
2005-01-26 17:46:40 -05:00
$this -> page_structure = '' ;
return false ;
}
$this -> page_structure = $this -> root . '%pagename%' ;
return $this -> page_structure ;
}
function get_feed_permastruct () {
if ( isset ( $this -> feed_structure )) {
return $this -> feed_structure ;
}
2005-10-20 16:48:32 -04:00
if ( empty ( $this -> permalink_structure )) {
2005-01-26 17:46:40 -05:00
$this -> feed_structure = '' ;
return false ;
}
$this -> feed_structure = $this -> root . $this -> feed_base . '/%feed%' ;
return $this -> feed_structure ;
}
function get_comment_feed_permastruct () {
if ( isset ( $this -> comment_feed_structure )) {
return $this -> comment_feed_structure ;
}
2005-10-20 16:48:32 -04:00
if ( empty ( $this -> permalink_structure )) {
2005-01-26 17:46:40 -05:00
$this -> comment_feed_structure = '' ;
return false ;
}
$this -> comment_feed_structure = $this -> root . $this -> comments_base . '/' . $this -> feed_base . '/%feed%' ;
return $this -> comment_feed_structure ;
}
2004-12-03 19:12:08 -05:00
function add_rewrite_tag ( $tag , $pattern , $query ) {
2005-01-24 19:23:57 -05:00
// If the tag already exists, replace the existing pattern and query for
// that tag, otherwise add the new tag, pattern, and query to the end of
// the arrays.
$position = array_search ( $tag , $this -> rewritecode );
if ( FALSE !== $position && NULL !== $position ) {
$this -> rewritereplace [ $position ] = $pattern ;
$this -> queryreplace [ $position ] = $query ;
} else {
$this -> rewritecode [] = $tag ;
$this -> rewritereplace [] = $pattern ;
$this -> queryreplace [] = $query ;
}
2004-12-03 19:12:08 -05:00
}
2006-01-03 19:41:53 -05:00
function generate_rewrite_rules ( $permalink_structure , $paged = true , $feed = true , $forcomments = false , $walk_dirs = true ) {
2005-02-13 13:42:40 -05:00
$feedregex2 = '' ;
2005-03-07 20:20:08 -05:00
foreach ( $this -> feeds as $feed_name ) {
$feedregex2 .= $feed_name . '|' ;
2005-02-13 13:42:40 -05:00
}
$feedregex2 = '(' . trim ( $feedregex2 , '|' ) . ')/?$' ;
$feedregex = $this -> feed_base . '/' . $feedregex2 ;
2004-12-02 21:38:11 -05:00
$trackbackregex = 'trackback/?$' ;
$pageregex = 'page/?([0-9]{1,})/?$' ;
$front = substr ( $permalink_structure , 0 , strpos ( $permalink_structure , '%' ));
preg_match_all ( '/%.+?%/' , $permalink_structure , $tokens );
$num_tokens = count ( $tokens [ 0 ]);
$index = $this -> index ;
$feedindex = $index ;
$trackbackindex = $index ;
for ( $i = 0 ; $i < $num_tokens ; ++ $i ) {
if ( 0 < $i ) {
$queries [ $i ] = $queries [ $i - 1 ] . '&' ;
}
$query_token = str_replace ( $this -> rewritecode , $this -> queryreplace , $tokens [ 0 ][ $i ]) . $this -> preg_index ( $i + 1 );
$queries [ $i ] .= $query_token ;
}
$structure = $permalink_structure ;
if ( $front != '/' ) {
$structure = str_replace ( $front , '' , $structure );
}
$structure = trim ( $structure , '/' );
2004-12-18 14:40:02 -05:00
if ( $walk_dirs ) {
$dirs = explode ( '/' , $structure );
} else {
$dirs [] = $structure ;
}
2004-12-02 21:38:11 -05:00
$num_dirs = count ( $dirs );
$front = preg_replace ( '|^/+|' , '' , $front );
$post_rewrite = array ();
$struct = $front ;
for ( $j = 0 ; $j < $num_dirs ; ++ $j ) {
$struct .= $dirs [ $j ] . '/' ;
$struct = ltrim ( $struct , '/' );
$match = str_replace ( $this -> rewritecode , $this -> rewritereplace , $struct );
$num_toks = preg_match_all ( '/%.+?%/' , $struct , $toks );
$query = $queries [ $num_toks - 1 ];
$pagematch = $match . $pageregex ;
$pagequery = $index . '?' . $query . '&paged=' . $this -> preg_index ( $num_toks + 1 );
$feedmatch = $match . $feedregex ;
$feedquery = $feedindex . '?' . $query . '&feed=' . $this -> preg_index ( $num_toks + 1 );
$feedmatch2 = $match . $feedregex2 ;
$feedquery2 = $feedindex . '?' . $query . '&feed=' . $this -> preg_index ( $num_toks + 1 );
if ( $forcomments ) {
$feedquery .= '&withcomments=1' ;
$feedquery2 .= '&withcomments=1' ;
}
2004-12-03 19:12:08 -05:00
$rewrite = array ();
if ( $feed )
$rewrite = array ( $feedmatch => $feedquery , $feedmatch2 => $feedquery2 );
2006-01-03 19:41:53 -05:00
if ( $paged )
2006-01-23 18:20:17 -05:00
$rewrite = array_merge ( $rewrite , array ( $pagematch => $pagequery ));
2004-12-02 21:38:11 -05:00
if ( $num_toks ) {
2005-12-27 23:27:21 -05:00
$post = false ;
$page = false ;
2004-12-02 21:38:11 -05:00
if ( strstr ( $struct , '%postname%' ) || strstr ( $struct , '%post_id%' )
2005-01-24 19:23:57 -05:00
|| strstr ( $struct , '%pagename%' )
2004-12-02 21:38:11 -05:00
|| ( strstr ( $struct , '%year%' ) && strstr ( $struct , '%monthnum%' ) && strstr ( $struct , '%day%' ) && strstr ( $struct , '%hour%' ) && strstr ( $struct , '%minute' ) && strstr ( $struct , '%second%' ))) {
2005-12-27 23:27:21 -05:00
$post = true ;
if ( strstr ( $struct , '%pagename%' ) )
$page = true ;
2004-12-02 21:38:11 -05:00
$trackbackmatch = $match . $trackbackregex ;
$trackbackquery = $trackbackindex . '?' . $query . '&tb=1' ;
2005-04-14 00:24:22 -04:00
$match = rtrim ( $match , '/' );
2005-10-20 16:48:32 -04:00
$submatchbase = str_replace ( array ( '(' , ')' ), '' , $match );
$sub1 = $submatchbase . '/([^/]+)/' ;
$sub1tb = $sub1 . $trackbackregex ;
$sub1feed = $sub1 . $feedregex ;
$sub1feed2 = $sub1 . $feedregex2 ;
$sub1 .= '?$' ;
2005-11-15 17:55:24 -05:00
$sub2 = $submatchbase . '/attachment/([^/]+)/' ;
2005-10-20 16:48:32 -04:00
$sub2tb = $sub2 . $trackbackregex ;
$sub2feed = $sub2 . $feedregex ;
$sub2feed2 = $sub2 . $feedregex2 ;
$sub2 .= '?$' ;
2005-11-15 17:55:24 -05:00
$subquery = $index . '?attachment=' . $this -> preg_index ( 1 );
2005-10-20 16:48:32 -04:00
$subtbquery = $subquery . '&tb=1' ;
$subfeedquery = $subquery . '&feed=' . $this -> preg_index ( 2 );
2005-04-14 00:24:22 -04:00
$match = $match . '(/[0-9]+)?/?$' ;
2004-12-02 21:38:11 -05:00
$query = $index . '?' . $query . '&page=' . $this -> preg_index ( $num_toks + 1 );
} else {
$match .= '?$' ;
$query = $index . '?' . $query ;
}
2006-01-23 18:20:17 -05:00
$rewrite = array_merge ( $rewrite , array ( $match => $query ));
2004-12-02 21:38:11 -05:00
if ( $post ) {
2006-01-23 18:20:17 -05:00
$rewrite = array_merge ( array ( $trackbackmatch => $trackbackquery ), $rewrite );
2005-12-27 23:27:21 -05:00
if ( ! $page )
2006-01-23 18:20:17 -05:00
$rewrite = array_merge ( $rewrite , array ( $sub1 => $subquery , $sub1tb => $subtbquery , $sub1feed => $subfeedquery , $sub1feed2 => $subfeedquery ));
$rewrite = array_merge ( $rewrite , array ( $sub2 => $subquery , $sub2tb => $subtbquery , $sub2feed => $subfeedquery , $sub2feed2 => $subfeedquery ));
2004-12-02 21:38:11 -05:00
}
}
2006-01-23 18:20:17 -05:00
$post_rewrite = array_merge ( $rewrite , $post_rewrite );
2004-12-02 21:38:11 -05:00
}
return $post_rewrite ;
}
2004-12-18 14:40:02 -05:00
function generate_rewrite_rule ( $permalink_structure , $walk_dirs = false ) {
return $this -> generate_rewrite_rules ( $permalink_structure , false , false , false , $walk_dirs );
}
2004-12-02 21:38:11 -05:00
/* rewrite_rules
* Construct rewrite matches and queries from permalink structure .
* Returns an associate array of matches and queries .
*/
function rewrite_rules () {
$rewrite = array ();
if ( empty ( $this -> permalink_structure )) {
return $rewrite ;
}
// Post
$post_rewrite = $this -> generate_rewrite_rules ( $this -> permalink_structure );
2005-01-21 00:10:13 -05:00
$post_rewrite = apply_filters ( 'post_rewrite_rules' , $post_rewrite );
2004-12-02 21:38:11 -05:00
// Date
$date_rewrite = $this -> generate_rewrite_rules ( $this -> get_date_permastruct ());
2005-01-21 00:10:13 -05:00
$date_rewrite = apply_filters ( 'date_rewrite_rules' , $date_rewrite );
2004-12-02 21:38:11 -05:00
// Root
2004-12-03 19:12:08 -05:00
$root_rewrite = $this -> generate_rewrite_rules ( $this -> root . '/' );
2005-01-21 00:10:13 -05:00
$root_rewrite = apply_filters ( 'root_rewrite_rules' , $root_rewrite );
2004-12-02 21:38:11 -05:00
// Comments
2006-02-19 05:28:09 -05:00
$comments_rewrite = $this -> generate_rewrite_rules ( $this -> root . $this -> comments_base , true , true , true , false );
2005-01-21 00:10:13 -05:00
$comments_rewrite = apply_filters ( 'comments_rewrite_rules' , $comments_rewrite );
2004-12-02 21:38:11 -05:00
// Search
2005-01-26 17:46:40 -05:00
$search_structure = $this -> get_search_permastruct ();
2004-12-02 21:38:11 -05:00
$search_rewrite = $this -> generate_rewrite_rules ( $search_structure );
2005-01-21 00:10:13 -05:00
$search_rewrite = apply_filters ( 'search_rewrite_rules' , $search_rewrite );
2004-12-02 21:38:11 -05:00
// Categories
$category_rewrite = $this -> generate_rewrite_rules ( $this -> get_category_permastruct ());
2005-01-21 00:10:13 -05:00
$category_rewrite = apply_filters ( 'category_rewrite_rules' , $category_rewrite );
2004-12-02 21:38:11 -05:00
// Authors
2004-12-08 21:40:35 -05:00
$author_rewrite = $this -> generate_rewrite_rules ( $this -> get_author_permastruct ());
2005-01-21 00:10:13 -05:00
$author_rewrite = apply_filters ( 'author_rewrite_rules' , $author_rewrite );
2004-12-02 21:38:11 -05:00
// Pages
$page_rewrite = $this -> page_rewrite_rules ();
2005-01-21 00:10:13 -05:00
$page_rewrite = apply_filters ( 'page_rewrite_rules' , $page_rewrite );
2004-12-02 21:38:11 -05:00
// Put them together.
2006-01-23 18:20:17 -05:00
$this -> rules = array_merge ( $page_rewrite , $root_rewrite , $comments_rewrite , $search_rewrite , $category_rewrite , $author_rewrite , $date_rewrite , $post_rewrite );
2004-12-02 21:38:11 -05:00
2005-02-01 01:20:54 -05:00
do_action ( 'generate_rewrite_rules' , array ( & $this ));
2004-12-03 19:12:08 -05:00
$this -> rules = apply_filters ( 'rewrite_rules_array' , $this -> rules );
2005-10-20 16:48:32 -04:00
2004-12-03 19:12:08 -05:00
return $this -> rules ;
2004-12-02 21:38:11 -05:00
}
function wp_rewrite_rules () {
2005-12-28 02:05:05 -05:00
$this -> rules = get_option ( 'rewrite_rules' );
if ( empty ( $this -> rules ) ) {
$this -> matches = 'matches' ;
$this -> rewrite_rules ();
update_option ( 'rewrite_rules' , $this -> rules );
}
return $this -> rules ;
2004-12-02 21:38:11 -05:00
}
2005-01-21 00:10:13 -05:00
function mod_rewrite_rules () {
2004-12-27 17:30:52 -05:00
if ( ! $this -> using_permalinks ()) {
return '' ;
}
2005-02-01 02:05:00 -05:00
$site_root = parse_url ( get_settings ( 'siteurl' ));
$site_root = trailingslashit ( $site_root [ 'path' ]);
2004-12-02 21:38:11 -05:00
2005-02-01 02:05:00 -05:00
$home_root = parse_url ( get_settings ( 'home' ));
$home_root = trailingslashit ( $home_root [ 'path' ]);
2004-12-02 21:38:11 -05:00
$rules = " <IfModule mod_rewrite.c> \n " ;
$rules .= " RewriteEngine On \n " ;
$rules .= " RewriteBase $home_root\n " ;
2005-06-12 22:09:24 -04:00
if ( $this -> use_verbose_rules ) {
$this -> matches = '' ;
$rewrite = $this -> rewrite_rules ();
$num_rules = count ( $rewrite );
$rules .= " RewriteCond % { REQUEST_FILENAME} -f [OR] \n " .
" RewriteCond % { REQUEST_FILENAME} -d \n " .
" RewriteRule ^.* $ - [S= $num_rules ] \n " ;
foreach ( $rewrite as $match => $query ) {
// Apache 1.3 does not support the reluctant (non-greedy) modifier.
$match = str_replace ( '.+?' , '.+' , $match );
// If the match is unanchored and greedy, prepend rewrite conditions
// to avoid infinite redirects and eclipsing of real files.
if ( $match == '(.+)/?$' || $match == '([^/]+)/?$' ) {
//nada.
}
if ( strstr ( $query , $this -> index )) {
$rules .= 'RewriteRule ^' . $match . ' ' . $home_root . $query . " [QSA,L] \n " ;
} else {
$rules .= 'RewriteRule ^' . $match . ' ' . $site_root . $query . " [QSA,L] \n " ;
}
2004-12-02 21:38:11 -05:00
}
2005-06-12 22:09:24 -04:00
} else {
$rules .= " RewriteCond % { REQUEST_FILENAME} !-f \n " .
" RewriteCond % { REQUEST_FILENAME} !-d \n " .
2006-01-04 22:47:38 -05:00
" RewriteRule . { $home_root } { $this -> index } [L] \n " ;
2004-12-02 21:38:11 -05:00
}
2005-06-12 22:09:24 -04:00
2004-12-02 21:38:11 -05:00
$rules .= " </IfModule> \n " ;
2005-01-21 00:10:13 -05:00
$rules = apply_filters ( 'mod_rewrite_rules' , $rules );
$rules = apply_filters ( 'rewrite_rules' , $rules ); // Deprecated
2004-12-02 21:38:11 -05:00
return $rules ;
}
2005-12-28 02:05:05 -05:00
function flush_rules () {
generate_page_rewrite_rules ();
delete_option ( 'rewrite_rules' );
$this -> wp_rewrite_rules ();
if ( function_exists ( 'save_mod_rewrite_rules' ) )
save_mod_rewrite_rules ();
}
2004-12-02 21:38:11 -05:00
function init () {
$this -> permalink_structure = get_settings ( 'permalink_structure' );
$this -> front = substr ( $this -> permalink_structure , 0 , strpos ( $this -> permalink_structure , '%' ));
2004-12-03 19:12:08 -05:00
$this -> root = '' ;
2004-12-02 21:38:11 -05:00
if ( $this -> using_index_permalinks ()) {
2004-12-03 19:12:08 -05:00
$this -> root = $this -> index . '/' ;
2004-12-02 21:38:11 -05:00
}
$this -> category_base = get_settings ( 'category_base' );
unset ( $this -> category_structure );
2004-12-08 21:40:35 -05:00
unset ( $this -> author_structure );
2005-01-26 17:46:40 -05:00
unset ( $this -> date_structure );
unset ( $this -> page_structure );
unset ( $this -> search_structure );
unset ( $this -> feed_structure );
unset ( $this -> comment_feed_structure );
2004-12-02 21:38:11 -05:00
}
function set_permalink_structure ( $permalink_structure ) {
if ( $permalink_structure != $this -> permalink_structure ) {
update_option ( 'permalink_structure' , $permalink_structure );
$this -> init ();
}
}
function set_category_base ( $category_base ) {
if ( $category_base != $this -> category_base ) {
update_option ( 'category_base' , $category_base );
$this -> init ();
}
}
function WP_Rewrite () {
$this -> init ();
}
}
2005-06-10 19:15:13 -04:00
class WP {
2006-01-23 18:39:56 -05:00
var $public_query_vars = array ( 'm' , 'p' , 'posts' , 'w' , 'cat' , 'withcomments' , 's' , 'search' , 'exact' , 'sentence' , 'debug' , 'calendar' , 'page' , 'paged' , 'more' , 'tb' , 'pb' , 'author' , 'order' , 'orderby' , 'year' , 'monthnum' , 'day' , 'hour' , 'minute' , 'second' , 'name' , 'category_name' , 'feed' , 'author_name' , 'static' , 'pagename' , 'page_id' , 'error' , 'comments_popup' , 'attachment' , 'attachment_id' , 'subpost' , 'subpost_id' , 'preview' );
2005-06-10 19:15:13 -04:00
2005-12-13 14:19:56 -05:00
var $private_query_vars = array ( 'posts_per_page' , 'posts_per_archive_page' , 'what_to_show' , 'showposts' , 'nopaging' , 'show_post_type' );
2005-06-10 19:15:13 -04:00
var $query_vars ;
var $query_string ;
2005-11-22 16:07:48 -05:00
var $request ;
var $matched_rule ;
var $matched_query ;
2005-06-10 19:15:13 -04:00
var $did_permalink = false ;
function parse_request ( $extra_query_vars = '' ) {
global $wp_rewrite ;
$this -> query_vars = array ();
if ( ! empty ( $extra_query_vars ))
parse_str ( $extra_query_vars , $extra_query_vars );
2005-08-30 15:01:45 -04:00
else
$extra_query_vars = array ();
2005-06-10 19:15:13 -04:00
2005-06-12 22:09:24 -04:00
// Process PATH_INFO, REQUEST_URI, and 404 for permalinks.
2005-06-10 19:15:13 -04:00
2005-11-16 17:54:52 -05:00
// Fetch the rewrite rules.
$rewrite = $wp_rewrite -> wp_rewrite_rules ();
2005-06-10 19:15:13 -04:00
2005-11-16 17:54:52 -05:00
if ( ! empty ( $rewrite )) {
2005-06-10 19:15:13 -04:00
// If we match a rewrite rule, this will be cleared.
$error = '404' ;
2005-11-16 17:54:52 -05:00
$this -> did_permalink = true ;
2005-06-10 19:15:13 -04:00
2005-11-16 17:54:52 -05:00
$pathinfo = $_SERVER [ 'PATH_INFO' ];
$pathinfo_array = explode ( '?' , $pathinfo );
2006-09-24 22:50:11 -04:00
$pathinfo = str_replace ( " % " , " %25 " , $pathinfo_array [ 0 ]);
2005-11-16 17:54:52 -05:00
$req_uri = $_SERVER [ 'REQUEST_URI' ];
$req_uri_array = explode ( '?' , $req_uri );
$req_uri = $req_uri_array [ 0 ];
$self = $_SERVER [ 'PHP_SELF' ];
$home_path = parse_url ( get_settings ( 'home' ));
$home_path = $home_path [ 'path' ];
2005-12-27 20:48:29 -05:00
$home_path = trim ( $home_path , '/' );
2005-11-16 17:54:52 -05:00
// Trim path info from the end and the leading home path from the
// front. For path info requests, this leaves us with the requesting
// filename, if any. For 404 requests, this leaves us with the
// requested permalink.
$req_uri = str_replace ( $pathinfo , '' , $req_uri );
$req_uri = trim ( $req_uri , '/' );
2005-12-27 20:48:29 -05:00
$req_uri = preg_replace ( " |^ $home_path | " , '' , $req_uri );
$req_uri = trim ( $req_uri , '/' );
$pathinfo = trim ( $pathinfo , '/' );
$pathinfo = preg_replace ( " |^ $home_path | " , '' , $pathinfo );
2005-11-16 17:54:52 -05:00
$pathinfo = trim ( $pathinfo , '/' );
2005-12-27 20:48:29 -05:00
$self = trim ( $self , '/' );
$self = preg_replace ( " |^ $home_path | " , '' , $self );
2005-11-16 17:54:52 -05:00
$self = str_replace ( $home_path , '' , $self );
$self = trim ( $self , '/' );
// The requested permalink is in $pathinfo for path info requests and
// $req_uri for other requests.
2006-01-02 19:59:31 -05:00
if ( ! empty ( $pathinfo ) && ! preg_match ( '|^.*' . $wp_rewrite -> index . '$|' , $pathinfo ) ) {
2005-11-16 17:54:52 -05:00
$request = $pathinfo ;
} else {
2005-11-30 20:34:29 -05:00
// If the request uri is the index, blank it out so that we don't try to match it against a rule.
if ( $req_uri == $wp_rewrite -> index )
$req_uri = '' ;
2005-11-16 17:54:52 -05:00
$request = $req_uri ;
}
2005-11-30 20:34:29 -05:00
2005-11-22 16:07:48 -05:00
$this -> request = $request ;
2005-06-10 19:15:13 -04:00
2005-11-16 17:54:52 -05:00
// Look for matches.
$request_match = $request ;
foreach ( $rewrite as $match => $query ) {
// If the requesting file is the anchor of the match, prepend it
// to the path info.
if (( ! empty ( $req_uri )) && ( strpos ( $match , $req_uri ) === 0 ) && ( $req_uri != $request )) {
$request_match = $req_uri . '/' . $request ;
}
2005-06-10 19:15:13 -04:00
2005-11-28 20:43:32 -05:00
if ( preg_match ( " !^ $match ! " , $request_match , $matches ) ||
preg_match ( " !^ $match ! " , urldecode ( $request_match ), $matches )) {
2005-11-16 17:54:52 -05:00
// Got a match.
2005-11-22 16:07:48 -05:00
$this -> matched_rule = $match ;
2005-11-16 17:54:52 -05:00
// Trim the query of everything up to the '?'.
$query = preg_replace ( " !^.+ \ ?! " , '' , $query );
2005-06-10 19:15:13 -04:00
2005-11-16 17:54:52 -05:00
// Substitute the substring matches into the query.
eval ( " \$ query = \" $query\ " ; " );
2005-11-22 16:07:48 -05:00
$this -> matched_query = $query ;
2005-06-10 19:15:13 -04:00
2005-11-16 17:54:52 -05:00
// Parse the query.
parse_str ( $query , $query_vars );
2005-11-16 05:16:20 -05:00
2005-11-16 17:54:52 -05:00
// If we're processing a 404 request, clear the error var
// since we found something.
2005-11-28 18:30:42 -05:00
if ( isset ( $_GET [ 'error' ]))
2005-11-16 05:16:20 -05:00
unset ( $_GET [ 'error' ]);
2005-11-28 18:30:42 -05:00
if ( isset ( $error ))
2005-11-16 05:16:20 -05:00
unset ( $error );
2005-11-16 17:54:52 -05:00
break ;
}
}
// If req_uri is empty or if it is a request for ourself, unset error.
2005-11-28 18:30:42 -05:00
if ( empty ( $request ) || $req_uri == $self || strstr ( $_SERVER [ 'PHP_SELF' ], 'wp-admin/' ) ) {
if ( isset ( $_GET [ 'error' ]))
2005-11-16 17:54:52 -05:00
unset ( $_GET [ 'error' ]);
2005-11-28 18:30:42 -05:00
if ( isset ( $error ))
2005-11-16 17:54:52 -05:00
unset ( $error );
2005-11-28 18:30:42 -05:00
2005-11-29 01:44:44 -05:00
if ( isset ( $query_vars ) && strstr ( $_SERVER [ 'PHP_SELF' ], 'wp-admin/' ) )
2005-11-28 18:30:42 -05:00
unset ( $query_vars );
$this -> did_permalink = false ;
2005-06-10 19:15:13 -04:00
}
}
$this -> public_query_vars = apply_filters ( 'query_vars' , $this -> public_query_vars );
for ( $i = 0 ; $i < count ( $this -> public_query_vars ); $i += 1 ) {
$wpvar = $this -> public_query_vars [ $i ];
if ( isset ( $extra_query_vars [ $wpvar ]))
$this -> query_vars [ $wpvar ] = $extra_query_vars [ $wpvar ];
elseif ( isset ( $GLOBALS [ $wpvar ]))
$this -> query_vars [ $wpvar ] = $GLOBALS [ $wpvar ];
elseif ( ! empty ( $_POST [ $wpvar ]))
$this -> query_vars [ $wpvar ] = $_POST [ $wpvar ];
elseif ( ! empty ( $_GET [ $wpvar ]))
$this -> query_vars [ $wpvar ] = $_GET [ $wpvar ];
elseif ( ! empty ( $query_vars [ $wpvar ]))
$this -> query_vars [ $wpvar ] = $query_vars [ $wpvar ];
else
$this -> query_vars [ $wpvar ] = '' ;
}
2005-11-16 05:16:20 -05:00
if ( isset ( $error ) )
$this -> query_vars [ 'error' ] = $error ;
2005-06-10 19:15:13 -04:00
}
function send_headers () {
@ header ( 'X-Pingback: ' . get_bloginfo ( 'pingback_url' ));
2005-12-15 11:31:41 -05:00
if ( is_user_logged_in () )
2005-11-10 20:44:41 -05:00
nocache_headers ();
2005-06-10 19:15:13 -04:00
if ( ! empty ( $this -> query_vars [ 'error' ]) && '404' == $this -> query_vars [ 'error' ] ) {
status_header ( 404 );
2006-06-24 02:00:13 -04:00
@ header ( 'Content-type: ' . get_option ( 'html_type' ) . '; charset=' . get_option ( 'blog_charset' ));
2005-06-10 19:15:13 -04:00
} else if ( empty ( $this -> query_vars [ 'feed' ]) ) {
@ header ( 'Content-type: ' . get_option ( 'html_type' ) . '; charset=' . get_option ( 'blog_charset' ));
} else {
// We're showing a feed, so WP is indeed the only thing that last changed
if ( $this -> query_vars [ 'withcomments' ] )
$wp_last_modified = mysql2date ( 'D, d M Y H:i:s' , get_lastcommentmodified ( 'GMT' ), 0 ) . ' GMT' ;
else
$wp_last_modified = mysql2date ( 'D, d M Y H:i:s' , get_lastpostmodified ( 'GMT' ), 0 ) . ' GMT' ;
$wp_etag = '"' . md5 ( $wp_last_modified ) . '"' ;
@ header ( " Last-Modified: $wp_last_modified " );
@ header ( " ETag: $wp_etag " );
// Support for Conditional GET
if ( isset ( $_SERVER [ 'HTTP_IF_NONE_MATCH' ])) $client_etag = stripslashes ( $_SERVER [ 'HTTP_IF_NONE_MATCH' ]);
else $client_etag = false ;
$client_last_modified = trim ( $_SERVER [ 'HTTP_IF_MODIFIED_SINCE' ]);
// If string is empty, return 0. If not, attempt to parse into a timestamp
$client_modified_timestamp = $client_last_modified ? strtotime ( $client_last_modified ) : 0 ;
// Make a timestamp for our most recent modification...
$wp_modified_timestamp = strtotime ( $wp_last_modified );
if ( ( $client_last_modified && $client_etag ) ?
(( $client_modified_timestamp >= $wp_modified_timestamp ) && ( $client_etag == $wp_etag )) :
(( $client_modified_timestamp >= $wp_modified_timestamp ) || ( $client_etag == $wp_etag )) ) {
status_header ( 304 );
exit ;
}
}
}
function build_query_string () {
$this -> query_string = '' ;
foreach ( $this -> public_query_vars as $wpvar ) {
if ( isset ( $this -> query_vars [ $wpvar ]) && '' != $this -> query_vars [ $wpvar ]) {
$this -> query_string .= ( strlen ( $this -> query_string ) < 1 ) ? '' : '&' ;
$this -> query_string .= $wpvar . '=' . rawurlencode ( $this -> query_vars [ $wpvar ]);
}
}
foreach ( $this -> private_query_vars as $wpvar ) {
if ( isset ( $GLOBALS [ $wpvar ]) && '' != $GLOBALS [ $wpvar ]) {
$this -> query_string .= ( strlen ( $this -> query_string ) < 1 ) ? '' : '&' ;
$this -> query_string .= $wpvar . '=' . rawurlencode ( $GLOBALS [ $wpvar ]);
}
}
$this -> query_string = apply_filters ( 'query_string' , $this -> query_string );
}
function register_globals () {
global $wp_query ;
// Extract updated query vars back into global namespace.
foreach ( $wp_query -> query_vars as $key => $value ) {
$GLOBALS [ $key ] = $value ;
}
$GLOBALS [ 'query_string' ] = & $this -> query_string ;
$GLOBALS [ 'posts' ] = & $wp_query -> posts ;
$GLOBALS [ 'post' ] = & $wp_query -> post ;
2006-01-11 06:06:26 -05:00
$GLOBALS [ 'request' ] = & $wp_query -> request ;
2005-06-10 19:15:13 -04:00
if ( is_single () || is_page () ) {
$GLOBALS [ 'more' ] = 1 ;
$GLOBALS [ 'single' ] = 1 ;
}
}
2005-12-18 17:08:01 -05:00
function init () {
2006-05-11 19:05:45 -04:00
wp_get_current_user ();
2005-06-10 19:15:13 -04:00
}
function query_posts () {
$this -> build_query_string ();
query_posts ( $this -> query_string );
}
function handle_404 () {
global $wp_query ;
// Issue a 404 if a permalink request doesn't match any posts. Don't
// issue a 404 if one was already issued, if the request was a search,
// or if the request was a regular query string request rather than a
// permalink request.
2006-01-24 22:59:41 -05:00
if ( ( 0 == count ( $wp_query -> posts )) && ! is_404 () && ! is_search () && ( $this -> did_permalink || ( ! empty ( $_SERVER [ 'QUERY_STRING' ]) && ( false === strpos ( $_SERVER [ 'REQUEST_URI' ], '?' ))) ) ) {
2005-09-15 23:16:12 -04:00
$wp_query -> set_404 ();
2005-06-10 19:15:13 -04:00
status_header ( 404 );
2005-11-16 05:16:20 -05:00
} elseif ( is_404 () != true ) {
2005-06-10 19:15:13 -04:00
status_header ( 200 );
}
}
function main ( $query_args = '' ) {
2005-12-18 17:08:01 -05:00
$this -> init ();
2005-06-10 19:15:13 -04:00
$this -> parse_request ( $query_args );
2005-11-10 20:44:41 -05:00
$this -> send_headers ();
2005-06-10 19:15:13 -04:00
$this -> query_posts ();
$this -> handle_404 ();
$this -> register_globals ();
}
function WP () {
// Empty.
}
2004-12-02 21:38:11 -05:00
}
2005-08-30 15:01:45 -04:00
?>