Semi-automatic tagging - solution

Sometime in September, someone torwald put the idea of semi-automatic generation of keywords , but no solution was proposed.

After listening to suggestions on the ngcms and 2z-project forums, a solution appeared:


')


class.php (class that defines keywords)

1. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
2. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
3. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
4. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
5. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
6. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
7. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
8. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
9. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
10. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
11. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
12. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
13. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
14. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
15. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
16. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
17. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
18. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
19. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
20. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
21. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
22. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
23. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
24. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
25. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
26. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
27. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
28. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
29. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
30. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
31. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
32. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
33. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
34. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
35. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
36. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
37. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
38. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
39. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
40. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
41. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
42. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
43. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
44. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
45. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
46. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
47. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
48. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
49. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
50. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
51. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
52. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
53. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
54. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
55. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
56. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
57. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
58. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
59. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
60. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
61. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
62. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
63. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
64. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
65. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
66. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
67. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
68. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
69. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
70. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
71. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
72. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
73. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
74. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
75. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
76. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
77. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
78. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
79. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
80. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
81. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
82. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
83. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
84. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
85. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
86. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>
87. <?
class autokeyword {
var $contents ;
var $encoding ;
var $keywords ;
var $wordLengthMin ;
var $wordOccuredMin ;
var $wordLengthMax ;
var $wordGoodArray ;
var $wordBlockArray ;
var $wordMaxCount ;
var $wordB ;
var $wordAddTitle ;
var $wordTitle ;
function autokeyword ( $params , $encoding )
{
$this -> wordGoodArray = array ( ) ;
$this -> wordBlockArray = array ( ) ;
$this -> encoding = $encoding ;
$this -> wordLengthMin = $params [ 'min_word_length' ] ;
$this -> wordLengthMax = $params [ 'max_word_length' ] ;
$this -> wordMaxCount = $params [ 'word_count' ] ;
if ( $params [ 'good_b' ] ) { $this -> wordB = 1 ; }
if ( $params [ 'add_title' ] > 0 )
{
$this -> wordAddTitle = $params [ 'add_title' ] ; $this -> wordTitle = $params [ 'title' ] ;
for ( $i = 0 ; $i < $this -> wordAddTitle ; $i ++ ) { $content .= $this -> wordTitle . ' ' ; }
$params [ 'content' ] = $content . ' ' . $params [ 'content' ] ;
}
if ( $params [ 'good_array' ] && $params [ 'good_word' ] == true ) { $this -> wordGoodArray = explode ( " \r \n " , $params [ 'good_array' ] ) ; }
if ( $params [ 'block_array' ] && $params [ 'block_word' ] == true ) { $this -> wordBlockArray = explode ( " \r \n " , $params [ 'block_array' ] ) ; }
$this -> contents = $this -> replace_chars ( $params [ 'content' ] ) ;
}
function replace_chars ( $content )
{
$content = strtolower ( $content ) ;
$content = strip_tags ( $content ) ;
if ( $this -> wordB == 1 ) { $content = preg_replace ( '![b](.*)[/b]!si' , '$1 $1' , $content ) ; }
$punctuations = array ( ',' , ')' , '(' , '.' , "'" , '"' , '<' , '>' , ';' , '!' , '?' , '/' , '-' ,
'_' , '[' , ']' , ':' , '+' , '=' , '#' , '$' , '"' , '©' , '>' , '<' , chr ( 10 ) , chr ( 13 ) , chr ( 9 ) ) ;
$punctuations = array_merge ( $this -> wordBlockArray , $punctuations ) ;
$content = str_replace ( $punctuations , " " , $content ) ;
$content = preg_replace ( '/ {2,}/si' , " " , $content ) ;
return $content ;
}
function parse_words ( )
{
$common = array ( "aaaaaaa" , "aaaaaaa" ) ;
$s = split ( " " , $this -> contents ) ;
$k = array ( ) ;
foreach ( $s as $key => $val ) {
if ( strlen ( trim ( $val ) ) >= $this -> wordLengthMin && strlen ( trim ( $val ) ) <= $this -> wordLengthMax && ! in_array ( trim ( $val ) , $common ) && ! is_numeric ( trim ( $val ) ) )
{
$k [ ] = trim ( $val ) ;
}
}
$k = array_count_values ( $k ) ;
$occur_filtered = $this -> occure_filter ( $k , $this -> wordOccuredMin ) ;
arsort ( $occur_filtered ) ;
$occur_filtered = array_flip ( $this -> wordGoodArray ) + $occur_filtered ;
array_splice ( $occur_filtered , $this -> wordMaxCount ) ;
$imploded = $this -> implode ( ", " , $occur_filtered ) ;
unset ( $k ) ;
unset ( $s ) ;
return $imploded ;
}
function occure_filter ( $array_count_values , $min_occur )
{
$occur_filtered = array ( ) ;
foreach ( $array_count_values as $word => $occured ) {
if ( $occured >= $min_occur ) {
$occur_filtered [ $word ] = $occured ;
}
}
return $occur_filtered ;
}

function implode ( $gule , $array )
{
$c = "" ;
foreach ( $array as $key => $val ) {
@ $c .= $key . $gule ;
}
return $c ;
}
}
?>

ajax.php (which will return the cloud)

1. <?
   
2. if ( $ _POST [ 'q' ] )
   
3. {
   
4. header ( 'Content-type: text / html; charset = windows-1251' ) ;
   
5. include_once ( "class.php" ) ;
   
6. if ( $ _POST [ 'q' ] == '' || $ _POST [ 'q' ] == 'undefined' ) die ( '{"res": "error", "msg": "No data!"} ' ) ;
   
7. $ params [ 'content' ] = iconv ( 'UTF-8' , 'windows-1251' , $ _POST [ 'q' ] ) ;
   
8. $ params [ 'min_word_length' ] = 5 ; // minimum word length
   
9. $ params [ 'max_word_length' ] = 100 ; // maximum word length
   
10. $ params [ 'min_word_occur' ] = 2 ; // minimum number of posts
    
11. $ params [ 'word_sum' ] = 245 ; // maximum length of all words (taking into account the space character)
    
12. $ params [ 'block_word' ] = false ; // block stop words (which you do not want to add)
    
13. $ params [ 'block_array' ] = 'hello' ; // list of stop words (new line separator)
    
14. $ params [ 'good_word' ] = false ; // add favorite words (which you really want to add)
    
15. $ params [ 'good_array' ] = 'habrabra' ; // list of favorite words (new line separator)
    
16. $ params [ 'add_title' ] = 0 ; // add title (the number of times you want to add a title)
    
17. $ params [ 'word_count' ] = 245 ; // maximum number of words
    
18. $ params [ 'good_b' ] = false ; // read the words in the <b> tag as double
    
19. $ keyword = new autokeyword ( $ params , "windows-1251" ) ;
    
20. $ SQL [ 'keywords' ] = substr ( $ keyword -> parse_words ( ) , 0 , $ params [ 'word_sum' ] ) ;
    
21. $ SQL [ 'keywords' ] = substr ( $ SQL [ 'keywords' ] , 0 , strrpos ( $ SQL [ 'keywords' ] , ',' ) ) ;
    
22. echo '{"res": "ok", "x1": "<span>' . $ SQL [ 'keywords' ] . '</ span>"}' ;
    
23. }
    
24. ?>

js.js (sends a request from your page)

1. function SendPOST ( )
   
2. {
   
3. var data = document. form . content . value ;
   
4. var title = document. form . title . value ;
   
5. ajaxSendPOST ( 'ajax.php' , 'q =' + encodeURI ( title ) + '' + encodeURI ( data ) , SendCallback ) ;
   
6. }
   
7. function SendCallback ( answer ) {
   
8. var ans = eval ( '(' + answer + ')' ) ;
   
9. if ( ans. res == 'error' ) { alert ( 'Empty?' ) ; return ; }
   
10. if ( ans. res ! = 'ok' ) { alert ( 'I don’t know what to say' ) ; return ; }
    
11. keys_out = ans. x1 ;
    
12. keys_out = keys_out. replace ( /, / g , '</ span> <span>' ) ;
    
13. document. getElementById ( 'autokey_out' ) . innerHTML = keys_out ;
    
14. key_span = document. getElementById ( 'autokey_out' ) ;
    
15. key_click = key_span. getElementsByTagName ( 'span' ) ;
    
16. for ( i in key_click )
    
17. {
    
18. key_click [ i ] . onclick = function ( ) {
    
19. if ( document. form . keywords . value == '' )
    
20. {
    
21. document. form . keywords . value = this . innerHTML ;
    
22. this . parentNode . removeChild ( this ) ;
    
23. }
    
24. else
    
25. {
    
26. document. form . keywords . value + = ',' + this . innerHTML ;
    
27. this . parentNode . removeChild ( this )
    
28. }
    
29. }
    
30. }
    
31. }
    
32. function ajaxSendPOST ( xmlpage , data , callback )
    
33. {
    
34. var xmlh = null ;
    
35. if ( window. XMLHttpRequest )
    
36. xmlh = new XMLHttpRequest ( ) ;
    
37. else
    
38. try
    
39. { xmlh = new ActiveXObject ( 'Msxml2.XMLHTTP' ) ; }
    
40. catch ( ex )
    
41. { xmlh = new ActiveXObject ( 'Microsoft.XMLHTTP' ) ; }
    
42. if ( xmlh )
    
43. {
    
44. xmlh. open ( 'post' , xmlpage , true ) ;
    
45. xmlh. onreadystatechange = function ( x ) { if ( xmlh. readyState == 4 ) callback ( xmlh. responseText ) ; }
    
46. xmlh. setRequestHeader ( "Accept-Charset" , "windows-1251" ) ;
    
47. xmlh. setRequestHeader ( "Accept-Language" , "ru, en" ) ;
    
48. xmlh. setRequestHeader ( "Connection" , "close" ) ;
    
49. xmlh. setRequestHeader ( "Content-length" , data. length ) ;
    
50. xmlh. setRequestHeader ( "Content-type" , "application / x-www-form-urlencoded" ) ;
    
51. xmlh. send ( data ) ;
    
52. }
    
53. }

index.php

1. < script type = "text / javascript" src = "js.js" > < / script >
   
2. < style type = "text / css" >
   
3. #autokey_out span {cursor: pointer; text-decoration: underline}
   
4. < / style >
   
5. < form id = "postForm" name = "form" method = "post" action = "#" target = "_self" >
   
6. < textarea name = "content" rows = "16" cols = "60" tabindex = "2" > < / textarea >
   
7. <Br />
   
8. < input type = "text" name = "keywords" size = "60" value = "" >
   
9. < input type = "submit" value = "Get Keywords" name = "autokey_keys" onclick = "javascript: SendPOST (); return false;" >
   
10. <Br />
    
11. < div id = "autokey_out" > < / div >
    
12. < / form >

Sorsy

This is the first article. Do not scold much.
______________________