php-doc-en/functions/strings.xml

 <reference id="ref.strings">
  <title>String functions</title>
  <titleabbrev>Strings</titleabbrev>

  <partintro>
   <simpara>
    These functions all manipulate strings in various ways. Some more
    specialized sections can be found in the regular expression and
    URL handling sections.
   </simpara>

   <para>
    For information on how strings behave, especially with regard to
    usage of single quotes, double quotes, and escape sequences, see
    the <link linkend="language.types.string">Strings</link> entry in
    the <link linkend="language.types">Types</link> section of the
    manual. 
   </para>
  </partintro>

  <refentry id="function.addcslashes">
   <refnamediv>
    <refname>AddCSlashes</refname>
    <refpurpose>Quote string with slashes in a C style</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>addcslashes</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
      <paramdef>string <parameter>charlist</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns a string with backslashes before characters that are
     listed in <parameter>charlist</parameter> parameter. It escapes
     <literal>\n</literal>, <literal>\r</literal> etc. in C-like
     style, characters with ASCII code lower than 32 and higher than
     126 are converted to octal representation. Be carefull when
     escaping alphanumeric characters. You can specify a range in
     <parameter>charlist</parameter> like "\0..\37", which would
     escape all characters with ASCII code between 0 and 31.
     <example>
      <title><function>Addcslashes</function> example</title>
      <programlisting role="php">
$escaped = addcslashes ($not_escaped, "\0..\37!@\177..\377");
      </programlisting>
     </example>
     <note>
      <simpara>
       Added in PHP4b3-dev.</simpara>
     </note>
    </para>
    <para>
     See also <function>stripcslashes</function>, 
     <function>stripslashes</function>, 
     <function>htmlspecialchars</function>,
     <function>htmlspecialchars</function>, and 
     <function>quotemeta</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.addslashes">
   <refnamediv>
    <refname>AddSlashes</refname>
    <refpurpose>Quote string with slashes</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>addslashes</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns a string with backslashes before characters that need
     to be quoted in database queries etc.  These characters are
     single quote (<literal>'</literal>), double quote
     (<literal>"</literal>), backslash (<literal>\</literal>)
     and NUL (the null byte).
    </para>
    <para>
     See also <function>stripslashes</function>, 
     <function>htmlspecialchars</function>, and
     <function>quotemeta</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.bin2hex">
   <refnamediv>
    <refname>bin2hex</refname>
    <refpurpose>
     Convert binary data into hexadecimal representation
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>bin2hex</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns an ASCII string containing the hexadecimal representation
     of <parameter>str</parameter>. The conversion is done byte-wise
     with the high-nibble first.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.chop">
   <refnamediv>
    <refname>Chop</refname>
    <refpurpose>Remove trailing whitespace</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>chop</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns the argument string without trailing whitespace,
     including newlines.
     <example>
      <title><function>Chop</function> example</title>
      <programlisting role="php">
$trimmed = chop ($line);
      </programlisting>
     </example>
    </para>
    <note>
     <para>
      <function>chop</function> is different than the Perl
      <parameter>chop()</parameter> function, which removes the last
      character in the string.
     </para>
    </note>
    <para>
     See also <function>trim</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.chr">
   <refnamediv>
    <refname>Chr</refname>
    <refpurpose>Return a specific character</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>chr</function></funcdef>
      <paramdef>int <parameter>ascii</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns a one-character string containing the character specified
     by <parameter>ascii</parameter>.
     <example>
      <title><function>Chr</function> example</title>
      <programlisting role="php">
$str .= chr (27); /* add an escape character at the end of $str */

/* Often this is more useful */

$str = sprintf ("The string ends in escape: %c", 27);
      </programlisting>
     </example>
     This function complements <function>ord</function>. See also
     <function>sprintf</function> with a format string of
     <literal>%c</literal>.
    </para>
   </refsect1>
  </refentry>
  
  <refentry id="function.chunk-split">
   <refnamediv>
    <refname>chunk_split</refname>
    <refpurpose>Split a string into smaller chunks</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>chunk_split</function></funcdef>
      <paramdef>string <parameter>string</parameter></paramdef>
      <paramdef>int 
       <parameter><optional>chunklen</optional></parameter>
      </paramdef>
      <paramdef>string 
       <parameter><optional>end</optional></parameter>
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Can be used to split a string into smaller chunks which is useful
     for e.g. converting <link
     linkend="function.base64-encode">base64_encode</link> output to
     match RFC 2045 semantics. It inserts every
     <parameter>chunklen</parameter> (defaults to 76) chars the string
     <parameter>end</parameter> (defaults to "\r\n").  It returns the
     new string leaving the original string untouched.
     <example>
      <title><function>Chunk_split</function> example</title>
      <programlisting role="php">
# format $data using RFC 2045 semantics

$new_string = chunk_split (base64_encode($data));
      </programlisting>
     </example>
     This function is significantly faster than
     <function>ereg_replace</function>.
     <note>
      <para>
       This function was added in 3.0.6.
      </para>
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.convert-cyr-string">
   <refnamediv>
    <refname>convert_cyr_string</refname>
    <refpurpose>
     Convert from one Cyrillic character set to another
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>convert_cyr_string</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
      <paramdef>string <parameter>from</parameter></paramdef>
      <paramdef>string <parameter>to</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     This function converts the given string from one Cyrillic
     character set to another.  The <parameter>from</parameter> and
     <parameter>to</parameter> arguments are single characters that
     represent the source and target Cyrillic character sets.  The
     supported types are:
     <itemizedlist>
      <listitem>
       <simpara>
	k - koi8-r
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	w - windows-1251
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	i - iso8859-5
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	a - x-cp866
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	d - x-cp866
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	m - x-mac-cyrillic
       </simpara>
      </listitem>
     </itemizedlist>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.count-chars">
   <refnamediv>
    <refname>count_chars</refname>
    <refpurpose>
     Return information abouts characters used in a string
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>mixed <function>count_chars</function></funcdef>
      <paramdef>string <parameter>string</parameter></paramdef>
      <paramdef>
       <parameter>
        <optional>mode</optional>
       </parameter>
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Counts the number of occurances of every byte-value (0..255) in
     <parameter>string</parameter> and returns it in various ways.
     The optional parameter <parameter>Mode</parameter> default to
     0. Depending on <parameter>mode</parameter>
     <function>count_chars</function> returns one of the following:
     <itemizedlist>
      <listitem>
       <simpara>
	0 - an array with the byte-value as key and the freqency of
	every byte as value.
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	1 - same as 0 but only byte-values with a frequency greater
	than zero are listed.
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	2 - same as 0 but only byte-values with a frequency equal to
	zero are listed.  
       </simpara>
      </listitem> 
      <listitem>
       <simpara> 
	3 - a string containing all used byte-values is returned.
       </simpara>
      </listitem> 
      <listitem>
       <simpara> 
	4 - a string containing all not used byte-values is returned.
       </simpara>
      </listitem> 
     </itemizedlist>
    </para>
    <note>
     <para>
      This function was added in PHP 4.0.
     </para> 
    </note>
   </refsect1>
  </refentry>

  <refentry id="function.crc32">
   <refnamediv>
    <refname>crc32</refname>
    <refpurpose>Calculates the crc32 polynomial of a string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>crc32</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
	 Generates the cyclic redundancy checksum polynomial of 32-bit lengths of
	 the <parameter>str</parameter>. This is usually used to validate the
	 integrity of data being trasmited.
    </para>
	<para>
	See also: <function>md5</function>
	</para>
   </refsect1>
  </refentry>
 
  <refentry id="function.crypt">
   <refnamediv>
    <refname>crypt</refname>
    <refpurpose>DES-encrypt a string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>crypt</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
      <paramdef>string 
       <parameter><optional>salt</optional></parameter>
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     <function>crypt</function> will encrypt a string using the
     standard Unix <abbrev>DES</abbrev> encryption method.  Arguments
     are a string to be encrypted and an optional two-character salt
     string to base the encryption on.  See the Unix man page for your
     crypt function for more information.
    </para>
    <simpara>
     If the salt argument is not provided, one will be randomly
     generated by PHP.
    </simpara>
    <simpara>
     Some operating systems support more than one type of encryption.
     In fact, sometimes the standard DES encryption is replaced by an
     MD5 based encryption algorithm.  The encryption type is triggered
     by the salt argument.  At install time, PHP determines the
     capabilities of the crypt function and will accept salts for
     other encryption types.  If no salt is provided, PHP will
     auto-generate a standard 2-character DES salt by default, unless
     the default encryption type on the system is MD5, in which case a
     random MD5-compatible salt is generated.  PHP sets a constant
     named CRYPT_SALT_LENGTH which tells you whether a regular
     2-character salt applies to your system or the longer 12-char MD5
     salt is applicable.
    </simpara>
    <simpara>
     If you are using the supplied salt, you should be aware that the
     salt is generated once. If you are calling this function
     recursively, this may impact both appearance and, to a certain
     extent, security.
    </simpara>  
    <simpara>
     The standard DES encryption <function>crypt</function> contains
     the salt as the first two characters of the output.
    </simpara>
    <simpara>
     On systems where the crypt() function supports multiple
     encryption types, the following constants are set to 0 or 1
     depending on whether the given type is available:
    </simpara>
    <itemizedlist>
     <listitem>
      <simpara>
       CRYPT_STD_DES - Standard DES encryption with a 2-char SALT
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       CRYPT_EXT_DES - Extended DES encryption with a 9-char SALT
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       CRYPT_MD5 - MD5 encryption with a 12-char SALT starting with
       $1$
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       CRYPT_BLOWFISH - Extended DES encryption with a 16-char SALT
       starting with $2$
      </simpara>
     </listitem>
    </itemizedlist>
    <simpara>
     There is no decrypt function, since <function>crypt</function>
     uses a one-way algorithm.
    </simpara>
    <simpara>
    	See also: <function>md5</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.echo">
   <refnamediv>
    <refname>echo</refname>
    <refpurpose>Output one or more strings</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef><function>echo</function></funcdef>
      <paramdef>string <parameter>arg1</parameter></paramdef>
      <paramdef>string 
       <parameter><optional>argn</optional>...</parameter>
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <simpara>
     Outputs all parameters.
    </simpara>
    <para>
     <function>Echo</function> is not actually a function (it is a
     language construct) so you are not required to use parantheses
     with it.  
     <example>
      <title><function>Echo</function> example</title>
      <programlisting role="php">
echo "Hello World";

echo "This spans
multiple lines. The newlines will be 
output as well";

echo "This spans\nmultiple lines. The newlines will be\noutput as well.";
      </programlisting>
     </example>
    </para>	 
    <note>
     <para>
      In fact, if you want to pass more than one parameter to echo,
      you must not enclose the parameters within parentheses.
     </para>
    </note>
    <simpara>
     See also:
     <function>print</function>,
     <function>printf</function>, and
     <function>flush</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.explode">
   <refnamediv>
    <refname>explode</refname>
    <refpurpose>Split a string by string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>array <function>explode</function></funcdef>
      <paramdef>string <parameter>separator</parameter></paramdef>
      <paramdef>string <parameter>string</parameter></paramdef>
      <paramdef>int    
       <parameter><optional>limit</optional></parameter>
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns an array of strings, each of which is a substring of
     <parameter>string</parameter> formed by splitting it on boundaries formed 
     by the string <parameter>delim</parameter>. 
     If <parameter>limit</parameter> is set, the returned array will contaion 
     a maximum of <parameter>limit</parameter> elements with the last element
     containing the whole rest of <parameter>string</parameter>.
    </para>
    <para>
     <example>
      <title><function>Explode</function> example</title>
      <programlisting role="php">
$pizza = "piece1 piece2 piece3 piece4 piece5 piece6";
$pieces = explode (" ", $pizza);
      </programlisting>
     </example>
    </para>
    <para>
     See also <function>split</function> and
     <function>implode</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.get-html-translation-table">
   <refnamediv>
    <refname>get_html_translation_table</refname>
    <refpurpose>
     Returns the translation table used by
     <function>htmlspecialchars</function> and
     <function>htmlentities</function>
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string 
       <function>get_html_translation_table</function>
      </funcdef>
      <paramdef>int <parameter>table</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     <function>get_html_translation_table</function> will return the
     translation table that is used internally for
     <function>htmlspecialchars</function> and
     <function>htmlentities</function>. Ther are two new defines
     (<parameter>HTML_ENTITIES</parameter>,
     <parameter>HTML_SPECIALCHARS</parameter>) that allow you to
     specify the table you want.
     <example>
      <title>Translation Table Example</title>
      <programlisting role="php">
$trans = get_html_translation_table (HTML_ENTITIES);
$str = "Hallo &amp; &lt;Frau> &amp; Kr&auml;mer";
$encoded = strtr ($str, $trans);
      </programlisting>
     </example>
     The <literal>$encoded</literal> variable will now contain: "Hallo
     &amp;<sgmltag>amp</sgmltag>;
     &amp;<sgmltag>lt</sgmltag>;Frau&amp;<sgmltag>gt</sgmltag>;
     &amp;<sgmltag>amp</sgmltag>; Kr&amp;<sgmltag>auml</sgmltag>;mer".
    </para>
    <para>
     The cool thing is using <function>array_flip</function> to change
     the direction of the translation.
     <informalexample>
      <programlisting role="php">
$trans = array_flip ($trans);
$original = strtr ($str, $trans);
      </programlisting>
     </informalexample>
      The content of <literal>$original</literal> would be: "Hallo &amp;
      &lt;Frau> &amp; Kr&auml;mer".
     <note>
      <para>
       This function was added in PHP 4.0.
      </para> 
     </note>
    </para>
    <para>
     See also: <function>htmlspecialchars</function>,
     <function>htmlentities</function>, <function>strtr</function>,
     and <function>array_flip</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.get-meta-tags">
   <refnamediv>
    <refname>get_meta_tags</refname>
    <refpurpose>
     Extracts all meta tag content attributes from a file and returns
     an array
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>array <function>get_meta_tags</function></funcdef>
      <paramdef>string <parameter>filename</parameter></paramdef>
      <paramdef>int
       <parameter><optional>use_include_path</optional></parameter>
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Opens <parameter>filename</parameter> and parses it line by line
     for &lt;meta> tags of the form
     <example>
      <title>Meta Tags Example</title>
      <programlisting role="html">
&lt;meta name="author" content="name">
&lt;meta name="tags" content="php3 documentation">
&lt;/head> &lt;!-- parsing stops here -->
      </programlisting>
     </example>
     (pay attention to line endings - PHP uses a native function to
     parse the input, so a Mac file won't work on Unix).
    </para>
    <para> 
     The value of the name property becomes the key, the value of the
     content property becomes the value of the returned array, so you
     can easily use standard array functions to traverse it or access
     single values. Special characters in the value of the name
     property are substituted with '_', the rest is converted to lower
     case.
    </para>
    <para>
     Setting <parameter>use_include_path</parameter> to 1 will result
     in PHP trying to open the file along the standard include path.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.hebrev">
   <refnamediv>
    <refname>hebrev</refname>
    <refpurpose>
     Convert logical Hebrew text to visual text
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>hebrev</function></funcdef>
      <paramdef>string <parameter>hebrew_text</parameter></paramdef>
      <paramdef>int 
	    <parameter><optional>max_chars_per_line</optional></parameter>
	  </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
	  The optional parameter <parameter>max_chars_per_line</parameter>
	  indicates maximum number of characters per line will be output. The
	  function tries to avoid breaking words.
    </para>
	<para>
     See also <function>hebrevc</function>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.hebrevc">
   <refnamediv>
    <refname>hebrevc</refname>
    <refpurpose>
     Convert logical Hebrew text to visual text with newline conversion
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>hebrevc</function></funcdef>
      <paramdef>string <parameter>hebrew_text</parameter></paramdef>
      <paramdef>int 
	    <parameter><optional>max_chars_per_line</optional></parameter>
	  </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
	  This function is similar to <function>hebrev</function> with the
	  difference that it converts newlines (\n) to "&lt;br&gt;\n".
	  The optional parameter <parameter>max_chars_per_line</parameter>
	  indicates maximum number of characters per line will be output. The
	  function tries to avoid breaking words.
    </para>
	<para>
     See also <function>hebrev</function>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.htmlentities">
   <refnamediv>
    <refname>htmlentities</refname>
    <refpurpose>
     Convert all applicable characters to HTML entities
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>htmlentities</function></funcdef>
      <paramdef>string <parameter>string</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     This function is identical to
     <function>Htmlspecialchars</function> in all ways, except that
     all characters which have HTML entity equivalents are translated
     into these entities.
    </para>
    <para>
     At present, the ISO-8859-1 character set is used.
    </para>
    <para>
     See also <function>htmlspecialchars</function> and
     <function>nl2br</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.htmlspecialchars">
   <refnamediv>
    <refname>htmlspecialchars</refname> 
    <refpurpose>
     Convert special characters to HTML entities
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>htmlspecialchars</function></funcdef>
      <paramdef>string <parameter>string</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Certain characters have special significance in HTML, and should
     be represented by HTML entities if they are to preserve their
     meanings. This function returns a string with these conversions
     made.
    </para>
    <simpara>
     This function is useful in preventing user-supplied text from
     containing HTML markup, such as in a message board or guest book
     application.
    </simpara>
    <para>
     At present, the translations that are done are:
     <itemizedlist>
      <listitem>
       <simpara>
        '&amp;' (ampersand) becomes '&amp;amp;'
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        '&quot;' (double quote) becomes '&amp;quot;'
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        '&lt;' (less than) becomes '&amp;lt;'
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        '&gt;' (greater than) becomes '&amp;gt;'
       </simpara>
      </listitem>
     </itemizedlist>
    </para>
    <para>
     Note that this functions does not translate anything beyond what
     is listed above. For full entity translation, see
     <function>htmlentities</function>.
    </para>
    <para>
     See also <function>htmlentities</function> and
     <function>nl2br</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.implode">
   <refnamediv>
    <refname>implode</refname>
    <refpurpose>Join array elements with a string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>implode</function></funcdef>
      <paramdef>string <parameter>glue</parameter></paramdef>
      <paramdef>array <parameter>pieces</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns a string containing a string representation of all the
     array elements in the same order, with the glue string between
     each element.
     <example>
      <title><function>Implode</function> example</title>
      <programlisting role="php">
$colon_separated = implode (":", $array);
      </programlisting>
     </example>
    </para>
    <simpara>
     See also <function>explode</function>, <function>join</function>,
     and <function>split</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.join">
   <refnamediv>
    <refname>join</refname>
    <refpurpose>Join array elements with a string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>join</function></funcdef>
      <paramdef>string <parameter>glue</parameter></paramdef>
      <paramdef>array <parameter>pieces</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <simpara>
     <function>join</function> is an alias to
     <function>implode</function>, and is identical in every way.
    </simpara>
    <simpara>
     See also <function>explode</function>, <function>implode</function>,
     and <function>split</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.levenshtein">
   <refnamediv>
    <refname>levenshtein</refname> 
    <refpurpose>
     Calculate Levenshtein distance between two strings		
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>levenshtein</function></funcdef>
      <paramdef>string <parameter>str1</parameter></paramdef>
      <paramdef>string <parameter>str2</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     This function return the Levenshtein-Distance between the two
     argument strings or -1, if one of the argument strings is longer
     than the limit of 255 characters.
    </para>
    <para>
     The Levenshtein distance is defined as the minimal number of
     characters you have to replace, insert or delete to transform
     <parameter>str1</parameter> into <parameter>str2</parameter>.
     The complexity of the algorithm is <literal>O(m*n)</literal>,
     where <literal>n</literal> and <literal>m</literal> are the
     length of <parameter>str1</parameter> and
     <parameter>str2</parameter> (rather good when compared to
     <function>similar_text</function>, which is O(max(n,m)**3), but
     still expensive).
    </para>
    <para>
     See also <function>soundex</function>,
     <function>similar_text</function> and
     <function>metaphone</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.ltrim">
   <refnamediv>
    <refname>ltrim</refname> 
    <refpurpose>
     Strip whitespace from the beginning of a string
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>ltrim</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     This function strips whitespace from the start of a string and
     returns the stripped string.  The whitespace
     characters it currently strips are: "\n", "\r", "\t", "\v", "\0",
     and a plain space.
    </para>
    <para>
     See also <function>chop</function> and <function>trim</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.md5">
   <refnamediv>
    <refname>md5</refname>
    <refpurpose>Calculate the md5 hash of a string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>md5</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Calculates the MD5 hash of <parameter>str</parameter> using the
     <ulink url="&url.rfc;rfc1321.html">RSA Data Security, Inc. 
     MD5 Message-Digest Algorithm</ulink>.
    </para>
	<para>
	See also: <function>crc32</function>
	</para>
   </refsect1>
  </refentry>

  <refentry id="function.metaphone">
   <refnamediv>
    <refname>Metaphone</refname>
    <refpurpose>Calculate the metaphone key of a string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>metaphone</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Calculates the metaphone key of <parameter>str</parameter>.
    </para>
    <para>
     Similar to <function>soundex</function> metaphone creates the
     same key for similar sounding words. It's more accurate than
     <function>soundex</function> as it knows the basic rules of
     English pronunciation.  The metaphone generated keys are of
     variable length.
    </para>
    <para>
     Metaphone was developed by Lawrence Philips
     &lt;lphilips@verity.com>. It is described in ["Practical
     Algorithms for Programmers", Binstock &amp; Rex, Addison Wesley,
     1995].
     <note>
      <para>
       This function was added in PHP 4.0.
      </para>
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.nl2br">
   <refnamediv>
    <refname>nl2br</refname>
    <refpurpose>Converts newlines to HTML line breaks</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>nl2br</function></funcdef>
      <paramdef>string <parameter>string</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns <parameter>string</parameter> with '&lt;BR&gt;' inserted
     before all newlines.
    </para>
    <para>
     See also <function>htmlspecialchars</function>,
     <function>htmlentities</function> and
     <function>wordwrap</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.ord">
   <refnamediv>
    <refname>Ord</refname>
    <refpurpose>Return ASCII value of character</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>ord</function></funcdef>
      <paramdef>string <parameter>string</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns the ASCII value of the first character of
     <parameter>string</parameter>.  This function complements
     <function>chr</function>.
     <example>
      <title><function>Ord</function> example</title>
      <programlisting role="php">
if (ord ($str) == 10) {
    echo "The first character of \$str is a line feed.\n";
}
      </programlisting>
     </example>
    </para>
    <simpara>
     See also <function>chr</function>.
    </simpara> 
   </refsect1>
  </refentry>

  <refentry id="function.parse-str">
   <refnamediv>
    <refname>parse_str</refname>
    <refpurpose>Parses the string into variables</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>void <function>parse_str</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Parses <parameter>str</parameter> as if it were the query string
     passed via an URL and sets variables in the current scope.
    </para>
    <para>
     <example>
      <title>Using <function>parse_str</function></title>
      <programlisting role="php">
$str = "first=value&amp;second[]=this+works&amp;second[]=another";
parse_str($str);
echo $first;     /* prints "value" */
echo $second[0]; /* prints "this works" */
echo $second[1]; /* prints "another" */
      </programlisting>
     </example>
    </para>
     <note>
      <para>
       This currently requires 
       <link linkend="ini.register-globals">register_globals</link>=on 
       to be set in <filename>php.ini</filename>, this behaviour may 
       change in the future (After 4.0.2) and this function might well 
       also return an array of values.
      </para> 
     </note>	 
   </refsect1>
  </refentry>

  <refentry id="function.print">
   <refnamediv>
    <refname>print</refname>
    <refpurpose>Output a string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef><function>print</function></funcdef>
      <paramdef>string <parameter>arg</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <simpara>
     Outputs <parameter>arg</parameter>.
    </simpara>
    <simpara>
     See also: <function>echo</function>, <function>printf</function>,
     and <function>flush</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.printf">
   <refnamediv>
    <refname>printf</refname>
    <refpurpose>Output a formatted string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>printf</function></funcdef>
      <paramdef>string <parameter>format</parameter></paramdef>
      <paramdef>mixed 
       <parameter><optional>args</optional></parameter>...
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <simpara>
     Produces output according to <parameter>format</parameter>, which
     is described in the documentation for <function>sprintf</function>.
    </simpara>
    <simpara>
     See also: <function>print</function>, <function>sprintf</function>, 
	 <function>sscanf</function>, <function>fscanf</function>,
	 and <function>flush</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.quoted-printable-decode">
   <refnamediv>
    <refname>quoted_printable_decode</refname>
    <refpurpose>
     Convert a quoted-printable string to an 8 bit string
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string
       <function>quoted_printable_decode</function>
      </funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <simpara>
     This function returns an 8-bit binary string corresponding to the
     decoded quoted printable string.  This function is similar to
     <function>imap_qprint</function>, except this one does not
     require the IMAP module to work.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.quotemeta">
   <refnamediv>
    <refname>quotemeta</refname>
    <refpurpose>Quote meta characters</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>quotemeta</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns a version of str with a backslash character
     (<literal>\</literal>) before every character that is among
     these: <screen>. \\ + * ? [ ^ ] ( $ )</screen>
    </para>
    <simpara>
     See also <function>addslashes</function>,
     <function>htmlentities</function>, 
     <function>htmlspecialchars</function>, 
     <function>nl2br</function>, and 
     <function>stripslashes</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.rtrim">
   <refnamediv>
    <refname>rtrim</refname>
    <refpurpose>Remove trailing whitespace.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcdef>string <function>rtrim</function></funcdef>
     <paramdef>string <parameter>str</parameter></paramdef>
    </funcsynopsis>
    <para>
     Returns the argument string without trailing whitespace,
     including newlines.  This is an alias for <function>chop</function>.
     <example>
      <title><function>rtrim</function> example</title>
      <programlisting role="php">
$trimmed = rtrim ($line);
      </programlisting>
     </example>
    </para>
    <para>
     See also <function>trim</function>, <function>ltrim</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.sscanf">
   <refnamediv>
    <refname>sscanf</refname>
    <refpurpose>Parses input from a string according to a format</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>mixed <function>sscanf</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
      <paramdef>string <parameter>format</parameter></paramdef>
      <paramdef>string 
       <parameter><optional>var1</optional></parameter>...
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
	 The function <function>sscanf</function> is the input analog of
	 <function>printf</function>. <function>Sscanf</function> reads from
	 the string <parameter>str</parameter> and interprets it according to
	 the specified <parameter>format</parameter>. If only two parameters were
	 passed to this function, the values parsed will be returned as an array.
	 <example>
	 <title><function>Sscanf</function> Example</title>
	 <programlisting role="php">
// getting the serial number
$serial = sscanf("SN/2350001","SN/%d");
// and the date of manufacturing
$mandate = "January 01 2000";
list($month, $day, $year) = sscanf($mandate,"%s %d %d");
echo "Item $serial was manufactured on: $year-".substr($month,0,3)."-$day\n";
	 </programlisting>
	 </example>
	 If optional parameters are passed, the function will return the number of
	 assigned values. The optional parameters must be passed by reference.
 <example>
	 <title><function>Sscanf</function> - using optional parameters</title>
	 <programlisting role="php">
// get author info and generate DocBook entry
$auth = "24\tLewis Carroll";
$n = sscanf($auth,"%d\t%s %s", &amp;$id, &amp;$first, &amp;$last);
echo "&lt;author id='$id'&gt;
	&lt;firstname&gt;$first&lt;/firstname&gt;
	&lt;surname&gt;$last&lt;/surname&gt;
&lt;/author&gt;\n";
	 </programlisting>
	 </example>
    </para>
    <para>
     See also: <function>fscanf</function>, <function>printf</function>,
     and <function>sprintf</function>. 
    </para>
   </refsect1>
  </refentry>
 
  <refentry id="function.setlocale">
   <refnamediv>
    <refname>setlocale</refname>
    <refpurpose>Set locale information</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>setlocale</function></funcdef>
      <paramdef>string <parameter>category</parameter></paramdef>
      <paramdef>string <parameter>locale</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     <parameter>Category</parameter> is a string specifying the
     category of the functions affected by the locale setting:
     <itemizedlist>
      <listitem>
       <simpara>
	LC_ALL for all of the below
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	LC_COLLATE for string comparison - not currently implemented in PHP
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	LC_CTYPE for character classification and conversion, for
	example <function>strtoupper</function>
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	LC_MONETARY for localeconv() - not currently implemented in
	PHP
       </simpara>
      </listitem>
      <listitem>
       <simpara> 
	LC_NUMERIC for decimal separator
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	LC_TIME for date and time formatting with
	<function>strftime</function>
       </simpara>
      </listitem>
     </itemizedlist>
    </para>
    <para>
     If <parameter>locale</parameter> is the empty string
     <literal>""</literal>, the locale names will be set from the
     values of environment variables with the same names as the above
     categories, or from "LANG".
    </para>
    <para>
     If locale is zero or <literal>"0"</literal>, the locale setting
     is not affected, only the current setting is returned.
    </para>
    <para>
     Setlocale returns the new current locale, or false if the locale
     functionality is not implemented in the plattform, the specified
     locale does not exist or the category name is invalid.
     An invalid category name also causes a warning message.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.similar-text">
   <refnamediv>
    <refname>similar_text</refname>
    <refpurpose>
     Calculate the similarity between two strings
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>similar_text</function></funcdef>
      <paramdef>string <parameter>first</parameter></paramdef>
      <paramdef>string <parameter>second</parameter></paramdef>
      <paramdef>double 
       <parameter><optional>percent</optional></parameter>
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     This calculates the similarity between two strings as described
     in Oliver [1993]. Note that this implementation does not use a
     stack as in Oliver's pseudo code, but recursive calls which may
     or may not speed up the whole process. Note also that the
     complexity of this algorithm is O(N**3) where N is the length of
     the longest string.
    </para>
    <para>
     By passing a reference as third argument,
     <function>similar_text</function> will calculate the similarity
     in percent for you. It returns the number of matching chars in
     both strings.
    </para>
   </refsect1>
  </refentry>
    
  <refentry id="function.soundex">
   <refnamediv>
    <refname>soundex</refname>
    <refpurpose>Calculate the soundex key of a string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>soundex</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Calculates the soundex key of <parameter>str</parameter>.
    </para>
    <para>
     Soundex keys have the property that words pronounced similarly
     produce the same soundex key, and can thus be used to simplify
     searches in databases where you know the pronunciation but not
     the spelling. This soundex function returns a string 4 characters
     long, starting with a letter.
    </para>
    <para>
     This particular soundex function is one described by Donald Knuth
     in "The Art Of Computer Programming, vol. 3: Sorting And
     Searching", Addison-Wesley (1973), pp. 391-392.
    </para>
    <para>
     <example>
      <title>Soundex Examples</title>
      <programlisting role="php">
soundex ("Euler") == soundex ("Ellery") == 'E460';
soundex ("Gauss") == soundex ("Ghosh") == 'G200';
soundex ("Knuth") == soundex ("Kant") == 'H416';
soundex ("Lloyd") == soundex ("Ladd") == 'L300';
soundex ("Lukasiewicz") == soundex ("Lissajous") == 'L222';
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.sprintf">
   <refnamediv>
    <refname>sprintf</refname>
    <refpurpose>Return a formatted string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>sprintf</function></funcdef>
      <paramdef>string <parameter>format</parameter></paramdef>
      <paramdef>mixed 
       <parameter><optional>args</optional></parameter>...
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <simpara>
     Returns a string produced according to the formatting string
     <parameter>format</parameter>.
    </simpara>
    <simpara>
     The format string is composed by zero or more directives:
     ordinary characters (excluding <literal>%</literal>) that are
     copied directly to the result, and <emphasis>conversion
     specifications</emphasis>, each of which results in fetching its
     own parameter.  This applies to both <function>sprintf</function>
     and <function>printf</function>.
    </simpara>
    <para>
     Each conversion specification consists of these elements, in
     order:
     <orderedlist>
      <listitem>
       <simpara>
	An optional <emphasis>padding specifier</emphasis> that says
	what character will be used for padding the results to the
	right string size.  This may be a space character or a
	<literal>0</literal> (zero character).  The default is to pad
	with spaces.  An alternate padding character can be specified
	by prefixing it with a single quote (<literal>'</literal>).
	See the examples below.
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	An optional <emphasis>alignment specifier</emphasis> that says
	if the result should be left-justified or right-justified.
	The default is right-justified; a <literal>-</literal>
	character here will make it left-justified.
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	An optional number, a <emphasis>width specifier</emphasis>
	that says how many characters (minimum) this conversion should
	result in.
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	An optional <emphasis>precision specifier</emphasis> that says
	how many decimal digits should be displayed for floating-point
	numbers.  This option has no effect for other types than
	double. (Another function useful for formatting numbers is
	<function>number_format</function>.)
       </simpara>
      </listitem>
      <listitem>
       <para>
	A <emphasis>type specifier</emphasis> that says what type the
	argument data should be treated as.  Possible types:
	<simplelist>
	 <member>
	  <literal>%</literal> - a literal percent character. No
	  argument is required.
	 </member>
	 <member>
	  <literal>b</literal> - the argument is treated as an
	  integer, and presented as a binary number.
	 </member>
	 <member>
	  <literal>c</literal> - the argument is treated as an
	  integer, and presented as the character with that ASCII
	  value.
	 </member>
	 <member>
	  <literal>d</literal> - the argument is treated as an
	  integer, and presented as a decimal number.
	 </member>
	 <member>
	  <literal>f</literal> - the argument is treated as a double,
	  and presented as a floating-point number.
	 </member>
	 <member>
	  <literal>o</literal> - the argument is treated as an
	  integer, and presented as an octal number.
	 </member>
	 <member>
	  <literal>s</literal> - the argument is treated as and
	  presented as a string.
	 </member>
	 <member>
	  <literal>x</literal> - the argument is treated as an integer
	  and presented as a hexadecimal number (with lowercase
	  letters).
	 </member>
	 <member>
	  <literal>X</literal> - the argument is treated as an integer
	  and presented as a hexadecimal number (with uppercase
	  letters).
	 </member>
	</simplelist>
       </para>
      </listitem>
     </orderedlist>
    </para>
    <simpara>
     See also: <function>printf</function>, <function>sscanf</function>,
	 <function>fscanf</function>, and <function>number_format</function>.
    </simpara>
   </refsect1>
   <refsect1>
    <title>Examples</title>
    <para>
     <example>
      <title><function>Sprintf</function>: zero-padded integers</title>
      <programlisting role="php">
$isodate = sprintf ("%04d-%02d-%02d", $year, $month, $day);
      </programlisting>
     </example>
     <example>
      <title><function>Sprintf</function>: formatting currency</title>
      <programlisting role="php">
$money1 = 68.75;
$money2 = 54.35;
$money = $money1 + $money2;
// echo $money will output "123.1";
$formatted = sprintf ("%01.2f", $money);
// echo $formatted will output "123.10"
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.strcasecmp">
   <refnamediv>
    <refname>strcasecmp</refname>
    <refpurpose>
     Binary safe case-insensitive string comparison
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>strcasecmp</function></funcdef>
      <paramdef>string <parameter>str1</parameter></paramdef>
      <paramdef>string <parameter>str2</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns &lt; 0 if <parameter>str1</parameter> is less than
     <parameter>str2</parameter>; &gt; 0 if <parameter>str1</parameter>
     is greater than <parameter>str2</parameter>, and 0 if they are
     equal.
    <example>
      <title><function>strcasecmp</function> example</title>
      <programlisting role="php">
$var1 = "Hello";
$var2 = "hello";
if (!strcasecmp ($var1, $var2)) {
    echo '$var1 is equal to $var2 in a case-insensitive string comparison';
}
      </programlisting>
    </example>
    </para>
    <simpara>
     See also <function>ereg</function>, <function>strcmp</function>,
     <function>substr</function>, <function>stristr</function>, and
     <function>strstr</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.strchr">
   <refnamediv>
    <refname>strchr</refname> 
    <refpurpose>
     Find the first occurrence of a character
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>strchr</function></funcdef>
      <paramdef>string <parameter>haystack</parameter></paramdef>
      <paramdef>string <parameter>needle</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     This function is an alias for <function>strstr</function>, and is
     identical in every way.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.strcmp">
   <refnamediv>
    <refname>strcmp</refname>
    <refpurpose>Binary safe string comparison</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>strcmp</function></funcdef>
      <paramdef>string <parameter>str1</parameter></paramdef>
      <paramdef>string <parameter>str2</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <simpara>
     Returns &lt; 0 if <parameter>str1</parameter> is less than
     <parameter>str2</parameter>; &gt; 0 if <parameter>str1</parameter>
     is greater than <parameter>str2</parameter>, and 0 if they are
     equal.
    </simpara>
    <simpara>
     Note that this comparison is case sensitive.
    </simpara>
    <simpara>
     See also <function>ereg</function>,
     <function>strcasecmp</function>, <function>substr</function>,
     <function>stristr</function>, <function>strncmp</function>,
	 and <function>strstr</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.strcspn">
   <refnamediv>
    <refname>strcspn</refname>
    <refpurpose>
     Find length of initial segment not matching mask
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>strcspn</function></funcdef>
      <paramdef>string <parameter>str1</parameter></paramdef>
      <paramdef>string <parameter>str2</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <simpara>
     Returns the length of the initial segment of
     <parameter>str1</parameter> which does <emphasis>not</emphasis>
     contain any of the characters in <parameter>str2</parameter>.
    </simpara>
    <simpara>
     See also <function>strspn</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.strip-tags">
   <refnamediv>
    <refname>strip_tags</refname>
    <refpurpose>Strip HTML and PHP tags from a string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>strip_tags</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
      <paramdef>string 
       <parameter><optional>allowable_tags</optional></parameter>
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     This function tries to strip all HTML and PHP tags from the given
     string.  It errors on the side of caution in case of incomplete
     or bogus tags.  It uses the same tag stripping state machine as
     the <function>fgetss</function> function.
    </para>
    <para>
     You can use the optional second parameter to specify tags which
     should not be stripped.
     <note>
      <para>
       <parameter>Allowable_tags</parameter> was added in PHP 3.0.13,
       PHP4B3.
      </para> 
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.stripcslashes">
   <refnamediv>
    <refname>stripcslashes</refname>
    <refpurpose>
     Un-quote string quoted with <function>addcslashes</function>
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>stripcslashes</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns a string with backslashes stripped off. Recognizes
     C-like <literal>\n</literal>, <literal>\r</literal> ..., octal
     and hexadecimal representation.
     <note>
      <simpara>
       Added in PHP4b3-dev.
      </simpara>
     </note>
    </para>
    <simpara>
     See also <function>addcslashes</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.stripslashes">
   <refnamediv>
    <refname>stripslashes</refname>
    <refpurpose>
     Un-quote string quoted with <function>addslashes</function>
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>stripslashes</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns a string with backslashes stripped off.
     (<literal>\'</literal> becomes <literal>'</literal> and so on.)
     Double backslashes are made into a single backslash.
    </para>
    <simpara>
     See also <function>addslashes</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.stristr">
   <refnamediv>
    <refname>stristr</refname>
    <refpurpose>
     Case-insensitive <function>strstr</function>
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>stristr</function></funcdef>
      <paramdef>string <parameter>haystack</parameter></paramdef>
      <paramdef>string <parameter>needle</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns all of <parameter>haystack</parameter> from the first
     occurrence of <parameter>needle</parameter> to the end.
     <parameter>needle</parameter> and <parameter>haystack</parameter>
     are examined in a case-insensitive manner.
    </para>
    <para>
     If <parameter>needle</parameter> is not found, returns false.
    </para>
    <para>
     If <parameter>needle</parameter> is not a string, it is converted
     to an integer and applied as the ordinal value of a character.
    </para>
    <para>
     See also <function>strchr</function>,
     <function>strrchr</function>, <function>substr</function>, and
     <function>ereg</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.strlen">
   <refnamediv>
    <refname>strlen</refname>
    <refpurpose>Get string length</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>strlen</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns the length of <parameter>string</parameter>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.strnatcmp">
   <refnamediv>
    <refname>strnatcmp</refname>
    <refpurpose>
	 String comparisons using a "natural order" algorithm
	</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>strnatcmp</function></funcdef>
      <paramdef>string <parameter>str1</parameter></paramdef>
      <paramdef>string <parameter>str2</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
	 This function implements a comparison algorithm that orders
	 alphanumeric strings in the way a human being would, this is
	 described as a "natural ordering".  An example of the difference
	 between this algorithm and the regular computer string sorting
	 algorithms (used in <function>strcmp</function>) can be seen
	 below:
	 <informalexample>
	  <programlisting>
$arr1 = $arr2 = array ("img12.png","img10.png","img2.png","img1.png");
echo "Standard string comparison\n";
usort($arr1,"strcmp");
print_r($arr1);
echo "\nNatural order string comparison\n";
usort($arr2,"strnatcmp");
print_r($arr2);
	  </programlisting>
	 </informalexample>
	 The code above will generate the following output:
	 <informalexample>
	  <programlisting>
Standard string comparison
Array
(
    [0] =&gt; img1.png
    [1] =&gt; img10.png
    [2] =&gt; img12.png
    [3] =&gt; img2.png
)

Natural order string comparison
Array
(
    [0] =&gt; img1.png
    [1] =&gt; img2.png
    [2] =&gt; img10.png
    [3] =&gt; img12.png
)
	  </programlisting>
	 </informalexample>
	 For more infomation see: Martin Pool's <ulink
	 url="&url.strnatcmp;">Natural Order String Comparison</ulink>
	 page.
	</para>
	<simpara>
	 Similar to other string comparison functions, this one returns
	 &lt; 0 if <parameter>str1</parameter> is less than
	 <parameter>str2</parameter>; &gt; 0 if <parameter>str1</parameter>
	 is greater than <parameter>str2</parameter>, and 0 if they are
	 equal.
    </simpara>
    <simpara>
     Note that this comparison is case sensitive.
    </simpara>
    <simpara>
     See also <function>ereg</function>,
     <function>strcasecmp</function>, <function>substr</function>,
     <function>stristr</function>, <function>strcmp</function>,
     <function>strncmp</function>, <function>strnatcasecmp</function>,
     <function>strstr</function>, <function>natsort</function> and
     <function>natcasesort</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.strnatcasecmp">
   <refnamediv>
    <refname>strnatcasecmp</refname>
    <refpurpose>
	 Case insensitive string comparisons using a "natural order" algorithm
	</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>strnatcasecmp</function></funcdef>
      <paramdef>string <parameter>str1</parameter></paramdef>
      <paramdef>string <parameter>str2</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
	 This function implements a comparison algorithm that orders
	 alphanumeric strings in the way a human being would.  The
	 behavior of this function is similar to
	 <function>strnatcmp</function>, except that the comparison is
	 not case sensitive.  For more infomation see: Martin Pool's
	 <ulink url="&url.strnatcmp;">Natural Order String
	 Comparison</ulink> page.
	</para>
	<simpara>
	 Similar to other string comparison functions, this one returns
	 &lt; 0 if <parameter>str1</parameter> is less than
	 <parameter>str2</parameter>; &gt; 0 if <parameter>str1</parameter>
	 is greater than <parameter>str2</parameter>, and 0 if they are
	 equal.
    </simpara>
    <simpara>
     See also <function>ereg</function>,
     <function>strcasecmp</function>, <function>substr</function>,
     <function>stristr</function>, <function>strcmp</function>,
     <function>strncmp</function>, <function>strnatcmp</function>,
	 and <function>strstr</function>.
    </simpara>
   </refsect1>
  </refentry>
 
  <refentry id="function.strncmp">
   <refnamediv>
    <refname>strncmp</refname>
    <refpurpose>
	 Binary safe string comparison of the first n characters
	</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>strncmp</function></funcdef>
      <paramdef>string <parameter>str1</parameter></paramdef>
      <paramdef>string <parameter>str2</parameter></paramdef>
      <paramdef>int <parameter>len</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
	 This function is similar to <function>strcmp</function>, with the
	 difference that you can specify the (upper limit of the) number of 
	 characters (<parameter>len</parameter>) from each string to be
	 used in the comparison. If any of the strings is shorter than
	 <parameter>len</parameter>, then the length of that string will be
	 used for the comparison.
	</para>
	<simpara>
     Returns &lt; 0 if <parameter>str1</parameter> is less than
     <parameter>str2</parameter>; &gt; 0 if <parameter>str1</parameter>
     is greater than <parameter>str2</parameter>, and 0 if they are
     equal.
    </simpara>
    <simpara>
     Note that this comparison is case sensitive.
    </simpara>
    <simpara>
     See also <function>ereg</function>,
     <function>strcasecmp</function>, <function>substr</function>,
     <function>stristr</function>, <function>strcmp</function>,
	 and <function>strstr</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.str-pad">
   <refnamediv>
    <refname>str_pad</refname>
    <refpurpose>Pad a string to a certain length with another string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>str_pad</function></funcdef>
      <paramdef>string <parameter>input</parameter></paramdef>
      <paramdef>int <parameter>pad_length</parameter></paramdef>
      <paramdef>string
       <parameter><optional>pad_string</optional></parameter></paramdef>
      <paramdef>int
       <parameter><optional>pad_type</optional></parameter>
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     This functions pads the <parameter>input</parameter> string on
     the left, the right, or both sides to the specifed padding
     length. If the optional argument
     <parameter>pad_string</parameter> is not supplied, the
     <parameter>input</parameter> is padded with spaces, otherwise it
     is padded with characters from <parameter>pad_string</parameter>
     up to the limit.
    </para>

    <para>
     Optional argument <parameter>pad_type</parameter> can be
     STR_PAD_RIGHT, STR_PAD_LEFT, or STR_PAD_BOTH.  If
     <parameter>pad_type</parameter> is not specified it is assumed to
     be STR_PAD_RIGHT.
    </para>
    
    <para>
      If the value of <parameter>pad_length</parameter> is negative or
      less than the length of the input string, no padding takes
      place.
    </para>

    <para>
     <example>
      <title><function>str_pad</function> example</title>
      <programlisting role="php">
$input = "Alien";
print str_pad($input, 10);                      // produces "Alien     "
print str_pad($input, 10, "-=", STR_PAD_LEFT);  // produces "-=-=-Alien"
print str_pad($input, 10, "_", STR_PAD_BOTH);   // produces "__Alien___"
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.strpos">
   <refnamediv>
    <refname>strpos</refname>
    <refpurpose>
     Find position of first occurrence of a string
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>strpos</function></funcdef>
      <paramdef>string <parameter>haystack</parameter></paramdef>
      <paramdef>string <parameter>needle</parameter></paramdef>
      <paramdef>int 
       <parameter><optional>offset</optional></parameter>
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns the numeric position of the first occurrence of
     <parameter>needle</parameter> in the
     <parameter>haystack</parameter> string.  Unlike the
     <function>strrpos</function>, this function can take a full
     string as the <parameter>needle</parameter> parameter and the
     entire string will be used.
    </para>
    <para>
     If <parameter>needle</parameter> is not found, returns false.
     <note>
      <para>
       It is easy to mistake the return values for "character found at
       position 0" and "character not found".  Here's how to detect
       the difference:
       <informalexample>
	<programlisting role="php">
// in PHP 4.0b3 and newer:
$pos = strpos ($mystring, "b");
if ($pos === false) { // note: three equal signs
    // not found...
}

// in versions older than 4.0b3:
$pos = strpos ($mystring, "b");
if (is_string ($pos) &amp;&amp; !$pos) {
    // not found...
}
	</programlisting>
       </informalexample>
      </para>
     </note>
    </para>
    <para>
     If <parameter>needle</parameter> is not a string, it is converted
     to an integer and applied as the ordinal value of a character.
    </para>
    <para>
     The optional <parameter>offset</parameter> parameter allows you
     to specify which character in <parameter>haystack</parameter> to
     start searching. The position returned is still relative to the
     the beginning of <parameter>haystack</parameter>.
    </para>
    <para>
     See also <function>strrpos</function>,
     <function>strrchr</function>, <function>substr</function>,
     <function>stristr</function>, and <function>strstr</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.strrchr">
   <refnamediv>
    <refname>strrchr</refname>
    <refpurpose>
     Find the last occurrence of a character in a string
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>strrchr</function></funcdef>
      <paramdef>string <parameter>haystack</parameter></paramdef>
      <paramdef>string <parameter>needle</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     This function returns the portion of
     <parameter>haystack</parameter> which starts at the last
     occurrence of <parameter>needle</parameter> and goes until the
     end of <parameter>haystack</parameter>.
    </para>
    <para>
     Returns false if <parameter>needle</parameter> is not found.
    </para>
    <para>
     If <parameter>needle</parameter> contains more than one
     character, the first is used.
    </para>
    <para>
     If <parameter>needle</parameter> is not a string, it is converted
     to an integer and applied as the ordinal value of a character.
     <example>
      <title><function>Strrchr</function> example</title>
      <programlisting role="php">
// get last directory in $PATH
$dir = substr (strrchr ($PATH, ":"), 1);

// get everything after last newline
$text = "Line 1\nLine 2\nLine 3";
$last = substr (strrchr ($text, 10), 1 );
      </programlisting>
     </example>
    </para>
    <para>
     See also <function>substr</function>,
     <function>stristr</function>, and <function>strstr</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.str-repeat">
   <refnamediv>
    <refname>str_repeat</refname>
    <refpurpose>Repeat a string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>str_repeat</function></funcdef>
      <paramdef>string <parameter>input</parameter></paramdef>
      <paramdef>int <parameter>multiplier</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns <parameter>input_str</parameter> repeated
     <parameter>multiplier</parameter> times.
     <parameter>multiplier</parameter> has to be greater than 0.
    </para>
    <example>
     <title><function>Str_repeat</function> example</title>
     <programlisting role="php">
echo str_repeat ("-=", 10);
     </programlisting>
    </example>
    <para>
     This will output "-=-=-=-=-=-=-=-=-=-=".
    </para>
    <note>
     <para>
      This function was added in PHP 4.0.
     </para> 
    </note>
   </refsect1>
  </refentry>

  <refentry id="function.strrev">
   <refnamediv>
    <refname>strrev</refname>
    <refpurpose>Reverse a string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>strrev</function></funcdef>
      <paramdef>string <parameter>string</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns <parameter>string</parameter>, reversed.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.strrpos">
   <refnamediv>
    <refname>strrpos</refname>
    <refpurpose>
     Find position of last occurrence of a char in a string
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>strrpos</function></funcdef>
      <paramdef>string <parameter>haystack</parameter></paramdef>
      <paramdef>char <parameter>needle</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns the numeric position of the last occurrence of
     <parameter>needle</parameter> in the
     <parameter>haystack</parameter> string.  Note that the needle in
     this case can only be a single character.  If a string is passed
     as the needle, then only the first character of that string will
     be used.
    </para>
    <para>
     If <parameter>needle</parameter> is not found, returns false.
    </para>
    <para>
     If <parameter>needle</parameter> is not a string, it is converted
     to an integer and applied as the ordinal value of a character.
    </para>
    <para>
     See also <function>strpos</function>,
     <function>strrchr</function>, <function>substr</function>,
     <function>stristr</function>, and <function>strstr</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.strspn">
   <refnamediv>
    <refname>strspn</refname>
    <refpurpose>
     Find length of initial segment matching mask
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>strspn</function></funcdef>
      <paramdef>string <parameter>str1</parameter></paramdef>
      <paramdef>string <parameter>str2</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <simpara>
     Returns the length of the initial segment of
     <parameter>str1</parameter> which consists entirely of characters
     in <parameter>str2</parameter>.
    </simpara>
    <para>         
     <informalexample>
      <programlisting role="php">
strspn ("42 is the answer, what is the question ...", "1234567890");
      </programlisting>
      <para>
       will return 2 as result. 
      </para>
     </informalexample>
    </para>
    <simpara>
     See also <function>strcspn</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.strstr">
   <refnamediv>
    <refname>strstr</refname>
    <refpurpose>Find first occurrence of a string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>strstr</function></funcdef>
      <paramdef>string <parameter>haystack</parameter></paramdef>
      <paramdef>string <parameter>needle</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns all of <parameter>haystack</parameter> from the first
     occurrence of <parameter>needle</parameter> to the end.
    </para>
    <para>
     If <parameter>needle</parameter> is not found, returns false.
    </para>
    <para>
     If <parameter>needle</parameter> is not a string, it is converted
     to an integer and applied as the ordinal value of a character.
    </para>
    <para>
     <note>
      <para>
       Note that this function is case-sensitive.  For
       case-insensitive searches, use <function>stristr</function>.
      </para>
     </note>
    </para>
    <para>
     <example>
      <title><function>Strstr</function> example</title>
      <programlisting role="php">
$email = 'sterling@designmultimedia.com';
$domain = strstr ($email, '@');
print $domain; // prints @designmultimedia.com
      </programlisting>
     </example> 
    </para>
    <para>
     See also <function>stristr</function>,
     <function>strrchr</function>, <function>substr</function>, and
     <function>ereg</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.strtok">
   <refnamediv>
    <refname>strtok</refname>
    <refpurpose>Tokenize string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>strtok</function></funcdef>
      <paramdef>string <parameter>arg1</parameter></paramdef>
      <paramdef>string <parameter>arg2</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     <function>strtok</function> is used to tokenize a string.  That
     is, if you have a string like "This is an example string" you
     could tokenize this string into its individual words by using the
     space character as the token.
     <example>
      <title><function>Strtok</function> example</title>
      <programlisting role="php">
$string = "This is an example string";
$tok = strtok ($string," ");
while ($tok) {
    echo "Word=$tok&lt;br>";
    $tok = strtok (" ");
}
      </programlisting>
     </example>
    </para>
    <para>
     Note that only the first call to strtok uses the string argument.
     Every subsequent call to strtok only needs the token to use, as
     it keeps track of where it is in the current string.  To start
     over, or to tokenize a new string you simply call strtok with the
     string argument again to initialize it.  Note that you may put
     multiple tokens in the token parameter.  The string will be
     tokenized when any one of the characters in the argument are
     found.
    </para>
    <para>
     Also be careful that your tokens may be equal to "0". This
     evaluates to false in conditional expressions.
    </para>
    <para>
     See also <function>split</function> and
     <function>explode</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.strtolower">
   <refnamediv>
    <refname>strtolower</refname>
    <refpurpose>Make a string lowercase</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>strtolower</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns <parameter>string</parameter> with all alphabetic
     characters converted to lowercase.
    </para>
    <para>
     Note that 'alphabetic' is determined by the current locale. This
     means that in i.e. the default "C" locale, characters such as
     umlaut-A (<28>) will not be converted.
    </para>
    <example>
     <title><function>Strtolower</function> example</title>
     <programlisting role="php">
$str = "Mary Had A Little Lamb and She LOVED It So";
$str = strtolower($str);	
print $str; # Prints mary had a little lamb and she loved it so
     </programlisting>
    </example>
    <para>
     See also <function>strtoupper</function>
     and <function>ucfirst</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.strtoupper">
   <refnamediv>
    <refname>strtoupper</refname>
    <refpurpose>Make a string uppercase</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>strtoupper</function></funcdef>
      <paramdef>string <parameter>string</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Returns <parameter>string</parameter> with all alphabetic
     characters converted to uppercase.
    </para>
    <para>
     Note that 'alphabetic' is determined by the current locale. For
     instance, in the default "C" locale characters such as umlaut-a
     (<28>) will not be converted.
    </para>
    <example>
     <title><function>Strtoupper</function> example</title>
     <programlisting role="php">
$str = "Mary Had A Little Lamb and She LOVED It So";
$str = strtoupper ($str);	
print $str; # Prints MARY HAD A LITTLE LAMB AND SHE LOVED IT SO
     </programlisting>
    </example>
    <para>
     See also <function>strtolower</function>
     and <function>ucfirst</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.str-replace">
   <refnamediv>
    <refname>str_replace</refname>
    <refpurpose>
     Replace all occurrences of needle in haystack with str
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>str_replace</function></funcdef>
      <paramdef>string <parameter>needle</parameter></paramdef>
      <paramdef>string <parameter>str</parameter></paramdef>
      <paramdef>string <parameter>haystack</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     This function replaces all occurences of
     <parameter>needle</parameter> in <parameter>haystack</parameter>
     with the given <parameter>str</parameter>. If you don't need
     fancy replacing rules, you should always use this function
     instead of <function>ereg_replace</function>.</para>
    <para>
     <example>
      <title><function>Str_replace</function> example</title>
      <programlisting role="php">
$bodytag = str_replace ("%body%", "black", "&lt;body text=%body%>");
      </programlisting>
     </example>
    </para>
    <para>
     This function is binary safe.
    </para>
    <note>
     <para>
      <function>Str_replace</function> was added in PHP 3.0.6, but was
      buggy up until PHP 3.0.8.
     </para>
    </note>
    <para>
     See also <function>ereg_replace</function> and
     <function>strtr</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.strtr">
   <refnamediv>
    <refname>strtr</refname>
    <refpurpose>Translate certain characters</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>strtr</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
      <paramdef>string <parameter>from</parameter></paramdef>
      <paramdef>string <parameter>to</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     This function operates on <parameter>str</parameter>, translating
     all occurrences of each character in <parameter>from</parameter>
     to the corresponding character in <parameter>to</parameter> and
     returning the result.
    </para>
    <para>
     If <parameter>from</parameter> and <parameter>to</parameter> are
     different lengths, the extra characters in the longer of the two
     are ignored.
     <example>
      <title><function>Strtr</function> example</title>
      <programlisting role="php">
$addr = strtr($addr, "<22><><EFBFBD>", "aao");
      </programlisting>
     </example>
    </para>
    <para>
     <function>strtr</function> can be called with only two
     arguments. If called with two arguments it behaves in a new way:
     <parameter>from</parameter> then has to be an array that contains
     string -> string pairs that will be replaced in the source
     string. <function>strtr</function> will always look for the
     longest possible match first and will *NOT* try to replace stuff
     that it has already worked on.
    </para>
    <para>
     Examples:
     <informalexample>
      <programlisting role="php">
$trans = array ("hello" =&gt; "hi", "hi" =&gt; "hello");
echo strtr("hi all, I said hello", $trans) . "\n";
      </programlisting>
     </informalexample>
     This will show: "hello all, I said hi",
    </para>
    <note>
     <simpara>
      This feature (two arguments) was added in PHP 4.0.
     </simpara>
    </note>
    <para>
     See also <function>ereg_replace</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.substr">
   <refnamediv>
    <refname>substr</refname>
    <refpurpose>Return part of a string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>substr</function></funcdef>
      <paramdef>string <parameter>string</parameter></paramdef>
      <paramdef>int <parameter>start</parameter></paramdef>
      <paramdef>int 
       <parameter><optional>length</optional></parameter>
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Substr returns the portion of <parameter>string</parameter>
     specified by the <parameter>start</parameter> and
     <parameter>length</parameter> parameters.
    </para>
    <para>
     If <parameter>start</parameter> is positive, the returned string
     will start at the <parameter>start</parameter>'th position in
     <parameter>string</parameter>, counting from zero. For instance,
     in the string '<literal>abcdef</literal>', the character at
     position <literal>0</literal> is '<literal>a</literal>', the
     character at position <literal>2</literal> is
     '<literal>c</literal>', and so forth.
    </para>
    <para>
     Examples:
     <informalexample>
      <programlisting role="php">
$rest = substr ("abcdef", 1);    // returns "bcdef"
$rest = substr ("abcdef", 1, 3); // returns "bcd"
      </programlisting>
     </informalexample>
    </para>
    <para>
     If <parameter>start</parameter> is negative, the returned string
     will start at the <parameter>start</parameter>'th character
     from the end of <parameter>string</parameter>.</para>  
    <para>
     Examples:
     <informalexample>
      <programlisting role="php">
$rest = substr ("abcdef", -1);    // returns "f"
$rest = substr ("abcdef", -2);    // returns "ef"
$rest = substr ("abcdef", -3, 1); // returns "d"
      </programlisting>
     </informalexample>
    </para>
    <para>
     If <parameter>length</parameter> is given and is positive, the
     string returned will end <parameter>length</parameter> characters
     from <parameter>start</parameter>. If this would result in a
     string with negative length (because the start is past the end of
     the string), then the returned string will contain the single
     character at <parameter>start</parameter>.
    </para>
    <para>
     If <parameter>length</parameter> is given and is negative, the
     string returned will end <parameter>length</parameter> characters
     from the end of <parameter>string</parameter>. If this would
     result in a string with negative length, then the returned string
     will contain the single character at
     <parameter>start</parameter>.
    </para>
    <para>
     Examples:
     <informalexample>
      <programlisting role="php">
$rest = substr ("abcdef", 1, -1); // returns "bcde"
      </programlisting>
     </informalexample>
    </para>
    <para>
     See also <function>strrchr</function> and
     <function>ereg</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.substr-count">
   <refnamediv>
    <refname>substr_count</refname>
    <refpurpose>Count the number of substring occurrences</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>int <function>substr_count</function></funcdef>
      <paramdef>string <parameter>haystrack</parameter></paramdef>
      <paramdef>string <parameter>needle</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     <function>substr_count</function> returns the number of times the
     <parameter>needle</parameter> substring occurs in the
     <parameter>haystack</parameter> string.
    </para>

    <para>
     <example>
      <title><function>substr_count</function> example</title>
      <programlisting>
print substr_count("This is a test", "is"); // prints out 2
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>
  
  <refentry id="function.substr-replace">
   <refnamediv>
    <refname>substr_replace</refname>
    <refpurpose>Replace text within a portion of a string</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>substr_replace</function></funcdef>
      <paramdef>string <parameter>string</parameter></paramdef>
      <paramdef>string <parameter>replacement</parameter></paramdef>
      <paramdef>int <parameter>start</parameter></paramdef>
      <paramdef>int 
       <parameter><optional>length</optional></parameter>
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     <function>substr_replace</function> replaces the part of
     <parameter>string</parameter> delimited by the
     <parameter>start</parameter> and (optionally)
     <parameter>length</parameter> parameters with the string given in
     <parameter>replacement</parameter>. The result is returned.
    </para>
    <para>
     If <parameter>start</parameter> is positive, the replacing will
     begin at the <parameter>start</parameter>'th offset into
     <parameter>string</parameter>.  
    </para>
    <para>
     If <parameter>start</parameter> is negative, the replacing will
     begin at the <parameter>start</parameter>'th character from the
     end of <parameter>string</parameter>.  
    </para>
    <para>
     If <parameter>length</parameter> is given and is positive, it
     represents the length of the portion of
     <parameter>string</parameter> which is to be replaced. If it is
     negative, it represents the number of characters from the end of
     <parameter>string</parameter> at which to stop replacing. If it
     is not given, then it will default to strlen(
     <parameter>string</parameter> ); i.e. end the replacing at the
     end of <parameter>string</parameter>.
    </para>
    <para>
     <example>
      <title><function>Substr_replace</function> example</title>
      <programlisting role="php">
&lt;?php
$var = 'ABCDEFGH:/MNRPQR/';
echo "Original: $var&lt;hr&gt;\n";

/* These two examples replace all of $var with 'bob'. */
echo substr_replace ($var, 'bob', 0) . "&lt;br&gt;\n";
echo substr_replace ($var, 'bob', 0, strlen ($var)) . "&lt;br&gt;\n";

/* Insert 'bob' right at the beginning of $var. */
echo substr_replace ($var, 'bob', 0, 0) . "&lt;br&gt;\n";

/* These next two replace 'MNRPQR' in $var with 'bob'. */
echo substr_replace ($var, 'bob', 10, -1) . "&lt;br&gt;\n";
echo substr_replace ($var, 'bob', -7, -1) . "&lt;br&gt;\n";

/* Delete 'MNRPQR' from $var. */
echo substr_replace ($var, '', 10, -1) . "&lt;br&gt;\n";
?&gt;
      </programlisting>
     </example>
    </para>
    <para>
     See also <function>str_replace</function> and
     <function>substr</function>.
    </para>
    <note>
     <simpara>
      <function>Substr_replace</function> was added in PHP 4.0.
     </simpara>
    </note>
   </refsect1>
  </refentry>

  <refentry id="function.trim">
   <refnamediv>
    <refname>trim</refname> 
    <refpurpose>
     Strip whitespace from the beginning and end of a string
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>trim</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     This function strips whitespace from the start and the end of a
     string and returns the stripped string.  The whitespace
     characters it currently strips are: "\n", "\r", "\t", "\v", "\0",
     and a plain space.
    </para>
    <para>
     See also <function>chop</function> and
     <function>ltrim</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.ucfirst">
   <refnamediv>
    <refname>ucfirst</refname> 
    <refpurpose>Make a string's first character uppercase</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>ucfirst</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Capitalizes the first character of <parameter>str</parameter> if
     that character is alphabetic.
    </para>
    <para>
     Note that 'alphabetic' is determined by the current locale. For
     instance, in the default "C" locale characters such as umlaut-a
     (<28>) will not be converted.
     <example>
      <title><function>Ucfirst</function> example</title>
      <programlisting role="php">    
$text = 'mary had a little lamb and she loved it so.';
$text = ucfirst ($text); // $text is now Mary had a little lamb 
                         // and she loved it so.
      </programlisting>
     </example>
    </para>
    <para>
     See also <function>strtoupper</function> and
     <function>strtolower</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.ucwords">
   <refnamediv>
    <refname>ucwords</refname> 
    <refpurpose>
     Uppercase the first character of each word in a string
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>ucwords</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Capitalizes the first character of each word in
     <parameter>str</parameter> if that character is alphabetic.
     <example>
      <title><function>ucwords</function> example</title>
      <programlisting role="php">
$text = "mary had a little lamb and she loved it so.";
$text = ucwords($text); // $text is now: Mary Had A Little 
                        // Lamb And She Loved It So.
      </programlisting>
     </example>
    </para>
    <para>
     See also <function>strtoupper</function>,
     <function>strtolower</function> and <function>ucfirst</function>.
    </para>
   </refsect1>
  </refentry>


  <refentry id="function.wordwrap">
   <refnamediv>
    <refname>wordwrap</refname>
    <refpurpose>
     Wraps a string to a given number of characters using a string
     break character.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
    <funcsynopsis>
     <funcprototype>
      <funcdef>string <function>wordwrap</function></funcdef>
      <paramdef>string <parameter>str</parameter></paramdef>
      <paramdef>int
       <parameter><optional>width</optional></parameter>
      </paramdef>
      <paramdef>string
       <parameter><optional>break</optional></parameter>
      </paramdef>
     </funcprototype>
    </funcsynopsis>
    <para>
     Wraps the string <parameter>str</parameter> at the column number
     specified by the (optional) <parameter>width</parameter>
     parameter.  The line is broken using the (optional)
     <parameter>break</parameter> parameter.
    </para>
    <para>
     <function>wordwrap</function> will automatically wrap at column
     75 and break using '\n' (newline) if <parameter>width</parameter>
     or <parameter>break</parameter> are not given.
    </para>
    <para>
     <example>
      <title><function>wordwrap</function> example</title>
      <programlisting role="php">
$text = "The quick brown fox jumped over the lazy dog.";
$newtext = wordwrap( $text, 20 );

echo "$newtext\n";
      </programlisting>
     </example>
    </para>
    <para>
     This example would display:
    </para>
    <para>
     <informalexample>
      <programlisting>
The quick brown fox
 jumped over the lazy dog.
      </programlisting>
     </informalexample>
    </para>
    <para>
     See also <function>nl2br</function>.
    </para>
   </refsect1>
  </refentry>


 </reference>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
sgml-parent-document:nil
sgml-default-dtd-file:"../../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
-->