BIWEB开源PHP WMS系统创始人ArthurXF肖飞的blog

<?php
//
// +---------------------------------------------------------------------------+
// | memcached client, PHP                                                     |
// +---------------------------------------------------------------------------+
// | Copyright (c) 2003 Ryan T. Dean <rtdean@cytherianage.net>                 |
// | All rights reserved.                                                      |
// |                                                                           |
// | Redistribution and use in source and binary forms, with or without        |
// | modification, are permitted provided that the following conditions        |
// | are met:                                                                  |
// |                                                                           |
// | 1. Redistributions of source code must retain the above copyright         |
// |    notice, this list of conditions and the following disclaimer.          |
// | 2. Redistributions in binary form must reproduce the above copyright      |
// |    notice, this list of conditions and the following disclaimer in the    |
// |    documentation and/or other materials provided with the distribution.   |
// |                                                                           |
// | THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR      |
// | IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
// | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.   |
// | IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,          |
// | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT  |
// | NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
// | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY     |
// | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT       |
// | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF  |
// | THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.         |
// +---------------------------------------------------------------------------+
// | Author: Ryan T. Dean <rtdean@cytherianage.net>                            |
// | Heavily influenced by the Perl memcached client by Brad Fitzpatrick.      |
// |   Permission granted by Brad Fitzpatrick for relicense of ported Perl     |
// |   client logic under 2-clause BSD license.                                |
// +---------------------------------------------------------------------------+
//
// $TCAnet$
//

/**
* This is the PHP client for memcached - a distributed memory cache daemon.
* More information is available at http://www.danga.com/memcached/
*
* Usage example:
*
* require_once 'memcached.php';
*  
* $mc = new memcached(array(
*              'servers' => array('127.0.0.1:10000',  
*                                 array('192.0.0.1:10010', 2),
*                                 '127.0.0.1:10020'),
*              'debug'   => false,
*              'compress_threshold' => 10240,
*              'persistant' => true));
*
* $mc->add('key', array('some', 'array'));
* $mc->replace('key', 'some random string');
* $val = $mc->get('key');
*
* @author  Ryan T. Dean <rtdean@cytherianage.net>
* @package memcached-client
* @version 0.1.2
*/

// {{{ requirements
// }}}

// {{{ constants
// {{{ flags

/**
* Flag: indicates data is serialized
*/
define("MEMCACHE_SERIALIZED", 1<<0);

/**
* Flag: indicates data is compressed
*/
define("MEMCACHE_COMPRESSED", 1<<1);

// }}}

/**
* Minimum savings to store data compressed
*/
define("COMPRESSION_SAVINGS", 0.20);

// }}}

// {{{ class memcached
/**
* memcached client class implemented using (p)fsockopen()
*
* @author  Ryan T. Dean <rtdean@cytherianage.net>
* @package memcached-client
*/
class memcached
{
  // {{{ properties
  // {{{ public

  /**
   * Command statistics
   *
   * @var     array
   * @access  public
   */
  var $stats;
   
  // }}}
  // {{{ private

  /**
   * Cached Sockets that are connected
   *
   * @var     array
   * @access  private
   */
  var $_cache_sock;
   
  /**
   * Current debug status; 0 - none to 9 - profiling
   *
   * @var     boolean
   * @access  private
   */
  var $_debug;
   
  /**
   * Dead hosts, assoc array, 'host'=>'unixtime when ok to check again'
   *
   * @var     array
   * @access  private
   */
  var $_host_dead;
   
  /**
   * Is compression available?
   *
   * @var     boolean
   * @access  private
   */
  var $_have_zlib;
   
  /**
   * Do we want to use compression?
   *
   * @var     boolean
   * @access  private
   */
  var $_compress_enable;
   
  /**
   * At how many bytes should we compress?
   *
   * @var     interger
   * @access  private
   */
  var $_compress_threshold;
   
  /**
   * Are we using persistant links?
   *
   * @var     boolean
   * @access  private
   */
  var $_persistant;
   
  /**
   * If only using one server; contains ip:port to connect to
   *
   * @var     string
   * @access  private
   */
  var $_single_sock;
   
  /**
   * Array containing ip:port or array(ip:port, weight)
   *
   * @var     array
   * @access  private
   */
  var $_servers;
   
  /**
   * Our bit buckets
   *
   * @var     array
   * @access  private
   */
  var $_buckets;
   
  /**
   * Total # of bit buckets we have
   *
   * @var     interger
   * @access  private
   */
  var $_bucketcount;
   
  /**
   * # of total servers we have
   *
   * @var     interger
   * @access  private
   */
  var $_active;

  // }}}
  // }}}
  // {{{ methods
  // {{{ public functions
  // {{{ memcached()

  /**
   * Memcache initializer
   *
   * @param   array    $args    Associative array of settings
   *
   * @return  mixed
   * @access  public
   */
  function memcached ($args)
  {
     $this->set_servers($args['servers']);
     $this->_debug = $args['debug'];
     $this->stats = array();
     $this->_compress_threshold = $args['compress_threshold'];
     $this->_persistant = isset($args['persistant']) ? $args['persistant'] : false;
     $this->_compress_enable = true;
     $this->_have_zlib = function_exists("gzcompress");
     
     $this->_cache_sock = array();
     $this->_host_dead = array();
  }

  // }}}
  // {{{ add()

  /**
   * Adds a key/value to the memcache server if one isn't already set with  
   * that key
   *
   * @param   string   $key     Key to set with data
   * @param   mixed    $val     Value to store
   * @param   interger $exp     (optional) Time to expire data at
   *
   * @return  boolean
   * @access  public
   */
  function add ($key, $val, $exp = 0)
  {
     return $this->_set('add', $key, $val, $exp);
  }

  // }}}
  // {{{ decr()

  /**
   * Decriment a value stored on the memcache server
   *
   * @param   string   $key     Key to decriment
   * @param   interger $amt     (optional) Amount to decriment
   *
   * @return  mixed    FALSE on failure, value on success
   * @access  public
   */
  function decr ($key, $amt=1)
  {
     return $this->_incrdecr('decr', $key, $amt);
  }

  // }}}
  // {{{ delete()

  /**
   * Deletes a key from the server, optionally after $time
   *
   * @param   string   $key     Key to delete
   * @param   interger $time    (optional) How long to wait before deleting
   *
   * @return  boolean  TRUE on success, FALSE on failure
   * @access  public
   */
  function delete ($key, $time = 0)
  {
     if (!$this->_active)
        return false;
         
     $sock = $this->get_sock($key);
     if (!is_resource($sock))
        return false;
     
     $key = is_array($key) ? $key[1] : $key;
     
     $this->stats['delete']++;
     $cmd = "delete $key $time\r\n";
     if(!fwrite($sock, $cmd, strlen($cmd)))
     {
        $this->_dead_sock($sock);
        return false;
     }
     $res = trim(fgets($sock));
     
     if ($this->_debug)
        printf("MemCache: delete %s (%s)\n", $key, $res);
     
     if ($res == "DELETED")
        return true;
     return false;
  }

  // }}}
  // {{{ disconnect_all()

  /**
   * Disconnects all connected sockets
   *
   * @access  public
   */
  function disconnect_all ()
  {
     foreach ($this->_cache_sock as $sock)
        fclose($sock);

     $this->_cache_sock = array();
  }

  // }}}
  // {{{ enable_compress()

  /**
   * Enable / Disable compression
   *
   * @param   boolean  $enable  TRUE to enable, FALSE to disable
   *
   * @access  public
   */
  function enable_compress ($enable)
  {
     $this->_compress_enable = $enable;
  }

  // }}}
  // {{{ forget_dead_hosts()

  /**
   * Forget about all of the dead hosts
   *
   * @access  public
   */
  function forget_dead_hosts ()
  {
     $this->_host_dead = array();
  }

  // }}}
  // {{{ get()

  /**
   * Retrieves the value associated with the key from the memcache server
   *
   * @param  string   $key     Key to retrieve
   *
   * @return  mixed
   * @access  public
   */
  function get ($key)
  {
     if (!$this->_active)
        return false;
         
     $sock = $this->get_sock($key);
     
     if (!is_resource($sock))
        return false;
         
     $this->stats['get']++;
     
     $cmd = "get $key\r\n";
     if (!fwrite($sock, $cmd, strlen($cmd)))
     {
        $this->_dead_sock($sock);
        return false;
     }
     
     $val = array();
     $this->_load_items($sock, $val);
     
     if ($this->_debug)
        foreach ($val as $k => $v)
           printf("MemCache: sock %s got %s => %s\r\n", $sock, $k, $v);
     
     return $val[$key];
  }

  // }}}
  // {{{ get_multi()

  /**
   * Get multiple keys from the server(s)
   *
   * @param   array    $keys    Keys to retrieve
   *
   * @return  array
   * @access  public
   */
  function get_multi ($keys)
  {
     if (!$this->_active)
        return false;
         
     $this->stats['get_multi']++;
     
     foreach ($keys as $key)
     {
        $sock = $this->get_sock($key);
        if (!is_resource($sock)) continue;
        $key = is_array($key) ? $key[1] : $key;
        if (!isset($sock_keys[$sock]))
        {
           $sock_keys[$sock] = array();
           $socks[] = $sock;
        }
        $sock_keys[$sock][] = $key;
     }
     
     // Send out the requests
     foreach ($socks as $sock)
     {
        $cmd = "get";
        foreach ($sock_keys[$sock] as $key)
        {
           $cmd .= " ". $key;
        }
        $cmd .= "\r\n";
         
        if (fwrite($sock, $cmd, strlen($cmd)))
        {
           $gather[] = $sock;
        } else
        {
           $this->_dead_sock($sock);
        }
     }
     
     // Parse responses
     $val = array();
     foreach ($gather as $sock)
     {
        $this->_load_items($sock, $val);
     }
     
     if ($this->_debug)
        foreach ($val as $k => $v)
           printf("MemCache: got %s => %s\r\n", $k, $v);
           
     return $val;
  }

  // }}}
  // {{{ incr()

  /**
   * Increments $key (optionally) by $amt
   *
   * @param   string   $key     Key to increment
   * @param   interger $amt     (optional) amount to increment
   *
   * @return  interger New key value?
   * @access  public
   */
  function incr ($key, $amt=1)
  {
     return $this->_incrdecr('incr', $key, $amt);
  }

  // }}}
  // {{{ replace()

  /**
   * Overwrites an existing value for key; only works if key is already set
   *
   * @param   string   $key     Key to set value as
   * @param   mixed    $value   Value to store
   * @param   interger $exp     (optional) Experiation time
   *
   * @return  boolean
   * @access  public
   */
  function replace ($key, $value, $exp=0)
  {
     return $this->_set('replace', $key, $value, $exp);
  }

  // }}}
  // {{{ run_command()

  /**
   * Passes through $cmd to the memcache server connected by $sock; returns  
   * output as an array (null array if no output)
   *
   * NOTE: due to a possible bug in how PHP reads while using fgets(), each
   *       line may not be terminated by a \r\n.  More specifically, my testing
   *       has shown that, on FreeBSD at least, each line is terminated only
   *       with a \n.  This is with the PHP flag auto_detect_line_endings set
   *       to falase (the default).
   *
   * @param   resource $sock    Socket to send command on
   * @param   string   $cmd     Command to run
   *
   * @return  array    Output array
   * @access  public
   */
  function run_command ($sock, $cmd)
  {
     if (!is_resource($sock))
        return array();
     
     if (!fwrite($sock, $cmd, strlen($cmd)))
        return array();
         
     while (true)
     {
        $res = fgets($sock);
        $ret[] = $res;
        if (preg_match('/^END/', $res))
           break;
        if (strlen($res) == 0)
           break;
     }
     return $ret;
  }

  // }}}
  // {{{ set()

  /**
   * Unconditionally sets a key to a given value in the memcache.  Returns true
   * if set successfully.
   *
   * @param   string   $key     Key to set value as
   * @param   mixed    $value   Value to set
   * @param   interger $exp     (optional) Experiation time
   *
   * @return  boolean  TRUE on success
   * @access  public
   */
  function set ($key, $value, $exp=0)
  {
     return $this->_set('set', $key, $value, $exp);
  }

  // }}}
  // {{{ set_compress_threshold()

  /**
   * Sets the compression threshold
   *
   * @param   interger $thresh  Threshold to compress if larger than
   *
   * @access  public
   */
  function set_compress_threshold ($thresh)
  {
     $this->_compress_threshold = $thresh;
  }

  // }}}
  // {{{ set_debug()

  /**
   * Sets the debug flag
   *
   * @param   boolean  $dbg     TRUE for debugging, FALSE otherwise
   *
   * @access  public
   *
   * @see     memcahced::memcached
   */
  function set_debug ($dbg)
  {
     $this->_debug = $dbg;
  }

  // }}}
  // {{{ set_servers()

  /**
   * Sets the server list to distribute key gets and puts between
   *
   * @param   array    $list    Array of servers to connect to
   *
   * @access  public
   *
   * @see     memcached::memcached()
   */
  function set_servers ($list)
  {
     $this->_servers = $list;
     $this->_active = count($list);
     $this->_buckets = null;
     $this->_bucketcount = 0;
     
     $this->_single_sock = null;
     if ($this->_active == 1)
        $this->_single_sock = $this->_servers[0];
  }

  // }}}
  // }}}
  // {{{ private methods
  // {{{ _close_sock()

  /**
   * Close the specified socket
   *
   * @param   string   $sock    Socket to close
   *
   * @access  private
   */
  function _close_sock ($sock)
  {
     $host = array_search($sock, $this->_cache_sock);
     fclose($this->_cache_sock[$host]);
     unset($this->_cache_sock[$host]);
  }

  // }}}
  // {{{ _connect_sock()

  /**
   * Connects $sock to $host, timing out after $timeout
   *
   * @param   interger $sock    Socket to connect
   * @param   string   $host    Host:IP to connect to
   * @param   float    $timeout (optional) Timeout value, defaults to 0.25s
   *
   * @return  boolean
   * @access  private
   */
  function _connect_sock (&$sock, $host, $timeout = 0.25)
  {
     list ($ip, $port) = explode(":", $host);
     if ($this->_persistant == 1)
     {
        $sock = @pfsockopen($ip, $port, $errno, $errstr, $timeout);
     } else
     {
        $sock = @fsockopen($ip, $port, $errno, $errstr, $timeout);
     }
     
     if (!$sock)
        return false;
     return true;
  }

  // }}}
  // {{{ _dead_sock()

  /**
   * Marks a host as dead until 30-40 seconds in the future
   *
   * @param   string   $sock    Socket to mark as dead
   *
   * @access  private
   */
  function _dead_sock ($sock)
  {
     $host = array_search($sock, $this->_cache_sock);
     list ($ip, $port) = explode(":", $host);
     $this->_host_dead[$ip] = time() + 30 + intval(rand(0, 10));
     $this->_host_dead[$host] = $this->_host_dead[$ip];
     unset($this->_cache_sock[$host]);
  }

  // }}}
  // {{{ get_sock()

  /**
   * get_sock
   *
   * @param   string   $key     Key to retrieve value for;
   *
   * @return  mixed    resource on success, false on failure
   * @access  private
   */
  function get_sock ($key)
  {
     if (!$this->_active)
        return false;

     if ($this->_single_sock !== null)
        return $this->sock_to_host($this->_single_sock);
     
     $hv = is_array($key) ? intval($key[0]) : $this->_hashfunc($key);
     
     if ($this->_buckets === null)
     {
        foreach ($this->_servers as $v)
        {
           if (is_array($v))
           {
              for ($i=0; $i<$v[1]; $i++)
                 $bu[] = $v[0];
           } else
           {
              $bu[] = $v;
           }
        }
        $this->_buckets = $bu;
        $this->_bucketcount = count($bu);
     }
     
     $realkey = is_array($key) ? $key[1] : $key;
     for ($tries = 0; $tries<20; $tries++)
     {
        $host = $this->_buckets[$hv % $this->_bucketcount];
        $sock = $this->sock_to_host($host);
        if (is_resource($sock))
           return $sock;
        $hv += $this->_hashfunc($tries . $realkey);
     }
     
     return false;
  }

  // }}}
  // {{{ _hashfunc()

  /**
   * Creates a hash interger based on the $key
   *
   * @param   string   $key     Key to hash
   *
   * @return  interger Hash value
   * @access  private
   */
  function _hashfunc ($key)
  {
     $hash = 0;
     for ($i=0; $i<strlen($key); $i++)
     {
        $hash = $hash*33 + ord($key[$i]);
     }
     
     return $hash;
  }

  // }}}
  // {{{ _incrdecr()

  /**
   * Perform increment/decriment on $key
   *
   * @param   string   $cmd     Command to perform
   * @param   string   $key     Key to perform it on
   * @param   interger $amt     Amount to adjust
   *
   * @return  interger    New value of $key
   * @access  private
   */
  function _incrdecr ($cmd, $key, $amt=1)
  {
     if (!$this->_active)
        return null;
         
     $sock = $this->get_sock($key);
     if (!is_resource($sock))
        return null;
         
     $key = is_array($key) ? $key[1] : $key;
     $this->stats[$cmd]++;
     if (!fwrite($sock, "$cmd $key $amt\r\n"))
        return $this->_dead_sock($sock);
         
     stream_set_timeout($sock, 1, 0);
     $line = fgets($sock);
     if (!preg_match('/^(\d+)/', $line, $match))
        return null;
     return $match[1];
  }

  // }}}
  // {{{ _load_items()

  /**
   * Load items into $ret from $sock
   *
   * @param   resource $sock    Socket to read from
   * @param   array    $ret     Returned values
   *
   * @access  private
   */
  function _load_items ($sock, &$ret)
  {
     while (1)
     {
        $decl = fgets($sock);
        if ($decl == "END\r\n")
        {
           return true;
        } elseif (preg_match('/^VALUE (\S+) (\d+) (\d+)\r\n$/', $decl, $match))
        {
           list($rkey, $flags, $len) = array($match[1], $match[2], $match[3]);
           $bneed = $len+2;
           $offset = 0;
           
           while ($bneed > 0)
           {
              $data = fread($sock, $bneed);
              $n = strlen($data);
              if ($n == 0)
                 break;
              $offset += $n;
              $bneed -= $n;
              $ret[$rkey] .= $data;
           }
           
           if ($offset != $len+2)
           {
              // Something is borked!
              if ($this->_debug)
                 printf("Something is borked!  key %s expecting %d got %d length\n", $rkey, $len+2, $offset);

              unset($ret[$rkey]);
              $this->_close_sock($sock);
              return false;
           }
           
           $ret[$rkey] = rtrim($ret[$rkey]);

           if ($this->_have_zlib && $flags & MEMCACHE_COMPRESSED)
              $ret[$rkey] = gzuncompress($ret[$rkey]);

           if ($flags & MEMCACHE_SERIALIZED)
              $ret[$rkey] = unserialize($ret[$rkey]);

        } else  
        {
           if ($this->_debug)
              print("Error parsing memcached response\n");
           return 0;
        }
     }
  }

  // }}}
  // {{{ _set()

  /**
   * Performs the requested storage operation to the memcache server
   *
   * @param   string   $cmd     Command to perform
   * @param   string   $key     Key to act on
   * @param   mixed    $val     What we need to store
   * @param   interger $exp     When it should expire
   *
   * @return  boolean
   * @access  private
   */
  function _set ($cmd, $key, $val, $exp)
  {
     if (!$this->_active)
        return false;
         
     $sock = $this->get_sock($key);
     if (!is_resource($sock))
        return false;
         
     $this->stats[$cmd]++;
     
     $flags = 0;
     
     if (!is_scalar($val))
     {
        $val = serialize($val);
        $flags |= MEMCACHE_SERIALIZED;
        if ($this->_debug)
           printf("client: serializing data as it is not scalar\n");
     }
     
     $len = strlen($val);
     
     if ($this->_have_zlib && $this->_compress_enable &&  
         $this->_compress_threshold && $len >= $this->_compress_threshold)
     {
        $c_val = gzcompress($val, 9);
        $c_len = strlen($c_val);
         
        if ($c_len < $len*(1 - COMPRESS_SAVINGS))
        {
           if ($this->_debug)
              printf("client: compressing data; was %d bytes is now %d bytes\n", $len, $c_len);
           $val = $c_val;
           $len = $c_len;
           $flags |= MEMCACHE_COMPRESSED;
        }
     }
     if (!fwrite($sock, "$cmd $key $flags $exp $len\r\n$val\r\n"))
        return $this->_dead_sock($sock);
         
     $line = trim(fgets($sock));
     
     if ($this->_debug)
     {
        if ($flags & MEMCACHE_COMPRESSED)
           $val = 'compressed data';
        printf("MemCache: %s %s => %s (%s)\n", $cmd, $key, $val, $line);
     }
     if ($line == "STORED")
        return true;
     return false;
  }

  // }}}
  // {{{ sock_to_host()

  /**
   * Returns the socket for the host
   *
   * @param   string   $host    Host:IP to get socket for
   *
   * @return  mixed    IO Stream or false
   * @access  private
   */
  function sock_to_host ($host)
  {
     if (isset($this->_cache_sock[$host]))
        return $this->_cache_sock[$host];
     
     $now = time();
     list ($ip, $port) = explode (":", $host);
     if (isset($this->_host_dead[$host]) && $this->_host_dead[$host] > $now ||
         isset($this->_host_dead[$ip]) && $this->_host_dead[$ip] > $now)
        return null;
         
     if (!$this->_connect_sock($sock, $host))
        return $this->_dead_sock($host);
         
     // Do not buffer writes
     stream_set_write_buffer($sock, 0);
     
     $this->_cache_sock[$host] = $sock;
     
     return $this->_cache_sock[$host];
  }

  // }}}
  // }}}
  // }}}
}

// }}}
?>

<?php
               eaccelerator_lock("count");
               eaccelerator_put("count",eaccelerator_get("count")+1));
       ?>

<?php eaccelerator_cache_output('test', 'echo time(); phpinfo();', 30); ?>

<?php eaccelerator_cache_output('test', 'time()." Hello";', 30); ?>

<?php
               eaccelerator_cache_page($_SERVER['PHP_SELF'].'?GET='.serialize($_GET),30);
               echo time();
               phpinfo();
       ?>

cd /usr/ports/editors/joe/
make fetch  

cd /usr/ports/systuils/portupgrade/
make fetch-recursive  

cd /usr/ports/
make fetch  

cd /usr/ports/ftp/
make fetch  

cd /usr/ports/editors/joe/
make extract  

cd /usr/ports/editors/joe/
make patch  

cd /usr/ports/editors/joe/
make install  

cd /usr/ports/editors/joe/
#make clean  

cd /usr/ports/
#make clean  

cd /usr/ports/editors/joe/
#make package  

mkdir -p /usr/ports/packages/All/  

cd /usr/ports/editors/joe/
make package clean  

cd /usr/ports/sysutils/portupgrade/
make DEPENDS_TARGET=package package  

cd /var/db/pkg/
pkg_create -b joe-{版本号}  

cd /usr/ports/editors/joe/
make clean  

cd /usr/ports/
make clean

cd /usr/ports/ftp/
make clean  

cd /usr/ports/editors/joe/
make distclean  

cd /usr/ports/
make distclean  

cd /usr/ports/ftp/
make distclean  

cd /usr/ports/mail/p5-Mail-SpamAssassin/
make all-depends-list #显示所有相关的套件
make pretty-print-build-depends-list #显示编译期间所需要的套件
make pretty-print-run-depends-list #显示此套件要执行时所需要的套件

cd /usr/ports/editors/joe/
make deinstall  

cd /var/db/pkg/
pkg_delete joe-{version}  

cd /var/db/pkg/
pkg_delete -f joe-{version}  

cd /usr/ports/sysutils/portupgrade/
make deinstall-depends  

cd /var/db/pkg/
pkg_delete -r portupgrade-{version}  

cd /usr/ports/editors/joe/
make deinstall
make clean
make install 或 make reinstall  

cd /usr/ports/
make search key=ldap

cd /usr/ports/ftp/
make search key=ldap  

cd /usr/ports/
make search name=ldap

cd /usr/ports/ftp/
make search name=ldap  

cd /var/db/pkg/
pkg_delete joe-{version}
cd /usr/ports/editors/joe/
make install  

cd /usr/ports/editors/joe/
make clean
make reinstall

pkg_info

pkg_info | grep  

pkg_info -W /usr/local/bin/joe  

pkg_info -L /var/db/pkg/joe-{version}  

# vi /usr/share/examples/cvsup/ports-supfile
******************************************
default date=2002.10.05.00.00.00 #将 date 改成当日  

# vi /usr/share/examples/cvsup/ports-supfile
******************************************
#ports-all #将 ports-all 标示起来
ports-lang #加入这行  

cd /usr/src/
make update
cd /usr/src/share/mk
make install  

cd /usr/ports/???/???/
make -DUSE_REINPLACE install  

pkg_version -c  

cd /usr/ports/sysutils/portupgrade/
make -DNOPORTDOCS install # make NOPORTDOCS=yes install 亦同  

cd /usr/ports/sysutils/portupgrade/
grep defined Makefile  

cd /usr/ports/ftp/pure-ftpd/
make CONFIGURE_ARGS+="--without-inetd" install  

cd /usr/ports/editors/joe/
make PREFIX=/usr install

只要在make install 時加上 FORCE_PKG_REGISTER="yes" 就可以強制安裝.
也就是: /usr/ports/資料夾位址/#make install FORCE_PKG_REGISTER="yes"

pkg_add joe-{version}.tgz  

pkg_add -f joe-{version}.tgz  

pkg_info -r portupgrade-{version}.tgz

pkg_add -r portupgrade  

cd /usr/ports/
make index  

cd /usr/ports/
make readmes

cd /usr/ports/ftp/
make readme  

# vi /usr/sup/refuse
******************************************
ports/french
ports/german
ports/hebrew
ports/hungarian
ports/japanese

# vi /usr/sup/refuse
******************************************
ports/lang/perl5.8  

# vi /usr/sup/refuse
******************************************
ports/lang/perl*
ports/po*  

# cd /usr/ports/mail/cclient/
# make reinstall 或 # make deinstall && make install
# cd /usr/ports/mail/imap-uw/
# make install  

openssl version -v  

make -DWITH_OPENSSL_PORT install  

brandelf -l  

brandelf execution-binary-filename  

brandelf -t Linux execution-binary-filename

rpm --ignoreos --root /compat/linux --dbpath /var/lib/rpm/ -Uvh xxx.rpm

make clean
make showconfig # 显示设定的内容
make rmconfig # 清除设定的内容
make config  

cat /var/db/ports/python/options  

pkg_info | sort | sed -e 's/-[0-9].*$//' | uniq -c | grep -v '^[[:space:]]*1'  

cd /usr/ports/
make search name=libtool  

/usr/ports/devel/libtool13
/usr/ports/devel/libtool14
/usr/ports/devel/libtool15  

cd /usr/ports/
make search name=gettext  

/usr/ports/devel/gettext  

cd /var/db/pkg/
pkg_delete p*  

cd /usr/ports/editors/joe/
make distclean  

String.prototype.trim = function() {
return this.replace(/(^\s*)|(\s*$)/g, "");
}

function IP2V(ip) {
re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //匹配IP地址的正则表达式
if(re.test(ip)) {
return RegExp.*Math.pow(255,3))+RegExp.*Math.pow(255,2))+RegExp.*255+RegExp.*1
}
else {
throw new Error("Not a valid IP address!")
}
}

var s="abacabefgeeii"
var s1=s.replace(/(.).*/g,"")
var re=new RegExp("["+s1+"]","g")
var s2=s.replace(re,"")
alert(s1+s2) //结果为：abcefgi

s="http://www.9499.net/page1.htm"
s=s.replace(/(.*\/)([^\.]+).*/ig,"")
alert(s)

onkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\u4E00-\u9FA5]/g,''))"

onkeyup="value=value.replace(/[^\uFF00-\uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\uFF00-\uFFFF]/g,''))"

onkeyup="value=value.replace(/[^\d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"

onkeyup="value=value.replace(/[\W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"