* Can be used with other directory functions such as * readdir(), rewinddir() and * closedir(). *

* The constant name. *

* A string. *

* Hexadecimal representation of data. *

* Halt time in seconds. *

* If the call was interrupted by a signal, sleep returns * a non-zero value. On Windows, this value will always be * 192 (the value of the * WAIT_IO_COMPLETION constant within the Windows API). * On other platforms, the return value will be the number of seconds left to * sleep. */ function sleep ($seconds) {} /** * (PHP 4, PHP 5)
* Delay execution in microseconds * @link http://php.net/manual/en/function.usleep.php * @param int $micro_seconds

* Halt time in micro seconds. A micro second is one millionth of a * second. *

* Must be a non-negative integer. *

* Must be a non-negative integer less than 1 billion. *

* If the delay was interrupted by a signal, an associative array will be * returned with the components: * seconds - number of seconds remaining in * the delay * nanoseconds - number of nanoseconds * remaining in the delay */ function time_nanosleep ($seconds, $nanoseconds) {} /** * (PHP 5 >= 5.1.0)
* Make the script sleep until the specified time * @link http://php.net/manual/en/function.time-sleep-until.php * @param float $timestamp

* The timestamp when the script should wake. *

* The string to parse (e.g. returned from strftime). *

* The format used in date (e.g. the same as * used in strftime). Note that some of the format * options available to strftime may not have any * effect within strptime; the exact subset that are * supported will vary based on the operating system and C library in * use. *

* For more information about the format options, read the * strftime page. *

* * The following parameters are returned in the array * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

parameters	Description
"tm_sec"	Seconds after the minute (0-61)
"tm_min"	Minutes after the hour (0-59)
"tm_hour"	Hour since midnight (0-23)
"tm_mday"	Day of the month (1-31)
"tm_mon"	Months since January (0-11)
"tm_year"	Years since 1900
"tm_wday"	Days since Sunday (0-6)
"tm_yday"	Days since January 1 (0-365)
"unparsed"	the date part which was not * recognized using the specified format

*/ function strptime ($date, $format) {} /** * (PHP 4, PHP 5)
* Flush the output buffer * @link http://php.net/manual/en/function.flush.php * @return void No value is returned. */ function flush () {} /** * (PHP 4 >= 4.0.2, PHP 5)
* Wraps a string to a given number of characters * @link http://php.net/manual/en/function.wordwrap.php * @param string $str

* The input string. *

* The number of characters at which the string will be wrapped. *

* The line is broken using the optional * break parameter. *

* If the cut is set to TRUE, the string is * always wrapped at or before the specified width. So if you have * a word that is larger than the given width, it is broken apart. * (See second example). *

* The string being converted. *

* A bitmask of one or more of the following flags, which specify how to handle quotes, * invalid code unit sequences and the used document type. The default is * ENT_COMPAT | ENT_HTML401. * * Available flags constants * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Constant Name	Description
ENT_COMPAT	Will convert double-quotes and leave single-quotes alone.
ENT_QUOTES	Will convert both double and single quotes.
ENT_NOQUOTES	Will leave both double and single quotes unconverted.
ENT_IGNORE	* Silently discard invalid code unit sequences instead of returning * an empty string. Using this flag is discouraged as it * may have security implications. *
ENT_SUBSTITUTE	* Replace invalid code unit sequences with a Unicode Replacement Character * U+FFFD (UTF-8) or &#FFFD; (otherwise) instead of returning an empty string. *
ENT_DISALLOWED	* Replace invalid code points for the given document type with a * Unicode Replacement Character U+FFFD (UTF-8) or &#FFFD; * (otherwise) instead of leaving them as is. This may be useful, for * instance, to ensure the well-formedness of XML documents with * embedded external content. *
ENT_HTML401	* Handle code as HTML 4.01. *
ENT_XML1	* Handle code as XML 1. *
ENT_XHTML	* Handle code as XHTML. *
ENT_HTML5	* Handle code as HTML 5. *

*

* Defines encoding used in conversion. * If omitted, the default value for this argument is ISO-8859-1 in * versions of PHP prior to 5.4.0, and UTF-8 from PHP 5.4.0 onwards. *

* For the purposes of this function, the encodings * ISO-8859-1, ISO-8859-15, * UTF-8, cp866, * cp1251, cp1252, and * KOI8-R are effectively equivalent, provided the * string itself is valid for the encoding, as * the characters affected by htmlspecialchars occupy * the same positions in all of these encodings. *

* When double_encode is turned off PHP will not * encode existing html entities, the default is to convert everything. *

* If the input string contains an invalid code unit * sequence within the given encoding an empty string * will be returned, unless either the ENT_IGNORE or * ENT_SUBSTITUTE flags are set. */ function htmlspecialchars ($string, $flags = 'ENT_COMPAT | ENT_HTML401', $encoding = 'UTF-8', $double_encode = true) {} /** * (PHP 4, PHP 5)
* Convert all applicable characters to HTML entities * @link http://php.net/manual/en/function.htmlentities.php * @param string $string

* The input string. *

* A bitmask of one or more of the following flags, which specify how to handle quotes, * invalid code unit sequences and the used document type. The default is * ENT_COMPAT | ENT_HTML401. * * Available flags constants * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Constant Name	Description
ENT_COMPAT	Will convert double-quotes and leave single-quotes alone.
ENT_QUOTES	Will convert both double and single quotes.
ENT_NOQUOTES	Will leave both double and single quotes unconverted.
ENT_IGNORE	* Silently discard invalid code unit sequences instead of returning * an empty string. Using this flag is discouraged as it * may have security implications. *
ENT_SUBSTITUTE	* Replace invalid code unit sequences with a Unicode Replacement Character * U+FFFD (UTF-8) or &#FFFD; (otherwise) instead of returning an empty string. *
ENT_DISALLOWED	* Replace invalid code points for the given document type with a * Unicode Replacement Character U+FFFD (UTF-8) or &#FFFD; * (otherwise) instead of leaving them as is. This may be useful, for * instance, to ensure the well-formedness of XML documents with * embedded external content. *
ENT_HTML401	* Handle code as HTML 4.01. *
ENT_XML1	* Handle code as XML 1. *
ENT_XHTML	* Handle code as XHTML. *
ENT_HTML5	* Handle code as HTML 5. *

*

* Like htmlspecialchars, * htmlentities takes an optional third argument * encoding which defines encoding used in * conversion. * If omitted, the default value for this argument is ISO-8859-1 in * versions of PHP prior to 5.4.0, and UTF-8 from PHP 5.4.0 onwards. * Although this argument is technically optional, you are highly * encouraged to specify the correct value for your code. *

* When double_encode is turned off PHP will not * encode existing html entities. The default is to convert everything. *

* If the input string contains an invalid code unit * sequence within the given encoding an empty string * will be returned, unless either the ENT_IGNORE or * ENT_SUBSTITUTE flags are set. */ function htmlentities ($string, $flags = 'ENT_COMPAT | ENT_HTML401', $encoding = 'UTF-8', $double_encode = true) {} /** * (PHP 4 >= 4.3.0, PHP 5)
* Convert all HTML entities to their applicable characters * @link http://php.net/manual/en/function.html-entity-decode.php * @param string $string

* The input string. *

* A bitmask of one or more of the following flags, which specify how to handle quotes and * which document type to use. The default is ENT_COMPAT | ENT_HTML401. * * Available flags constants * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Constant Name	Description
ENT_COMPAT	Will convert double-quotes and leave single-quotes alone.
ENT_QUOTES	Will convert both double and single quotes.
ENT_NOQUOTES	Will leave both double and single quotes unconverted.
ENT_HTML401	* Handle code as HTML 4.01. *
ENT_XML1	* Handle code as XML 1. *
ENT_XHTML	* Handle code as XHTML. *
ENT_HTML5	* Handle code as HTML 5. *

*

* Encoding to use. * If omitted, the default value for this argument is ISO-8859-1 in * versions of PHP prior to 5.4.0, and UTF-8 from PHP 5.4.0 onwards. *

* The string to decode. *

* A bitmask of one or more of the following flags, which specify how to handle quotes and * which document type to use. The default is ENT_COMPAT | ENT_HTML401. * * Available flags constants * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Constant Name	Description
ENT_COMPAT	Will convert double-quotes and leave single-quotes alone.
ENT_QUOTES	Will convert both double and single quotes.
ENT_NOQUOTES	Will leave both double and single quotes unconverted.
ENT_HTML401	* Handle code as HTML 4.01. *
ENT_XML1	* Handle code as XML 1. *
ENT_XHTML	* Handle code as XHTML. *
ENT_HTML5	* Handle code as HTML 5. *

*

* Which table to return. Either HTML_ENTITIES or * HTML_SPECIALCHARS. *

* A bitmask of one or more of the following flags, which specify which quotes the * table will contain as well as which document type the table is for. The default is * ENT_COMPAT | ENT_HTML401. * * Available flags constants * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Constant Name	Description
ENT_COMPAT	Table will contain entities for double-quotes, but not for single-quotes.
ENT_QUOTES	Table will contain entities for both double and single quotes.
ENT_NOQUOTES	Table will neither contain entities for single quotes nor for double quotes.
ENT_HTML401	Table for HTML 4.01.
ENT_XML1	Table for XML 1.
ENT_XHTML	Table for XHTML.
ENT_HTML5	Table for HTML 5.

*

* Encoding to use. * If omitted, the default value for this argument is ISO-8859-1 in * versions of PHP prior to 5.4.0, and UTF-8 from PHP 5.4.0 onwards. *

* The input string. *

* If the optional raw_output is set to TRUE, * then the sha1 digest is instead returned in raw binary format with a * length of 20, otherwise the returned value is a 40-character * hexadecimal number. *

* The filename of the file to hash. *

* When TRUE, returns the digest in raw binary format with a length of * 20. *

* The string. *

* If the optional raw_output is set to TRUE, * then the md5 digest is instead returned in raw binary format with a * length of 16. *

* The filename *

* When TRUE, returns the digest in raw binary format with a length of * 16. *

* The data. *

* A binary IPTC block. *

* The data to be written. *

* Path to the JPEG image. *

* Spool flag. If the spool flag is over 2 then the JPEG will be * returned as a string. *

* This parameter specifies the file you wish to retrieve information * about. It can reference a local file or (configuration permitting) a * remote file using one of the supported streams. *

* This optional parameter allows you to extract some extended * information from the image file. Currently, this will return the * different JPG APP markers as an associative array. * Some programs use these APP markers to embed text information in * images. A very common one is to embed * IPTC information in the APP13 marker. * You can use the iptcparse function to parse the * binary APP13 marker into something readable. *

* Index 0 and 1 contains respectively the width and the height of the image. *

* Some formats may contain no image or may contain multiple images. In these * cases, getimagesize might not be able to properly * determine the image size. getimagesize will return * zero for width and height in these cases. *

* Index 2 is one of the IMAGETYPE_XXX constants indicating * the type of the image. *

* Index 3 is a text string with the correct * height="yyy" width="xxx" string that can be used * directly in an IMG tag. *

* mime is the correspondant MIME type of the image. * This information can be used to deliver images with the correct HTTP * Content-type header: * getimagesize and MIME types * * $size = getimagesize($filename); * $fp = fopen($filename, "rb"); * if ($size && $fp) { * header("Content-type: {$size['mime']}"); * fpassthru($fp); * exit; * } else { * // error * } * *

* channels will be 3 for RGB pictures and 4 for CMYK * pictures. *

* bits is the number of bits for each color. *

* For some image types, the presence of channels and * bits values can be a bit * confusing. As an example, GIF always uses 3 channels * per pixel, but the number of bits per pixel cannot be calculated for an * animated GIF with a global color table. *

* On failure, FALSE is returned. */ function getimagesize ($filename, array &$imageinfo = null) {} /** * (PHP 5 >= 5.4.0)
* Get the size of an image from a string * @link http://php.net/manual/en/function.getimagesizefromstring.php * @param string $imagedata

* The image data, as a string. *

* See getimagesize. *

* One of the IMAGETYPE_XXX constants. *

* One of the IMAGETYPE_XXX constant. *

* Whether to prepend a dot to the extension or not. Default to TRUE. *

* The output may be customized by passing one or more of the * following constants bitwise values summed * together in the optional what parameter. * One can also combine the respective constants or bitwise values * together with the or operator. *

* * phpinfo options * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Name (constant)	Value	Description
INFO_GENERAL	1	* The configuration line, php.ini location, build date, Web * Server, System and more. *
INFO_CREDITS	2	* PHP Credits. See also phpcredits. *
INFO_CONFIGURATION	4	* Current Local and Master values for PHP directives. See * also ini_get. *
INFO_MODULES	8	* Loaded modules and their respective settings. See also * get_loaded_extensions. *
INFO_ENVIRONMENT	16	* Environment Variable information that's also available in * $_ENV. *
INFO_VARIABLES	32	* Shows all * predefined variables from EGPCS (Environment, GET, * POST, Cookie, Server). *
INFO_LICENSE	64	* PHP License information. See also the license FAQ. *
INFO_ALL	-1	* Shows all of the above. *

*

* An optional extension name. *

* To generate a custom credits page, you may want to use the * flag parameter. *

* * Pre-defined phpcredits flags * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

name	description
CREDITS_ALL	* All the credits, equivalent to using: CREDITS_DOCS + * CREDITS_GENERAL + CREDITS_GROUP + * CREDITS_MODULES + CREDITS_FULLPAGE. * It generates a complete stand-alone HTML page with the appropriate tags. *
CREDITS_DOCS	The credits for the documentation team
CREDITS_FULLPAGE	* Usually used in combination with the other flags. Indicates * that a complete stand-alone HTML page needs to be * printed including the information indicated by the other * flags. *
CREDITS_GENERAL	* General credits: Language design and concept, PHP authors * and SAPI module. *
CREDITS_GROUP	A list of the core developers
CREDITS_MODULES	* A list of the extension modules for PHP, and their authors *
CREDITS_SAPI	* A list of the server API modules for PHP, and their authors *

*

* Although not exhaustive, the possible return values include * aolserver, apache, * apache2filter, apache2handler, * caudium, cgi (until PHP 5.3), * cgi-fcgi, cli, * continuity, embed, * isapi, litespeed, * milter, nsapi, * phttpd, pi3web, roxen, * thttpd, tux, and webjames. */ function php_sapi_name () {} /** * (PHP 4 >= 4.0.2, PHP 5)
* Returns information about the operating system PHP is running on * @link http://php.net/manual/en/function.php-uname.php * @param string $mode [optional]

* mode is a single character that defines what * information is returned: * 'a': This is the default. Contains all modes in * the sequence "s n r v m". * @return string the description, as a string. */ function php_uname ($mode = "a") {} /** * (PHP 4 >= 4.3.0, PHP 5)
* Return a list of .ini files parsed from the additional ini dir * @link http://php.net/manual/en/function.php-ini-scanned-files.php * @return string a comma-separated string of .ini files on success. Each comma is * followed by a newline. If the directive --with-config-file-scan-dir wasn't set, * FALSE is returned. If it was set and the directory was empty, an * empty string is returned. If a file is unrecognizable, the file will * still make it into the returned string but a PHP error will also result. * This PHP error will be seen both at compile time and while using * php_ini_scanned_files. */ function php_ini_scanned_files () {} /** * (PHP 5 >= 5.2.4)
* Retrieve a path to the loaded php.ini file * @link http://php.net/manual/en/function.php-ini-loaded-file.php * @return string The loaded php.ini path, or FALSE if one is not loaded. */ function php_ini_loaded_file () {} /** * (PHP 4, PHP 5)
* String comparisons using a "natural order" algorithm * @link http://php.net/manual/en/function.strnatcmp.php * @param string $str1

* The first string. *

* The second string. *

* The first string. *

* The second string. *

* The string to search in *

* The substring to search for *

* The offset where to start counting *

* The maximum length after the specified offset to search for the * substring. It outputs a warning if the offset plus the length is * greater than the haystack length. *

* The string to examine. *

* The list of allowable characters. *

* The position in subject to * start searching. *

* If start is given and is non-negative, * then strspn will begin * examining subject at * the start'th position. For instance, in * the string 'abcdef', the character at * position 0 is 'a', the * character at position 2 is * 'c', and so forth. *

* If start is given and is negative, * then strspn will begin * examining subject at * the start'th position from the end * of subject. *

* The length of the segment from subject * to examine. *

* If length is given and is non-negative, * then subject will be examined * for length characters after the starting * position. *

* If lengthis given and is negative, * then subject will be examined from the * starting position up to length * characters from the end of subject. *

* The first string. *

* The second string. *

* The start position of the string to examine. *

* The length of the string to examine. *

* The string being split up into smaller strings (tokens). *

* The delimiter used when splitting up str. *

* The input string. *

* The input string. *

* The string to search in. *

* If needle is not a string, it is converted * to an integer and applied as the ordinal value of a character. *

* If specified, search will start this number of characters counted from * the beginning of the string. Unlike strrpos and * strripos, the offset cannot be negative. *

* Returns FALSE if the needle was not found. */ function strpos ($haystack, $needle, $offset = 0) {} /** * (PHP 5)
* Find the position of the first occurrence of a case-insensitive substring in a string * @link http://php.net/manual/en/function.stripos.php * @param string $haystack

* The string to search in. *

* Note that the needle may be a string of one or * more characters. *

* If needle is not a string, it is converted to * an integer and applied as the ordinal value of a character. *

* If specified, search will start this number of characters counted from * the beginning of the string. Unlike strrpos and * strripos, the offset cannot be negative. *

* Returns FALSE if the needle was not found. */ function stripos ($haystack, $needle, $offset = 0) {} /** * (PHP 4, PHP 5)
* Find the position of the last occurrence of a substring in a string * @link http://php.net/manual/en/function.strrpos.php * @param string $haystack

* The string to search in. *

* If needle is not a string, it is converted * to an integer and applied as the ordinal value of a character. *

* If specified, search will start this number of characters counted from the * beginning of the string. If the value is negative, search will instead start * from that many characters from the end of the string, searching backwards. *

* Returns FALSE if the needle was not found. */ function strrpos ($haystack, $needle, $offset = 0) {} /** * (PHP 5)
* Find the position of the last occurrence of a case-insensitive substring in a string * @link http://php.net/manual/en/function.strripos.php * @param string $haystack

* The string to search in. *

* If needle is not a string, it is converted * to an integer and applied as the ordinal value of a character. *

* If specified, search will start this number of characters counted from the * beginning of the string. If the value is negative, search will instead start * from that many characters from the end of the string, searching backwards. *

* Returns FALSE if the needle was not found. */ function strripos ($haystack, $needle, $offset = 0) {} /** * (PHP 4, PHP 5)
* Reverse a string * @link http://php.net/manual/en/function.strrev.php * @param string $string

* The string to be reversed. *

* A Hebrew input string. *

* This optional parameter indicates maximum number of characters per * line that will be returned. *

* A Hebrew input string. *

* This optional parameter indicates maximum number of characters per * line that will be returned. *

* The input string. *

* Whether to use XHTML compatible line breaks or not. *

* A path. *

* On Windows, both slash (/) and backslash * (\) are used as directory separator character. In * other environments, it is the forward slash (/). *

* If the name component ends in suffix this will also * be cut off. *

* A path. *

* On Windows, both slash (/) and backslash * (\) are used as directory separator character. In * other environments, it is the forward slash (/). *

* The path to be parsed. *

* If present, specifies a specific element to be returned; one of * PATHINFO_DIRNAME, * PATHINFO_BASENAME, * PATHINFO_EXTENSION or * PATHINFO_FILENAME. *

If options is not specified, returns all * available elements. *

* If the path does not have an extension, no * extension element will be returned * (see second example below). *

* If options is present, returns a * string containing the requested element. */ function pathinfo ($path, $options = 'PATHINFO_DIRNAME | PATHINFO_BASENAME | PATHINFO_EXTENSION | PATHINFO_FILENAME') {} /** * (PHP 4, PHP 5)
* Un-quotes a quoted string * @link http://php.net/manual/en/function.stripslashes.php * @param string $str

* The input string. *

* The string to be unescaped. *

* The input string. *

* If needle is not a string, it is converted to * an integer and applied as the ordinal value of a character. *

* If TRUE, strstr returns * the part of the haystack before the first * occurrence of the needle (excluding the needle). *

* The string to search in *

* If needle is not a string, it is converted to * an integer and applied as the ordinal value of a character. *

* If TRUE, stristr * returns the part of the haystack before the * first occurrence of the needle (excluding needle). *

* The string to search in *

* If needle contains more than one character, * only the first is used. This behavior is different from that of * strstr. *

* If needle is not a string, it is converted to * an integer and applied as the ordinal value of a character. *

* The input string. *

* The string *

* Specify the return value of this function. The current supported values * are: * 0 - returns the number of words found * @param string $charlist [optional]

* A list of additional characters which will be considered as 'word' *

* The input string. *

* Maximum length of the chunk. *

* FALSE is returned if split_length is less than 1. * If the split_length length exceeds the length of * string, the entire string is returned as the first * (and only) array element. */ function str_split ($string, $split_length = 1) {} /** * (PHP 5)
* Search a string for any of a set of characters * @link http://php.net/manual/en/function.strpbrk.php * @param string $haystack

* The string where char_list is looked for. *

* This parameter is case sensitive. *

* The main string being compared. *

* The secondary string being compared. *

* The start position for the comparison. If negative, it starts counting * from the end of the string. *

* The length of the comparison. The default value is the largest of the * length of the str compared to the length of * main_str less the * offset. *

* If case_insensitivity is TRUE, comparison is * case insensitive. *

* The first string. *

* The second string. *

* The format specification consists of the following sequence: *

a % character

* The number to be formatted. *

* The input string. Must be one character or longer. *

* If start is non-negative, the returned string * will start at the start'th position in * string, counting from zero. For instance, * in the string 'abcdef', the character at * position 0 is 'a', the * character at position 2 is * 'c', and so forth. *

* If start is negative, the returned string * will start at the start'th character * from the end of string. *

* If string is less than or equal to * start characters long, FALSE will be returned. *

* Using a negative start * * $rest = substr("abcdef", -1); // returns "f" * $rest = substr("abcdef", -2); // returns "ef" * $rest = substr("abcdef", -3, 1); // returns "d" * *

* If length is given and is positive, the string * returned will contain at most length characters * beginning from start (depending on the length of * string). *

* If length is given and is negative, then that many * characters will be omitted from the end of string * (after the start position has been calculated when a * start is negative). If * start denotes the position of this truncation or * beyond, false will be returned. *

* If length is given and is 0, * FALSE or NULL an empty string will be returned. *

* If length is omitted, the substring starting from * start until the end of the string will be * returned. *

* The input string. *

* An array of strings can be provided, in which * case the replacements will occur on each string in turn. In this case, * the replacement, start * and length parameters may be provided either as * scalar values to be applied to each input string in turn, or as * arrays, in which case the corresponding array element will * be used for each input string. *

* The replacement string. *

* If start is positive, the replacing will * begin at the start'th offset into * string. *

* If start is negative, the replacing will * begin at the start'th character from the * end of string. *

* If given and is positive, it represents the length of the portion of * string which is to be replaced. If it is * negative, it represents the number of characters from the end of * string at which to stop replacing. If it * is not given, then it will default to strlen( * string ); i.e. end the replacing at the * end of string. Of course, if * length is zero then this function will have the * effect of inserting replacement into * string at the given * start offset. *

* The input string. *

* The input string. *

* The input string. *

* The input string. *

* The string being translated. *

* The string being translated to to. *

* The string replacing from. *

* If replace_pairs contains a key which * is an empty string (""), * FALSE will be returned. */ function strtr ($str, $from, $to) {} /** * (PHP 4, PHP 5)
* Quote string with slashes * @link http://php.net/manual/en/function.addslashes.php * @param string $str

* The string to be escaped. *

* The string to be escaped. *

* A list of characters to be escaped. If * charlist contains characters * \n, \r etc., they are * converted in C-like style, while other non-alphanumeric characters * with ASCII codes lower than 32 and higher than 126 converted to * octal representation. *

* When you define a sequence of characters in the charlist argument * make sure that you know what characters come between the * characters that you set as the start and end of the range. * * echo addcslashes('foo[ ]', 'A..z'); * // output: \f\o\o\[ \] * // All upper and lower-case letters will be escaped * // ... but so will the [\]^_` * * Also, if the first character in a range has a higher ASCII value * than the second character in the range, no range will be * constructed. Only the start, end and period characters will be * escaped. Use the ord function to find the * ASCII value for a character. * * echo addcslashes("zoo['.']", 'z..A'); * // output: \zoo['\.'] * *

* Be careful if you choose to escape characters 0, a, b, f, n, r, * t and v. They will be converted to \0, \a, \b, \f, \n, \r, \t * and \v. * In PHP \0 (NULL), \r (carriage return), \n (newline), \f (form feed), * \v (vertical tab) and \t (tab) are predefined escape sequences, * while in C all of these are predefined escape sequences. *

* The input string. *

* You can also specify the characters you want to strip, by means * of the charlist parameter. * Simply list all characters that you want to be stripped. With * .. you can specify a range of characters. *

* The value being searched for, otherwise known as the needle. * An array may be used to designate multiple needles. *

* The replacement value that replaces found search * values. An array may be used to designate multiple replacements. *

* The string or array being searched and replaced on, * otherwise known as the haystack. *

* If subject is an array, then the search and * replace is performed with every entry of * subject, and the return value is an array as * well. *

* If passed, this will be set to the number of replacements performed. *

* The value being searched for, otherwise known as the * needle. An array may be used to designate * multiple needles. *

* The replacement value that replaces found search * values. An array may be used to designate multiple replacements. *

* The string or array being searched and replaced on, * otherwise known as the haystack. *

* If subject is an array, then the search and * replace is performed with every entry of * subject, and the return value is an array as * well. *

* If passed, this will be set to the number of replacements performed. *

* The string to be repeated. *

* Number of time the input string should be * repeated. *

* multiplier has to be greater than or equal to 0. * If the multiplier is set to 0, the function * will return an empty string. *

* The examined string. *

* See return values. *

* The string to be chunked. *

* The chunk length. *

* The line ending sequence. *

* The string that will be trimmed. *

* Optionally, the stripped characters can also be specified using * the charlist parameter. * Simply list all characters that you want to be stripped. With * .. you can specify a range of characters. *

* The input string. *

* You can also specify the characters you want to strip, by means of the * charlist parameter. * Simply list all characters that you want to be stripped. With * .. you can specify a range of characters. *

* The input string. *

* You can use the optional second parameter to specify tags which should * not be stripped. *

* HTML comments and PHP tags are also stripped. This is hardcoded and * can not be changed with allowable_tags. *

* This parameter should not contain whitespace. * strip_tags sees a tag as a case-insensitive * string between < and the first whitespace or * >. It means that * strip_tags("<br/>", "<br>") returns an * empty string. *

* The first string. *

* The second string. *

* By passing a reference as third argument, * similar_text will calculate the similarity in * percent for you. *

* The boundary string. *

* The input string. *

* If limit is set and positive, the returned array will contain * a maximum of limit elements with the last * element containing the rest of string. *

* If the limit parameter is negative, all components * except the last -limit are returned. *

* If the limit parameter is zero, then this is treated as 1. *

* If delimiter is an empty string (""), * explode will return FALSE. * If delimiter contains a value that is not * contained in string and a negative * limit is used, then an empty array will be * returned, otherwise an array containing * string will be returned. */ function explode ($delimiter, $string, $limit = null) {} /** * (PHP 4, PHP 5)
* Join array elements with a string * @link http://php.net/manual/en/function.implode.php * @param string $glue

* Defaults to an empty string. This is not the preferred usage of * implode as glue would be * the second parameter and thus, the bad prototype would be used. *

* The array of strings to implode. *

* category is a named constant specifying the * category of the functions affected by the locale setting: * LC_ALL for all of the below * @param string $locale

* If locale is NULL or the empty string * "", the locale names will be set from the * values of environment variables with the same names as the above * categories, or from "LANG". *

* If locale is "0", * the locale setting is not affected, only the current setting is returned. *

* If locale is an array or followed by additional * parameters then each array element or parameter is tried to be set as * new locale until success. This is useful if a locale is known under * different names on different systems or for providing a fallback * for a possibly not available locale. *

* (Optional string or array parameters to try as locale settings until * success.) *

* An invalid category name also causes a warning message. Category/locale * names can be found in RFC 1766 * and ISO 639. * Different systems have different naming schemes for locales. *

* The return value of setlocale depends * on the system that PHP is running. It returns exactly * what the system setlocale function returns. */ function setlocale ($category, $locale, $_ = null) {} /** * (PHP 4 >= 4.0.5, PHP 5)
* Get numeric formatting information * @link http://php.net/manual/en/function.localeconv.php * @return array localeconv returns data based upon the current locale * as set by setlocale. The associative array that is * returned contains the following fields: * * Array element * Description * * * decimal_point * Decimal point character * * * thousands_sep * Thousands separator * * * grouping * Array containing numeric groupings * * * int_curr_symbol * International currency symbol (i.e. USD) * * * currency_symbol * Local currency symbol (i.e. $) * * * mon_decimal_point * Monetary decimal point character * * * mon_thousands_sep * Monetary thousands separator * * * mon_grouping * Array containing monetary groupings * * * positive_sign * Sign for positive values * * * negative_sign * Sign for negative values * * * int_frac_digits * International fractional digits * * * frac_digits * Local fractional digits * * * p_cs_precedes * * TRUE if currency_symbol precedes a positive value, FALSE * if it succeeds one * * * * p_sep_by_space * * TRUE if a space separates currency_symbol from a positive * value, FALSE otherwise * * * * n_cs_precedes * * TRUE if currency_symbol precedes a negative value, FALSE * if it succeeds one * * * * n_sep_by_space * * TRUE if a space separates currency_symbol from a negative * value, FALSE otherwise * * * p_sign_posn * * 0 - Parentheses surround the quantity and currency_symbol * 1 - The sign string precedes the quantity and currency_symbol * 2 - The sign string succeeds the quantity and currency_symbol * 3 - The sign string immediately precedes the currency_symbol * 4 - The sign string immediately succeeds the currency_symbol * * * n_sign_posn * * 0 - Parentheses surround the quantity and currency_symbol * 1 - The sign string precedes the quantity and currency_symbol * 2 - The sign string succeeds the quantity and currency_symbol * 3 - The sign string immediately precedes the currency_symbol * 4 - The sign string immediately succeeds the currency_symbol * * *

* The p_sign_posn, and n_sign_posn contain a string * of formatting options. Each number representing one of the above listed conditions. *

* The grouping fields contain arrays that define the way numbers should be * grouped. For example, the monetary grouping field for the nl_NL locale (in * UTF-8 mode with the euro sign), would contain a 2 item array with the * values 3 and 3. The higher the index in the array, the farther left the * grouping is. If an array element is equal to CHAR_MAX, * no further grouping is done. If an array element is equal to 0, the previous * element should be used. */ function localeconv () {} /** * (PHP 4 >= 4.1.0, PHP 5)
* Query language and locale information * @link http://php.net/manual/en/function.nl-langinfo.php * @param int $item

* item may be an integer value of the element or the * constant name of the element. The following is a list of constant names * for item that may be used and their description. * Some of these constants may not be defined or hold no value for certain * locales. * * nl_langinfo Constants * * * * * * LC_TIME Category Constants * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * LC_MONETARY Category Constants * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Returns 0 if parentheses surround the quantity and CURRENCY_SYMBOL. * @return string the element as a string, or FALSE if item * is not valid. */ function nl_langinfo ($item) {} /** * (PHP 4, PHP 5)
* Calculate the soundex key of a string * @link http://php.net/manual/en/function.soundex.php * @param string $str

* The input string. *

* @return string the soundex key as a string. */ function soundex ($str) {} /** * (PHP 4 >= 4.0.1, PHP 5)
* Calculate Levenshtein distance between two strings * @link http://php.net/manual/en/function.levenshtein.php * @param string $str1

* One of the strings being evaluated for Levenshtein distance. *

* @param string $str2

* One of the strings being evaluated for Levenshtein distance. *

* @return int This function returns the Levenshtein-Distance between the * two argument strings or -1, if one of the argument strings * is longer than the limit of 255 characters. */ function levenshtein ($str1, $str2) {} /** * (PHP 4, PHP 5)
* Return a specific character * @link http://php.net/manual/en/function.chr.php * @param int $ascii

* The ascii code. *

* @return string the specified character. */ function chr ($ascii) {} /** * (PHP 4, PHP 5)
* Return ASCII value of character * @link http://php.net/manual/en/function.ord.php * @param string $string

* A character. *

* @return int the ASCII value as an integer. */ function ord ($string) {} /** * (PHP 4, PHP 5)
* Parses the string into variables * @link http://php.net/manual/en/function.parse-str.php * @param string $str

* The input string. *

* @param array $arr [optional]

* If the second parameter arr is present, * variables are stored in this variable as array elements instead. *

* @return void No value is returned. */ function parse_str ($str, array &$arr = null) {} /** * (PHP 5 >= 5.3.0)
* Parse a CSV string into an array * @link http://php.net/manual/en/function.str-getcsv.php * @param string $input

* The string to parse. *

* @param string $delimiter [optional]

* Set the field delimiter (one character only). *

* @param string $enclosure [optional]

* Set the field enclosure character (one character only). *

* @param string $escape [optional]

* Set the escape character (one character only). Defaults as a backslash * (\) *

* @return array an indexed array containing the fields read. */ function str_getcsv ($input, $delimiter = ',', $enclosure = '"', $escape = '\\') {} /** * (PHP 4 >= 4.0.1, PHP 5)
* Pad a string to a certain length with another string * @link http://php.net/manual/en/function.str-pad.php * @param string $input

* The input string. *

* @param int $pad_length

* If the value of pad_length is negative, * less than, or equal to the length of the input string, no padding * takes place. *

* @param string $pad_string [optional]

* The pad_string may be truncated if the * required number of padding characters can't be evenly divided by the * pad_string's length. *

* @param int $pad_type [optional]

* Optional argument pad_type can be * STR_PAD_RIGHT, STR_PAD_LEFT, * or STR_PAD_BOTH. If * pad_type is not specified it is assumed to be * STR_PAD_RIGHT. *

* @return string the padded string. */ function str_pad ($input, $pad_length, $pad_string = " ", $pad_type = 'STR_PAD_RIGHT') {} /** * (PHP 4, PHP 5)
* Alias of rtrim * @link http://php.net/manual/en/function.chop.php * @param $str * @param $character_mask [optional] */ function chop ($str, $character_mask) {} /** * (PHP 4, PHP 5)
* Alias of strstr * @link http://php.net/manual/en/function.strchr.php * @param $haystack * @param $needle * @param $part [optional] */ function strchr ($haystack, $needle, $part) {} /** * (PHP 4, PHP 5)
* Return a formatted string * @link http://php.net/manual/en/function.sprintf.php * @param string $format

* The format string is composed of zero or more directives: * ordinary characters (excluding %) that are * copied directly to the result, and conversion * specifications, each of which results in fetching its * own parameter. This applies to both sprintf * and printf. *

*

* Each conversion specification consists of a percent sign * (%), followed by one or more of these * elements, in order: * An optional sign specifier that forces a sign * (- or +) to be used on a number. By default, only the - sign is used * on a number if it's negative. This specifier forces positive numbers * to have the + sign attached as well, and was added in PHP 4.3.0. * @param mixed $args [optional] * @param mixed $_ [optional] * @return string a string produced according to the formatting string * format. */ function sprintf ($format, $args = null, $_ = null) {} /** * (PHP 4, PHP 5)
* Output a formatted string * @link http://php.net/manual/en/function.printf.php * @param string $format

* See sprintf for a description of * format. *

* @param mixed $args [optional] * @param mixed $_ [optional] * @return int the length of the outputted string. */ function printf ($format, $args = null, $_ = null) {} /** * (PHP 4 >= 4.1.0, PHP 5)
* Output a formatted string * @link http://php.net/manual/en/function.vprintf.php * @param string $format

* See sprintf for a description of * format. *

* @param array $args * @return int the length of the outputted string. */ function vprintf ($format, array $args) {} /** * (PHP 4 >= 4.1.0, PHP 5)
* Return a formatted string * @link http://php.net/manual/en/function.vsprintf.php * @param string $format

* See sprintf for a description of * format. *

* @param array $args * @return string Return array values as a formatted string according to * format (which is described in the documentation * for sprintf). */ function vsprintf ($format, array $args) {} /** * (PHP 5)
* Write a formatted string to a stream * @link http://php.net/manual/en/function.fprintf.php * @param resource $handle A file system pointer resource * that is typically created using fopen.

* @param string $format

* See sprintf for a description of * format. *

* @param mixed $args [optional] * @param mixed $_ [optional] * @return int the length of the string written. */ function fprintf ($handle, $format, $args = null, $_ = null) {} /** * (PHP 5)
* Write a formatted string to a stream * @link http://php.net/manual/en/function.vfprintf.php * @param resource $handle * @param string $format

* See sprintf for a description of * format. *

* @param array $args * @return int the length of the outputted string. */ function vfprintf ($handle, $format, array $args) {} /** * (PHP 4 >= 4.0.1, PHP 5)
* Parses input from a string according to a format * @link http://php.net/manual/en/function.sscanf.php * @param string $str

* The input string being parsed. *

* @param string $format

* The interpreted format for str, which is * described in the documentation for sprintf with * following differences: * Function is not locale-aware. * F, g, G and * b are not supported. * D stands for decimal number. * i stands for integer with base detection. * n stands for number of characters processed so far. *

* @param mixed $_ [optional]

* Optionally pass in variables by reference that will contain the parsed values. *

* @return mixed If only two parameters were passed to this function, the values parsed will * be returned as an array. Otherwise, if optional parameters are passed, the * function will return the number of assigned values. The optional parameters * must be passed by reference. *

*

* If there are more substrings expected in the format * than there are available within str, * -1 will be returned. */ function sscanf ($str, $format, &$_ = null) {} /** * (PHP 4 >= 4.0.1, PHP 5)
* Parses input from a file according to a format * @link http://php.net/manual/en/function.fscanf.php * @param resource $handle A file system pointer resource * that is typically created using fopen.

* @param string $format

* The specified format as described in the * sprintf documentation. *

* @param mixed $_ [optional]

* The optional assigned values. *

* @return mixed If only two parameters were passed to this function, the values parsed will be * returned as an array. Otherwise, if optional parameters are passed, the * function will return the number of assigned values. The optional * parameters must be passed by reference. */ function fscanf ($handle, $format, &$_ = null) {} /** * (PHP 4, PHP 5)
* Parse a URL and return its components * @link http://php.net/manual/en/function.parse-url.php * @param string $url

* The URL to parse. Invalid characters are replaced by * _. *

* @param int $component [optional]

* Specify one of PHP_URL_SCHEME, * PHP_URL_HOST, PHP_URL_PORT, * PHP_URL_USER, PHP_URL_PASS, * PHP_URL_PATH, PHP_URL_QUERY * or PHP_URL_FRAGMENT to retrieve just a specific * URL component as a string (except when * PHP_URL_PORT is given, in which case the return * value will be an integer). *

* @return mixed On seriously malformed URLs, parse_url may return * FALSE. *

*

* If the component parameter is omitted, an * associative array is returned. At least one element will be * present within the array. Potential keys within this array are: * scheme - e.g. http * host * port * user * pass * path * query - after the question mark ? * fragment - after the hashmark # *

*

* If the component parameter is specified, * parse_url returns a string (or an * integer, in the case of PHP_URL_PORT) * instead of an array. If the requested component doesn't exist * within the given URL, NULL will be returned. */ function parse_url ($url, $component = -1) {} /** * (PHP 4, PHP 5)
* URL-encodes string * @link http://php.net/manual/en/function.urlencode.php * @param string $str

* The string to be encoded. *

* @return string a string in which all non-alphanumeric characters except * -_. have been replaced with a percent * (%) sign followed by two hex digits and spaces encoded * as plus (+) signs. It is encoded the same way that the * posted data from a WWW form is encoded, that is the same way as in * application/x-www-form-urlencoded media type. This * differs from the RFC 3986 encoding (see * rawurlencode) in that for historical reasons, spaces * are encoded as plus (+) signs. */ function urlencode ($str) {} /** * (PHP 4, PHP 5)
* Decodes URL-encoded string * @link http://php.net/manual/en/function.urldecode.php * @param string $str

* The string to be decoded. *

* @return string the decoded string. */ function urldecode ($str) {} /** * (PHP 4, PHP 5)
* URL-encode according to RFC 3986 * @link http://php.net/manual/en/function.rawurlencode.php * @param string $str

* The URL to be encoded. *

* @return string a string in which all non-alphanumeric characters except * -_.~ have been replaced with a percent * (%) sign followed by two hex digits. This is the * encoding described in RFC 3986 for * protecting literal characters from being interpreted as special URL * delimiters, and for protecting URLs from being mangled by transmission * media with character conversions (like some email systems). *

* Prior to PHP 5.3.0, rawurlencode encoded tildes (~) as per * RFC 1738. *

*/ function rawurlencode ($str) {} /** * (PHP 4, PHP 5)
* Decode URL-encoded strings * @link http://php.net/manual/en/function.rawurldecode.php * @param string $str

* The URL to be decoded. *

* @return string the decoded URL, as a string. */ function rawurldecode ($str) {} /** * (PHP 5)
* Generate URL-encoded query string * @link http://php.net/manual/en/function.http-build-query.php * @param mixed $query_data

* May be an array or object containing properties. *

*

* If query_data is an array, it may be a simple * one-dimensional structure, or an array of arrays (which in * turn may contain other arrays). *

*

* If query_data is an object, then only public * properties will be incorporated into the result. *

* @param string $numeric_prefix [optional]

* If numeric indices are used in the base array and this parameter is * provided, it will be prepended to the numeric index for elements in * the base array only. *

*

* This is meant to allow for legal variable names when the data is * decoded by PHP or another CGI application later on. *

* @param string $arg_separator [optional]

* arg_separator.output * is used to separate arguments, unless this parameter is specified, * and is then used. *

* @param int $enc_type [optional]

* By default, PHP_QUERY_RFC1738. *

*

* If enc_type is * PHP_QUERY_RFC1738, then encoding is performed per * RFC 1738 and the * application/x-www-form-urlencoded media type, which * implies that spaces are encoded as plus (+) signs. *

*

* If enc_type is * PHP_QUERY_RFC3986, then encoding is performed * according to RFC 3986, and * spaces will be percent encoded (%20). *

* @return string a URL-encoded string. */ function http_build_query ($query_data, $numeric_prefix = null, $arg_separator = null, $enc_type = 'PHP_QUERY_RFC1738') {} /** * (PHP 4, PHP 5)
* Returns the target of a symbolic link * @link http://php.net/manual/en/function.readlink.php * @param string $path

* The symbolic link path. *

* @return string the contents of the symbolic link path or FALSE on error. */ function readlink ($path) {} /** * (PHP 4, PHP 5)
* Gets information about a link * @link http://php.net/manual/en/function.linkinfo.php * @param string $path

* Path to the link. *

* @return int linkinfo returns the st_dev field * of the Unix C stat structure returned by the lstat * system call. Returns 0 or FALSE in case of error. */ function linkinfo ($path) {} /** * (PHP 4, PHP 5)
* Creates a symbolic link * @link http://php.net/manual/en/function.symlink.php * @param string $target

* Target of the link. *

* @param string $link

* The link name. *

* @return bool TRUE on success or FALSE on failure. */ function symlink ($target, $link) {} /** * (PHP 4, PHP 5)
* Create a hard link * @link http://php.net/manual/en/function.link.php * @param string $target

* Target of the link. *

* @param string $link

* The link name. *

* @return bool TRUE on success or FALSE on failure. */ function link ($target, $link) {} /** * (PHP 4, PHP 5)
* Deletes a file * @link http://php.net/manual/en/function.unlink.php * @param string $filename

* Path to the file. *

* @param resource $context [optional] Context support was added * with PHP 5.0.0. For a description of contexts, refer to * . * @return bool TRUE on success or FALSE on failure. */ function unlink ($filename, $context = null) {} /** * (PHP 4, PHP 5)
* Execute an external program * @link http://php.net/manual/en/function.exec.php * @param string $command

* The command that will be executed. *

* @param array $output [optional]

* If the output argument is present, then the * specified array will be filled with every line of output from the * command. Trailing whitespace, such as \n, is not * included in this array. Note that if the array already contains some * elements, exec will append to the end of the array. * If you do not want the function to append elements, call * unset on the array before passing it to * exec. *

* @param int $return_var [optional]

* If the return_var argument is present * along with the output argument, then the * return status of the executed command will be written to this * variable. *

* @return string The last line from the result of the command. If you need to execute a * command and have all the data from the command passed directly back without * any interference, use the passthru function. *

*

* To get the output of the executed command, be sure to set and use the * output parameter. */ function exec ($command, array &$output = null, &$return_var = null) {} /** * (PHP 4, PHP 5)
* Execute an external program and display the output * @link http://php.net/manual/en/function.system.php * @param string $command

* The command that will be executed. *

* @param int $return_var [optional]

* If the return_var argument is present, then the * return status of the executed command will be written to this * variable. *

* @return string the last line of the command output on success, and FALSE * on failure. */ function system ($command, &$return_var = null) {} /** * (PHP 4, PHP 5)
* Escape shell metacharacters * @link http://php.net/manual/en/function.escapeshellcmd.php * @param string $command

* The command that will be escaped. *

* @return string The escaped string. */ function escapeshellcmd ($command) {} /** * (PHP 4 >= 4.0.3, PHP 5)
* Escape a string to be used as a shell argument * @link http://php.net/manual/en/function.escapeshellarg.php * @param string $arg

* The argument that will be escaped. *

* @return string The escaped string. */ function escapeshellarg ($arg) {} /** * (PHP 4, PHP 5)
* Execute an external program and display raw output * @link http://php.net/manual/en/function.passthru.php * @param string $command

* The command that will be executed. *

* @param int $return_var [optional]

* If the return_var argument is present, the * return status of the Unix command will be placed here. *

* @return void No value is returned. */ function passthru ($command, &$return_var = null) {} /** * (PHP 4, PHP 5)
* Execute command via shell and return the complete output as a string * @link http://php.net/manual/en/function.shell-exec.php * @param string $cmd

* The command that will be executed. *

* @return string The output from the executed command or NULL if an error occurred. */ function shell_exec ($cmd) {} /** * (PHP 4 >= 4.3.0, PHP 5)
* Execute a command and open file pointers for input/output * @link http://php.net/manual/en/function.proc-open.php * @param string $cmd

* The command to execute *

* @param array $descriptorspec

* An indexed array where the key represents the descriptor number and the * value represents how PHP will pass that descriptor to the child * process. 0 is stdin, 1 is stdout, while 2 is stderr. *

*

* Each element can be: * An array describing the pipe to pass to the process. The first * element is the descriptor type and the second element is an option for * the given type. Valid types are pipe (the second * element is either r to pass the read end of the pipe * to the process, or w to pass the write end) and * file (the second element is a filename). * A stream resource representing a real file descriptor (e.g. opened file, * a socket, STDIN). *

*

* The file descriptor numbers are not limited to 0, 1 and 2 - you may * specify any valid file descriptor number and it will be passed to the * child process. This allows your script to interoperate with other * scripts that run as "co-processes". In particular, this is useful for * passing passphrases to programs like PGP, GPG and openssl in a more * secure manner. It is also useful for reading status information * provided by those programs on auxiliary file descriptors. *

* @param array $pipes

* Will be set to an indexed array of file pointers that correspond to * PHP's end of any pipes that are created. *

* @param string $cwd [optional]

* The initial working dir for the command. This must be an * absolute directory path, or NULL * if you want to use the default value (the working dir of the current * PHP process) *

* @param array $env [optional]

* An array with the environment variables for the command that will be * run, or NULL to use the same environment as the current PHP process *

* @param array $other_options [optional]

* Allows you to specify additional options. Currently supported options * include: * suppress_errors (windows only): suppresses errors * generated by this function when it's set to TRUE * bypass_shell (windows only): bypass * cmd.exe shell when set to TRUE *

* @return resource a resource representing the process, which should be freed using * proc_close when you are finished with it. On failure * returns FALSE. */ function proc_open ($cmd, array $descriptorspec, array &$pipes, $cwd = null, array $env = null, array $other_options = null) {} /** * (PHP 4 >= 4.3.0, PHP 5)
* Close a process opened by proc_open and return the exit code of that process * @link http://php.net/manual/en/function.proc-close.php * @param resource $process

* The proc_open resource that will * be closed. *

* @return int the termination status of the process that was run. In case of * an error then -1 is returned. */ function proc_close ($process) {} /** * (PHP 5)
* Kills a process opened by proc_open * @link http://php.net/manual/en/function.proc-terminate.php * @param resource $process

* The proc_open resource that will * be closed. *

* @param int $signal [optional]

* This optional parameter is only useful on POSIX * operating systems; you may specify a signal to send to the process * using the kill(2) system call. The default is * SIGTERM. *

* @return bool the termination status of the process that was run. */ function proc_terminate ($process, $signal = 15) {} /** * (PHP 5)
* Get information about a process opened by proc_open * @link http://php.net/manual/en/function.proc-get-status.php * @param resource $process

* The proc_open resource that will * be evaluated. *

* @return array An array of collected information on success, and FALSE * on failure. The returned array contains the following elements: *

*

*

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ function proc_get_status ($process) {} /** * (PHP 5)
* Change the priority of the current process * @link http://php.net/manual/en/function.proc-nice.php * @param int $increment

* The increment value of the priority change. *

* @return bool TRUE on success or FALSE on failure. * If an error occurs, like the user lacks permission to change the priority, * an error of level E_WARNING is also generated. */ function proc_nice ($increment) {} /** * (PHP 4, PHP 5)
* Generate a random integer * @link http://php.net/manual/en/function.rand.php * @param $min [optional] * @param $max [optional] * @return int A pseudo random value between min * (or 0) and max (or getrandmax, inclusive). */ function rand ($min, $max) {} /** * (PHP 4, PHP 5)
* Seed the random number generator * @link http://php.net/manual/en/function.srand.php * @param int $seed [optional]

* Optional seed value *

* @return void No value is returned. */ function srand ($seed = null) {} /** * (PHP 4, PHP 5)
* Show largest possible random value * @link http://php.net/manual/en/function.getrandmax.php * @return int The largest possible random value returned by rand */ function getrandmax () {} /** * (PHP 4, PHP 5)
* Generate a better random value * @link http://php.net/manual/en/function.mt-rand.php * @param $min [optional] * @param $max [optional] * @return int A random integer value between min (or 0) * and max (or mt_getrandmax, inclusive), * or FALSE if max is less than min. */ function mt_rand ($min, $max) {} /** * (PHP 4, PHP 5)
* Seed the better random number generator * @link http://php.net/manual/en/function.mt-srand.php * @param int $seed [optional]

* An optional seed value *

* @return void No value is returned. */ function mt_srand ($seed = null) {} /** * (PHP 4, PHP 5)
* Show largest possible random value * @link http://php.net/manual/en/function.mt-getrandmax.php * @return int the maximum random value returned by mt_rand */ function mt_getrandmax () {} /** * (PHP 4, PHP 5)
* Get port number associated with an Internet service and protocol * @link http://php.net/manual/en/function.getservbyname.php * @param string $service

* The Internet service name, as a string. *

* @param string $protocol

* protocol is either "tcp" * or "udp" (in lowercase). *

* @return int the port number, or FALSE if service or * protocol is not found. */ function getservbyname ($service, $protocol) {} /** * (PHP 4, PHP 5)
* Get Internet service which corresponds to port and protocol * @link http://php.net/manual/en/function.getservbyport.php * @param int $port

* The port number. *

* @param string $protocol

* protocol is either "tcp" * or "udp" (in lowercase). *

* @return string the Internet service name as a string. */ function getservbyport ($port, $protocol) {} /** * (PHP 4, PHP 5)
* Get protocol number associated with protocol name * @link http://php.net/manual/en/function.getprotobyname.php * @param string $name

* The protocol name. *

* @return int the protocol number, or FALSE on failure. */ function getprotobyname ($name) {} /** * (PHP 4, PHP 5)
* Get protocol name associated with protocol number * @link http://php.net/manual/en/function.getprotobynumber.php * @param int $number

* The protocol number. *

* @return string the protocol name as a string, or FALSE on failure. */ function getprotobynumber ($number) {} /** * (PHP 4, PHP 5)
* Gets PHP script owner's UID * @link http://php.net/manual/en/function.getmyuid.php * @return int the user ID of the current script, or FALSE on error. */ function getmyuid () {} /** * (PHP 4 >= 4.1.0, PHP 5)
* Get PHP script owner's GID * @link http://php.net/manual/en/function.getmygid.php * @return int the group ID of the current script, or FALSE on error. */ function getmygid () {} /** * (PHP 4, PHP 5)
* Gets PHP's process ID * @link http://php.net/manual/en/function.getmypid.php * @return int the current PHP process ID, or FALSE on error. */ function getmypid () {} /** * (PHP 4, PHP 5)
* Gets the inode of the current script * @link http://php.net/manual/en/function.getmyinode.php * @return int the current script's inode as an integer, or FALSE on error. */ function getmyinode () {} /** * (PHP 4, PHP 5)
* Gets time of last page modification * @link http://php.net/manual/en/function.getlastmod.php * @return int the time of the last modification of the current * page. The value returned is a Unix timestamp, suitable for * feeding to date. Returns FALSE on error. */ function getlastmod () {} /** * (PHP 4, PHP 5)
* Decodes data encoded with MIME base64 * @link http://php.net/manual/en/function.base64-decode.php * @param string $data

* The encoded data. *

* @param bool $strict [optional]

* Returns FALSE if input contains character from outside the base64 * alphabet. *

* @return string the original data or FALSE on failure. The returned data may be * binary. */ function base64_decode ($data, $strict = false) {} /** * (PHP 4, PHP 5)
* Encodes data with MIME base64 * @link http://php.net/manual/en/function.base64-encode.php * @param string $data

* The data to encode. *

* @return string The encoded data, as a string or FALSE on failure. */ function base64_encode ($data) {} /** * (PHP 5)
* Uuencode a string * @link http://php.net/manual/en/function.convert-uuencode.php * @param string $data

* The data to be encoded. *

* @return string the uuencoded data. */ function convert_uuencode ($data) {} /** * (PHP 5)
* Decode a uuencoded string * @link http://php.net/manual/en/function.convert-uudecode.php * @param string $data

* The uuencoded data. *

* @return string the decoded data as a string. */ function convert_uudecode ($data) {} /** * (PHP 4, PHP 5)
* Absolute value * @link http://php.net/manual/en/function.abs.php * @param mixed $number

* The numeric value to process *

* @return number The absolute value of number. If the * argument number is * of type float, the return type is also float, * otherwise it is integer (as float usually has a * bigger value range than integer). */ function abs ($number) {} /** * (PHP 4, PHP 5)
* Round fractions up * @link http://php.net/manual/en/function.ceil.php * @param float $value

* The value to round *

* @return float value rounded up to the next highest * integer. * The return value of ceil is still of type * float as the value range of float is * usually bigger than that of integer. */ function ceil ($value) {} /** * (PHP 4, PHP 5)
* Round fractions down * @link http://php.net/manual/en/function.floor.php * @param float $value

* The numeric value to round *

* @return float value rounded to the next lowest integer. * The return value of floor is still of type * float because the value range of float is * usually bigger than that of integer. */ function floor ($value) {} /** * (PHP 4, PHP 5)
* Rounds a float * @link http://php.net/manual/en/function.round.php * @param float $val

* The value to round *

* @param int $precision [optional]

* The optional number of decimal digits to round to. *

* @param int $mode [optional]

* Use one of the following constants to specify the mode in which rounding occurs. *

* * * * * * * * * * * * * * * * * * * *

* @return float The rounded value */ function round ($val, $precision = 0, $mode = 'PHP_ROUND_HALF_UP') {} /** * (PHP 4, PHP 5)
* Sine * @link http://php.net/manual/en/function.sin.php * @param float $arg

* A value in radians *

* @return float The sine of arg */ function sin ($arg) {} /** * (PHP 4, PHP 5)
* Cosine * @link http://php.net/manual/en/function.cos.php * @param float $arg

* An angle in radians *

* @return float The cosine of arg */ function cos ($arg) {} /** * (PHP 4, PHP 5)
* Tangent * @link http://php.net/manual/en/function.tan.php * @param float $arg

* The argument to process in radians *

* @return float The tangent of arg */ function tan ($arg) {} /** * (PHP 4, PHP 5)
* Arc sine * @link http://php.net/manual/en/function.asin.php * @param float $arg

* The argument to process *

* @return float The arc sine of arg in radians */ function asin ($arg) {} /** * (PHP 4, PHP 5)
* Arc cosine * @link http://php.net/manual/en/function.acos.php * @param float $arg

* The argument to process *

* @return float The arc cosine of arg in radians. */ function acos ($arg) {} /** * (PHP 4, PHP 5)
* Arc tangent * @link http://php.net/manual/en/function.atan.php * @param float $arg

* The argument to process *

* @return float The arc tangent of arg in radians. */ function atan ($arg) {} /** * (PHP 4 >= 4.1.0, PHP 5)
* Inverse hyperbolic tangent * @link http://php.net/manual/en/function.atanh.php * @param float $arg

* The argument to process *

* @return float Inverse hyperbolic tangent of arg */ function atanh ($arg) {} /** * (PHP 4, PHP 5)
* Arc tangent of two variables * @link http://php.net/manual/en/function.atan2.php * @param float $y

* Dividend parameter *

* @param float $x

* Divisor parameter *

* @return float The arc tangent of y/x * in radians. */ function atan2 ($y, $x) {} /** * (PHP 4 >= 4.1.0, PHP 5)
* Hyperbolic sine * @link http://php.net/manual/en/function.sinh.php * @param float $arg

* The argument to process *

* @return float The hyperbolic sine of arg */ function sinh ($arg) {} /** * (PHP 4 >= 4.1.0, PHP 5)
* Hyperbolic cosine * @link http://php.net/manual/en/function.cosh.php * @param float $arg

* The argument to process *

* @return float The hyperbolic cosine of arg */ function cosh ($arg) {} /** * (PHP 4 >= 4.1.0, PHP 5)
* Hyperbolic tangent * @link http://php.net/manual/en/function.tanh.php * @param float $arg

* The argument to process *

* @return float The hyperbolic tangent of arg */ function tanh ($arg) {} /** * (PHP 4 >= 4.1.0, PHP 5)
* Inverse hyperbolic sine * @link http://php.net/manual/en/function.asinh.php * @param float $arg

* The argument to process *

* @return float The inverse hyperbolic sine of arg */ function asinh ($arg) {} /** * (PHP 4 >= 4.1.0, PHP 5)
* Inverse hyperbolic cosine * @link http://php.net/manual/en/function.acosh.php * @param float $arg

* The value to process *

* @return float The inverse hyperbolic cosine of arg */ function acosh ($arg) {} /** * (PHP 4 >= 4.1.0, PHP 5)
* Returns exp(number) - 1, computed in a way that is accurate even when the value of number is close to zero * @link http://php.net/manual/en/function.expm1.php * @param float $arg

* The argument to process *

* @return float 'e' to the power of arg minus one */ function expm1 ($arg) {} /** * (PHP 4 >= 4.1.0, PHP 5)
* Returns log(1 + number), computed in a way that is accurate even when the value of number is close to zero * @link http://php.net/manual/en/function.log1p.php * @param float $number

* The argument to process *

* @return float log(1 + number) */ function log1p ($number) {} /** * (PHP 4, PHP 5)
* Get value of pi * @link http://php.net/manual/en/function.pi.php * @return float The value of pi as float. */ function pi () {} /** * (PHP 4 >= 4.2.0, PHP 5)
* Finds whether a value is a legal finite number * @link http://php.net/manual/en/function.is-finite.php * @param float $val

* The value to check *

* @return bool TRUE if val is a legal finite * number within the allowed range for a PHP float on this platform, * else FALSE. */ function is_finite ($val) {} /** * (PHP 4 >= 4.2.0, PHP 5)
* Finds whether a value is not a number * @link http://php.net/manual/en/function.is-nan.php * @param float $val

* The value to check *

* @return bool TRUE if val is 'not a number', * else FALSE. */ function is_nan ($val) {} /** * (PHP 4 >= 4.2.0, PHP 5)
* Finds whether a value is infinite * @link http://php.net/manual/en/function.is-infinite.php * @param float $val

* The value to check *

* @return bool TRUE if val is infinite, else FALSE. */ function is_infinite ($val) {} /** * (PHP 4, PHP 5)
* Exponential expression * @link http://php.net/manual/en/function.pow.php * @param number $base

* The base to use *

* @param number $exp

* The exponent *

* @return number base raised to the power of exp. * If both arguments are non-negative integers and the result can be represented * as an integer, the result will be returned with integer type, * otherwise it will be returned as a float. */ function pow ($base, $exp) {} /** * (PHP 4, PHP 5)
* Calculates the exponent of e * @link http://php.net/manual/en/function.exp.php * @param float $arg

* The argument to process *

* @return float 'e' raised to the power of arg */ function exp ($arg) {} /** * (PHP 4, PHP 5)
* Natural logarithm * @link http://php.net/manual/en/function.log.php * @param float $arg

* The value to calculate the logarithm for *

* @param float $base [optional]

* The optional logarithmic base to use * (defaults to 'e' and so to the natural logarithm). *

* @return float The logarithm of arg to * base, if given, or the * natural logarithm. */ function log ($arg, $base = 'M_E') {} /** * (PHP 4, PHP 5)
* Base-10 logarithm * @link http://php.net/manual/en/function.log10.php * @param float $arg

* The argument to process *

* @return float The base-10 logarithm of arg */ function log10 ($arg) {} /** * (PHP 4, PHP 5)
* Square root * @link http://php.net/manual/en/function.sqrt.php * @param float $arg

* The argument to process *

* @return float The square root of arg * or the special value NAN for negative numbers. */ function sqrt ($arg) {} /** * (PHP 4 >= 4.1.0, PHP 5)
* Calculate the length of the hypotenuse of a right-angle triangle * @link http://php.net/manual/en/function.hypot.php * @param float $x

* Length of first side *

* @param float $y

* Length of second side *

* @return float Calculated length of the hypotenuse */ function hypot ($x, $y) {} /** * (PHP 4, PHP 5)
* Converts the number in degrees to the radian equivalent * @link http://php.net/manual/en/function.deg2rad.php * @param float $number

* Angular value in degrees *

* @return float The radian equivalent of number */ function deg2rad ($number) {} /** * (PHP 4, PHP 5)
* Converts the radian number to the equivalent number in degrees * @link http://php.net/manual/en/function.rad2deg.php * @param float $number

* A radian value *

* @return float The equivalent of number in degrees */ function rad2deg ($number) {} /** * (PHP 4, PHP 5)
* Binary to decimal * @link http://php.net/manual/en/function.bindec.php * @param string $binary_string

* The binary string to convert *

* @return number The decimal value of binary_string */ function bindec ($binary_string) {} /** * (PHP 4, PHP 5)
* Hexadecimal to decimal * @link http://php.net/manual/en/function.hexdec.php * @param string $hex_string

* The hexadecimal string to convert *

* @return number The decimal representation of hex_string */ function hexdec ($hex_string) {} /** * (PHP 4, PHP 5)
* Octal to decimal * @link http://php.net/manual/en/function.octdec.php * @param string $octal_string

* The octal string to convert *

* @return number The decimal representation of octal_string */ function octdec ($octal_string) {} /** * (PHP 4, PHP 5)
* Decimal to binary * @link http://php.net/manual/en/function.decbin.php * @param int $number

* Decimal value to convert *

*

Constant	Description
ABDAY_(1-7)	Abbreviated name of n-th day of the week.
DAY_(1-7)	Name of the n-th day of the week (DAY_1 = Sunday).
ABMON_(1-12)	Abbreviated name of the n-th month of the year.
MON_(1-12)	Name of the n-th month of the year.
AM_STR	String for Ante meridian.
PM_STR	String for Post meridian.
D_T_FMT	String that can be used as the format string for strftime to represent time and date.
D_FMT	String that can be used as the format string for strftime to represent date.
T_FMT	String that can be used as the format string for strftime to represent time.
T_FMT_AMPM	String that can be used as the format string for strftime to represent time in 12-hour format with ante/post meridian.
ERA	Alternate era.
ERA_YEAR	Year in alternate era format.
ERA_D_T_FMT	Date and time in alternate era format (string can be used in strftime).
ERA_D_FMT	Date in alternate era format (string can be used in strftime).
ERA_T_FMT	Time in alternate era format (string can be used in strftime).
INT_CURR_SYMBOL	International currency symbol.
CURRENCY_SYMBOL	Local currency symbol.
CRNCYSTR	Same value as CURRENCY_SYMBOL.
MON_DECIMAL_POINT	Decimal point character.
MON_THOUSANDS_SEP	Thousands separator (groups of three digits).
MON_GROUPING	Like "grouping" element.
POSITIVE_SIGN	Sign for positive values.
NEGATIVE_SIGN	Sign for negative values.
INT_FRAC_DIGITS	International fractional digits.
FRAC_DIGITS	Local fractional digits.
P_CS_PRECEDES	Returns 1 if CURRENCY_SYMBOL precedes a positive value.
P_SEP_BY_SPACE	Returns 1 if a space separates CURRENCY_SYMBOL from a positive value.
N_CS_PRECEDES	Returns 1 if CURRENCY_SYMBOL precedes a negative value.
N_SEP_BY_SPACE	Returns 1 if a space separates CURRENCY_SYMBOL from a negative value.
P_SIGN_POSN
element	type	description
command	string	* The command string that was passed to proc_open. *
pid	int	process id
running	bool	* TRUE if the process is still running, FALSE if it has * terminated. *
signaled	bool	* TRUE if the child process has been terminated by * an uncaught signal. Always set to FALSE on Windows. *
stopped	bool	* TRUE if the child process has been stopped by a * signal. Always set to FALSE on Windows. *
exitcode	int	* The exit code returned by the process (which is only * meaningful if running is FALSE). * Only first call of this function return real value, next calls return * -1. *
termsig	int	* The number of the signal that caused the child process to terminate * its execution (only meaningful if signaled is TRUE). *
stopsig	int	* The number of the signal that caused the child process to stop its * execution (only meaningful if stopped is TRUE). *
Constant	Description
PHP_ROUND_HALF_UP	* Round val up to precision decimal places * away from zero, when it is half way there. Making 1.5 into 2 and -1.5 into -2. *
PHP_ROUND_HALF_DOWN	* Round val down to precision decimal places * towards zero, when it is half way there. Making 1.5 into 1 and -1.5 into -1. *
PHP_ROUND_HALF_EVEN	* Round val to precision decimal places * towards the next even value. *
PHP_ROUND_HALF_ODD	* Round val to precision decimal places * towards the next odd value. *

* Range of inputs on 32-bit machines * * * * * * * * * * * * * * * * * * * * * * ... normal progression ... * * * * * * * * * * * * * * * * * * ... normal progression ... * * * * * * * * * * * *

positive number	negative number	return value
0		0
1		1
2		10
2147483646		1111111111111111111111111111110
2147483647 (largest signed integer)		1111111111111111111111111111111 (31 1's)
2147483648	-2147483648	10000000000000000000000000000000
4294967294	-2	11111111111111111111111111111110
4294967295 (largest unsigned integer)	-1	11111111111111111111111111111111 (32 1's)

* * Range of inputs on 64-bit machines * * * * * * * * * * * * * * * * * * * * * * ... normal progression ... * * * * * * * * * * * * * * * * * * ... normal progression ... * * * * * * * * * * * *

positive number	negative number	return value
0		0
1		1
2		10
9223372036854775806		111111111111111111111111111111111111111111111111111111111111110
9223372036854775807 (largest signed integer)		111111111111111111111111111111111111111111111111111111111111111 (63 1's)
	-9223372036854775808	1000000000000000000000000000000000000000000000000000000000000000
	-2	1111111111111111111111111111111111111111111111111111111111111110
	-1	1111111111111111111111111111111111111111111111111111111111111111 (64 1's)

* @return string Binary string representation of number */ function decbin ($number) {} /** * (PHP 4, PHP 5)
* Decimal to octal * @link http://php.net/manual/en/function.decoct.php * @param int $number

* Decimal value to convert *

* The decimal value to convert. *

* As PHP's integer type is signed, but * dechex deals with unsigned integers, negative * integers will be treated as though they were unsigned. *

* The number to convert *

* The base number is in *

* The base to convert number to *

* The number being formatted. *

* Sets the number of decimal points. *

* Sets the separator for the decimal point. *

* Sets the thousands separator. *

* The dividend *

* The divisor *

* A 32bit IPv4, or 128bit IPv6 address. *

* A human readable IPv4 or IPv6 address. *

* A standard format address. *

* A proper address representation. *

* The variable name. *

* The setting, like "FOO=BAR" *

* The parsing of options will end at the first non-option found, anything * that follows is discarded. */ function getopt ($options, array $longopts = null) {} /** * (PHP 5 >= 5.1.3)
* Gets system load average * @link http://php.net/manual/en/function.sys-getloadavg.php * @return array an array with three samples (last 1, 5 and 15 * minutes). */ function sys_getloadavg () {} /** * (PHP 4, PHP 5)
* Return current Unix timestamp with microseconds * @link http://php.net/manual/en/function.microtime.php * @param bool $get_as_float [optional]

* If used and set to TRUE, microtime will return a * float instead of a string, as described in * the return values section below. *

* If get_as_float is set to TRUE, then * microtime returns a float, which * represents the current time in seconds since the Unix epoch accurate to the * nearest microsecond. */ function microtime ($get_as_float = false) {} /** * (PHP 4, PHP 5)
* Get current time * @link http://php.net/manual/en/function.gettimeofday.php * @param bool $return_float [optional]

* When set to TRUE, a float instead of an array is returned. *

* Array keys: * "sec" - seconds since the Unix Epoch * "usec" - microseconds * "minuteswest" - minutes west of Greenwich * "dsttime" - type of dst correction */ function gettimeofday ($return_float = false) {} /** * (PHP 4, PHP 5)
* Gets the current resource usages * @link http://php.net/manual/en/function.getrusage.php * @param int $who [optional]

* If who is 1, getrusage will be called with * RUSAGE_CHILDREN. *

* Can be useful, for instance, if you generate identifiers * simultaneously on several hosts that might happen to generate the * identifier at the same microsecond. *

* With an empty prefix, the returned string will * be 13 characters long. If more_entropy is * TRUE, it will be 23 characters. *

* If set to TRUE, uniqid will add additional * entropy (using the combined linear congruential generator) at the end * of the return value, which increases the likelihood that the result * will be unique. *

* The input string. *

* The input string. *

* The string to be converted. *

* The source Cyrillic character set, as a single character. *

* The target Cyrillic character set, as a single character. *

* The maximum execution time, in seconds. If set to zero, no time limit * is imposed. *

* Function called just before the headers are sent. It gets no parameters * and the return value is ignored. *

* The configuration option name. *

* FALSE for off, TRUE for on. *

* The error message that should be logged. *

* Says where the error should go. The possible message types are as * follows: *

* * error_log log types * * * * * * * * * * * * * * * * * * * * *

0	* message is sent to PHP's system logger, using * the Operating System's system logging mechanism or a file, depending * on what the error_log * configuration directive is set to. This is the default option. *
1	* message is sent by email to the address in * the destination parameter. This is the only * message type where the fourth parameter, * extra_headers is used. *
2	* No longer an option. *
3	* message is appended to the file * destination. A newline is not automatically * added to the end of the message string. *
4	* message is sent directly to the SAPI logging * handler. *

*

* The destination. Its meaning depends on the * message_type parameter as described above. *

* The extra headers. It's used when the message_type * parameter is set to 1. * This message type uses the same internal function as * mail does. *

* The callable to be called. *

* Zero or more parameters to be passed to the callback. *

* Note that the parameters for call_user_func are * not passed by reference. * call_user_func example and references * * error_reporting(E_ALL); * function increment(&$var) * { * $var++; * } * $a = 0; * call_user_func('increment', $a); * echo $a."\n"; * call_user_func_array('increment', array( // You can use this instead before PHP 5.3 * echo $a."\n"; * * The above example will output:

 * 0
 * 1
 * 

* The callable to be called. *

* The parameters to be passed to the callback, as an indexed array. *

* The method name being called. *

* The object that method_name * is being called on. *

* The method name being called. *

* The object that method_name * is being called on. *

* An array of parameters. *

* The function or method to be called. This parameter may be an array, * with the name of the class, and the method, or a string, with a function * name. *

* Zero or more parameters to be passed to the function. *

* The function or method to be called. This parameter may be an array, * with the name of the class, and the method, or a string, with a function * name. *

* The value to be serialized. serialize * handles all types, except the resource-type. * You can even serialize arrays that contain * references to itself. Circular references inside the array/object you * are serializing will also be stored. Any other * reference will be lost. *

* When serializing objects, PHP will attempt to call the member function * __sleep() prior to serialization. * This is to allow the object to do any last minute clean-up, etc. prior * to being serialized. Likewise, when the object is restored using * unserialize the __wakeup() member function is called. *

* Object's private members have the class name prepended to the member * name; protected members have a '*' prepended to the member name. * These prepended values have null bytes on either side. *

* Note that this is a binary string which may include null bytes, and needs * to be stored and handled as such. For example, * serialize output should generally be stored in a BLOB * field in a database, rather than a CHAR or TEXT field. */ function serialize ($value) {} /** * (PHP 4, PHP 5)
* Creates a PHP value from a stored representation * @link http://php.net/manual/en/function.unserialize.php * @param string $str

* The serialized string. *

* If the variable being unserialized is an object, after successfully * reconstructing the object PHP will automatically attempt to call the * __wakeup() member * function (if it exists). *

* unserialize_callback_func directive *

* It's possible to set a callback-function which will be called, * if an undefined class should be instantiated during unserializing. * (to prevent getting an incomplete object "__PHP_Incomplete_Class".) * Use your php.ini, ini_set or .htaccess * to define 'unserialize_callback_func'. Everytime an undefined class * should be instantiated, it'll be called. To disable this feature just * empty this setting. *

* In case the passed string is not unserializeable, FALSE is returned and * E_NOTICE is issued. */ function unserialize ($str) {} /** * (PHP 4, PHP 5)
* Dumps information about a variable * @link http://php.net/manual/en/function.var-dump.php * @param mixed $expression

* The variable you want to dump. *

* The variable you want to export. *

* If used and set to TRUE, var_export will return * the variable representation instead of outputing it. *

* The variable being evaluated. *

* The expression to be printed. *

* If you would like to capture the output of print_r, * use the return parameter. When this parameter is set * to TRUE, print_r will return the information rather than print it. *

* When the return parameter is TRUE, this function * will return a string. Otherwise, the return value is TRUE. */ function print_r ($expression, $return = false) {} /** * (PHP 4 >= 4.3.2, PHP 5)
* Returns the amount of memory allocated to PHP * @link http://php.net/manual/en/function.memory-get-usage.php * @param bool $real_usage [optional]

* Set this to TRUE to get the real size of memory allocated from * system. If not set or FALSE only the memory used by * emalloc() is reported. *

* Set this to TRUE to get the real size of memory allocated from * system. If not set or FALSE only the memory used by * emalloc() is reported. *

* The shutdown callback to register. *

* The shutdown callbacks are executed as the part of the request, so * it's possible to send output from them and access output buffers. *

* It is possible to pass parameters to the shutdown function by passing * additional parameters. *

* The function name as a string, or an array consisting of an object and * a method. *

* The function name, as a string. *

* Path to the PHP file to be highlighted. *

* Set this parameter to TRUE to make this function return the * highlighted code. *

* The PHP code to be highlighted. This should include the opening tag. *

* Set this parameter to TRUE to make this function return the * highlighted code. *

* Path to the PHP file. *

* This function works as described as of PHP 5.0.1. Before this it would * only return an empty string. For more information on this bug and its * prior behavior, see bug report * #29606. */ function php_strip_whitespace ($filename) {} /** * (PHP 4, PHP 5)
* Gets the value of a configuration option * @link http://php.net/manual/en/function.ini-get.php * @param string $varname

* The configuration option name. *

* An optional extension name. If set, the function return only options * specific for that extension. *

* Retrieve details settings or only the current value for each setting. * Default is TRUE (retrieve details). *

* When details is TRUE (default) the array will * contain global_value (set in * php.ini), local_value (perhaps set with * ini_set or .htaccess), and * access (the access level). *

* When details is FALSE the value will be the * current value of the option. *

* See the manual section * for information on what access levels mean. *

* It's possible for a directive to have multiple access levels, which is * why access shows the appropriate bitmask values. */ function ini_get_all ($extension = null, $details = true) {} /** * (PHP 4, PHP 5)
* Sets the value of a configuration option * @link http://php.net/manual/en/function.ini-set.php * @param string $varname

*

* Not all the available options can be changed using * ini_set. There is a list of all available options * in the appendix. *

* The new value for the option. *

* The configuration option name. *

* The new value for the include_path *

* The name of the cookie. *

* The value of the cookie. This value is stored on the clients computer; * do not store sensitive information. Assuming the * name is 'cookiename', this * value is retrieved through $_COOKIE['cookiename'] *

* The time the cookie expires. This is a Unix timestamp so is * in number of seconds since the epoch. In other words, you'll * most likely set this with the time function * plus the number of seconds before you want it to expire. Or * you might use mktime. * time()+60*60*24*30 will set the cookie to * expire in 30 days. If set to 0, or omitted, the cookie will expire at * the end of the session (when the browser closes). *

*

* You may notice the expire parameter takes on a * Unix timestamp, as opposed to the date format Wdy, DD-Mon-YYYY * HH:MM:SS GMT, this is because PHP does this conversion * internally. *

* The path on the server in which the cookie will be available on. * If set to '/', the cookie will be available * within the entire domain. If set to * '/foo/', the cookie will only be available * within the /foo/ directory and all * sub-directories such as /foo/bar/ of * domain. The default value is the * current directory that the cookie is being set in. *

* The domain that the cookie is available to. Setting the domain to * 'www.example.com' will make the cookie * available in the www subdomain and higher subdomains. * Cookies available to a lower domain, such as * 'example.com' will be available to higher subdomains, * such as 'www.example.com'. * Older browsers still implementing the deprecated * RFC 2109 may require a leading * . to match all subdomains. *

* Indicates that the cookie should only be transmitted over a * secure HTTPS connection from the client. When set to TRUE, the * cookie will only be set if a secure connection exists. * On the server-side, it's on the programmer to send this * kind of cookie only on secure connection (e.g. with respect to * $_SERVER["HTTPS"]). *

* When TRUE the cookie will be made accessible only through the HTTP * protocol. This means that the cookie won't be accessible by * scripting languages, such as JavaScript. It has been suggested that * this setting can effectively help to reduce identity theft through * XSS attacks (although it is not supported by all browsers), but that * claim is often disputed. Added in PHP 5.2.0. * TRUE or FALSE *

* The header string. *

* There are two special-case header calls. The first is a header * that starts with the string "HTTP/" (case is not * significant), which will be used to figure out the HTTP status * code to send. For example, if you have configured Apache to * use a PHP script to handle requests for missing files (using * the ErrorDocument directive), you may want to * make sure that your script generates the proper status code. *

* * header("HTTP/1.0 404 Not Found"); * *

* For FastCGI you must use the following for a 404 response: * * header("Status: 404 Not Found"); * *

* The second special case is the "Location:" header. Not only does * it send this header back to the browser, but it also returns a * REDIRECT (302) status code to the browser * unless the 201 or * a 3xx status code has already been set. *

* * header("Location: http://www.example.com/"); /* Redirect browser * / * /* Make sure that code below does not get executed when we redirect. * / * exit; * *

* The optional replace parameter indicates * whether the header should replace a previous similar header, or * add a second header of the same type. By default it will replace, * but if you pass in FALSE as the second argument you can force * multiple headers of the same type. For example: *

* * header('WWW-Authenticate: Negotiate'); * header('WWW-Authenticate: NTLM', false); * *

* Forces the HTTP response code to the specified value. Note that this * parameter only has an effect if the string is * not empty. *

* The header name to be removed. *

* If the optional file and * line parameters are set, * headers_sent will put the PHP source file name * and line number where output started in the file * and line variables. *

* The line number where the output started. *

* The optional response_code will set the response code. *

* * http_response_code(404); * *

* If set, this function will set the ignore_user_abort ini setting * to the given value. If not, this function will * only return the previous setting without changing it. *

* The filename of the ini file being parsed. *

* By setting the process_sections * parameter to TRUE, you get a multidimensional array, with * the section names and settings included. The default * for process_sections is FALSE *

* Can either be INI_SCANNER_NORMAL (default) or * INI_SCANNER_RAW. If INI_SCANNER_RAW * is supplied, then option values will not be parsed. *

* The contents of the ini file being parsed. *

* By setting the process_sections * parameter to TRUE, you get a multidimensional array, with * the section names and settings included. The default * for process_sections is FALSE *

* Can either be INI_SCANNER_NORMAL (default) or * INI_SCANNER_RAW. If INI_SCANNER_RAW * is supplied, then option values will not be parsed. *

* The filename being checked. *

* The filename of the uploaded file. *

* The destination of the moved file. *

* If filename is not a valid upload file, * then no action will occur, and * move_uploaded_file will return * FALSE. *

* If filename is a valid upload file, but * cannot be moved for some reason, no action will occur, and * move_uploaded_file will return * FALSE. Additionally, a warning will be issued. */ function move_uploaded_file ($filename, $destination) {} /** * (PHP 4, PHP 5)
* Get the Internet host name corresponding to a given IP address * @link http://php.net/manual/en/function.gethostbyaddr.php * @param string $ip_address

* The host IP address. *

* The host name. *

* The host name. *

* host may either be the IP address in * dotted-quad notation or the host name. *

* type may be any one of: A, MX, NS, SOA, * PTR, CNAME, AAAA, A6, SRV, NAPTR, TXT or ANY. *

* The Internet host name. *

* A list of the MX records found is placed into the array * mxhosts. *

* If the weight array is given, it will be filled * with the weight information gathered. *

* hostname should be a valid DNS hostname such * as "www.example.com". Reverse lookups can be generated * using in-addr.arpa notation, but * gethostbyaddr is more suitable for * the majority of reverse lookups. *

* Per DNS standards, email addresses are given in user.host format (for * example: hostmaster.example.com as opposed to hostmaster@example.com), * be sure to check this value and modify if necessary before using it * with a functions such as mail. *

* By default, dns_get_record will search for any * resource records associated with hostname. * To limit the query, specify the optional type * parameter. May be any one of the following: * DNS_A, DNS_CNAME, * DNS_HINFO, DNS_MX, * DNS_NS, DNS_PTR, * DNS_SOA, DNS_TXT, * DNS_AAAA, DNS_SRV, * DNS_NAPTR, DNS_A6, * DNS_ALL or DNS_ANY. *

* Because of eccentricities in the performance of libresolv * between platforms, DNS_ANY will not * always return every record, the slower DNS_ALL * will collect all records more reliably. *

* Passed by reference and, if given, will be populated with Resource * Records for the Authoritative Name Servers. *

* Passed by reference and, if given, will be populated with any * Additional Records. *

* * Other keys in associative arrays dependant on 'type' * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Type	Extra Columns
A	* ip: An IPv4 addresses in dotted decimal notation. *
MX	* pri: Priority of mail exchanger. * Lower numbers indicate greater priority. * target: FQDN of the mail exchanger. * See also dns_get_mx. *
CNAME	* target: FQDN of location in DNS namespace to which * the record is aliased. *
NS	* target: FQDN of the name server which is authoritative * for this hostname. *
PTR	* target: Location within the DNS namespace to which * this record points. *
TXT	* txt: Arbitrary string data associated with this record. *
HINFO	* cpu: IANA number designating the CPU of the machine * referenced by this record. * os: IANA number designating the Operating System on * the machine referenced by this record. * See IANA's Operating System * Names for the meaning of these values. *
SOA	* mname: FQDN of the machine from which the resource * records originated. * rname: Email address of the administrative contain * for this domain. * serial: Serial # of this revision of the requested * domain. * refresh: Refresh interval (seconds) secondary name * servers should use when updating remote copies of this domain. * retry: Length of time (seconds) to wait after a * failed refresh before making a second attempt. * expire: Maximum length of time (seconds) a secondary * DNS server should retain remote copies of the zone data without a * successful refresh before discarding. * minimum-ttl: Minimum length of time (seconds) a * client can continue to use a DNS resolution before it should request * a new resolution from the server. Can be overridden by individual * resource records. *
AAAA	* ipv6: IPv6 address *
A6(PHP >= 5.1.0)	* masklen: Length (in bits) to inherit from the target * specified by chain. * ipv6: Address for this specific record to merge with * chain. * chain: Parent record to merge with * ipv6 data. *
SRV	* pri: (Priority) lowest priorities should be used first. * weight: Ranking to weight which of commonly prioritized * targets should be chosen at random. * target and port: hostname and port * where the requested service can be found. * For additional information see: RFC 2782 *
NAPTR	* order and pref: Equivalent to * pri and weight above. * flags, services, regex, * and replacement: Parameters as defined by * RFC 2915. *

*/ function dns_get_record ($hostname, $type = 'DNS_ANY', array &$authns = null, array &$addtl = null) {} /** * (PHP 4, PHP 5)
* Get the integer value of a variable * @link http://php.net/manual/en/function.intval.php * @param mixed $var

* The scalar value being converted to an integer *

* The base for the conversion *

* The maximum value depends on the system. 32 bit systems have a * maximum signed integer range of -2147483648 to 2147483647. So for example * on such a system, intval('1000000000000') will return * 2147483647. The maximum signed integer value for 64 bit systems is * 9223372036854775807. *

* Strings will most likely return 0 although this depends on the * leftmost characters of the string. The common rules of * integer casting * apply. */ function intval ($var, $base = 10) {} /** * (PHP 4 >= 4.2.0, PHP 5)
* Get float value of a variable * @link http://php.net/manual/en/function.floatval.php * @param mixed $var

* May be any scalar type. floatval should not be used * on objects, as doing so will emit an E_NOTICE level * error and return 1. *

* Strings will most likely return 0 although this depends on the * leftmost characters of the string. The common rules of * float casting * apply. */ function floatval ($var) {} /** * (PHP 4, PHP 5)
* Alias of floatval * @link http://php.net/manual/en/function.doubleval.php * @param $var */ function doubleval ($var) {} /** * (PHP 4, PHP 5)
* Get string value of a variable * @link http://php.net/manual/en/function.strval.php * @param mixed $var

* The variable that is being converted to a string. *

* var may be any scalar type or an object that * implements the __toString() * method. You cannot use strval on arrays or on * objects that do not implement the * __toString() method. *

* The variable being type checked. *

* The variable being converted. *

* Possibles values of type are: * "boolean" (or, since PHP 4.2.0, "bool") * @return bool TRUE on success or FALSE on failure. */ function settype (&$var, $type) {} /** * (PHP 4 >= 4.0.4, PHP 5)
* Finds whether a variable is NULL * @link http://php.net/manual/en/function.is-null.php * @param mixed $var

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The variable being evaluated. *

* The callback function to check *

* If set to TRUE the function only verifies that * name might be a function or method. It will only * reject simple variables that are not strings, or an array that does * not have a valid structure to be used as a callback. The valid ones * are supposed to have only 2 entries, the first of which is an object * or a string, and the second a string. *

* Receives the "callable name". In the example below it is * "someClass::someMethod". Note, however, that despite the implication * that someClass::SomeMethod() is a callable static method, this is not * the case. *

* The file pointer must be valid, and must have been returned by a * successful call to popen. *

* The command *

* The mode *

* If an error occurs, returns FALSE. */ function popen ($command, $mode) {} /** * (PHP 4, PHP 5)
* Outputs a file * @link http://php.net/manual/en/function.readfile.php * @param string $filename

* The filename being read. *

* You can use the optional second parameter and set it to TRUE, if * you want to search for the file in the include_path, too. *

* A context stream resource. *

* The file pointer must be valid, and must point to a file * successfully opened by fopen. *

* Path to the directory. *

* The new umask. *

* The file pointer must be valid, and must point to a file successfully * opened by fopen or fsockopen. *

* Reading ends when length - 1 bytes have been * read, or a newline (which is included in the return value), or an EOF * (whichever comes first). If no length is specified, it will keep * reading from the stream until it reaches the end of the line. *

* Until PHP 4.3.0, omitting it would assume 1024 as the line length. * If the majority of the lines in the file are all larger than 8KB, * it is more resource efficient for your script to specify the maximum * line length. *

* If an error occurs, FALSE is returned. */ function fgets ($handle, $length = null) {} /** * (PHP 4, PHP 5)
* Gets line from file pointer and strip HTML tags * @link http://php.net/manual/en/function.fgetss.php * @param resource $handle The file pointer must be valid, and must point to * a file successfully opened by fopen or * fsockopen (and not yet closed by * fclose).

* Length of the data to be retrieved. *

* You can use the optional third parameter to specify tags which should * not be stripped. *

* If an error occurs, returns FALSE. */ function fgetss ($handle, $length = null, $allowable_tags = null) {} /** * (PHP 4, PHP 5)
* Binary-safe file read * @link http://php.net/manual/en/function.fread.php * @param resource $handle A file system pointer resource * that is typically created using fopen.

* Up to length number of bytes read. *

* If filename is of the form "scheme://...", it * is assumed to be a URL and PHP will search for a protocol handler * (also known as a wrapper) for that scheme. If no wrappers for that * protocol are registered, PHP will emit a notice to help you track * potential problems in your script and then continue as though * filename specifies a regular file. *

* If PHP has decided that filename specifies * a local file, then it will try to open a stream on that file. * The file must be accessible to PHP, so you need to ensure that * the file access permissions allow this access. * If you have enabled safe mode, * or open_basedir further * restrictions may apply. *

* If PHP has decided that filename specifies * a registered protocol, and that protocol is registered as a * network URL, PHP will check to make sure that * allow_url_fopen is * enabled. If it is switched off, PHP will emit a warning and * the fopen call will fail. *

* The list of supported protocols can be found in . Some protocols (also referred to as * wrappers) support context * and/or php.ini options. Refer to the specific page for the * protocol in use for a list of options which can be set. (e.g. * php.ini value user_agent used by the * http wrapper). *

* On the Windows platform, be careful to escape any backslashes * used in the path to the file, or use forward slashes. * * $handle = fopen("c:\\folder\\resource.txt", "r"); * *

* The mode parameter specifies the type of access * you require to the stream. It may be any of the following: * * A list of possible modes for fopen * using mode * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

mode	Description
'r'	* Open for reading only; place the file pointer at the * beginning of the file. *
'r+'	* Open for reading and writing; place the file pointer at * the beginning of the file. *
'w'	* Open for writing only; place the file pointer at the * beginning of the file and truncate the file to zero length. * If the file does not exist, attempt to create it. *
'w+'	* Open for reading and writing; place the file pointer at * the beginning of the file and truncate the file to zero * length. If the file does not exist, attempt to create it. *
'a'	* Open for writing only; place the file pointer at the end of * the file. If the file does not exist, attempt to create it. *
'a+'	* Open for reading and writing; place the file pointer at * the end of the file. If the file does not exist, attempt to * create it. *
'x'	* Create and open for writing only; place the file pointer at the * beginning of the file. If the file already exists, the * fopen call will fail by returning FALSE and * generating an error of level E_WARNING. If * the file does not exist, attempt to create it. This is equivalent * to specifying O_EXCL|O_CREAT flags for the * underlying open(2) system call. *
'x+'	* Create and open for reading and writing; otherwise it has the * same behavior as 'x'. *
'c'	* Open the file for writing only. If the file does not exist, it is * created. If it exists, it is neither truncated (as opposed to * 'w'), nor the call to this function fails (as is * the case with 'x'). The file pointer is * positioned on the beginning of the file. This may be useful if it's * desired to get an advisory lock (see flock) * before attempting to modify the file, as using * 'w' could truncate the file before the lock * was obtained (if truncation is desired, * ftruncate can be used after the lock is * requested). *
'c+'	* Open the file for reading and writing; otherwise it has the same * behavior as 'c'. *

*

* Different operating system families have different line-ending * conventions. When you write a text file and want to insert a line * break, you need to use the correct line-ending character(s) for your * operating system. Unix based systems use \n as the * line ending character, Windows based systems use \r\n * as the line ending characters and Macintosh based systems use * \r as the line ending character. *

* If you use the wrong line ending characters when writing your files, you * might find that other applications that open those files will "look * funny". *

* Windows offers a text-mode translation flag ('t') * which will transparently translate \n to * \r\n when working with the file. In contrast, you * can also use 'b' to force binary mode, which will not * translate your data. To use these flags, specify either * 'b' or 't' as the last character * of the mode parameter. *

* The default translation mode depends on the SAPI and version of PHP that * you are using, so you are encouraged to always specify the appropriate * flag for portability reasons. You should use the 't' * mode if you are working with plain-text files and you use * \n to delimit your line endings in your script, but * expect your files to be readable with applications such as notepad. You * should use the 'b' in all other cases. *

* If you do not specify the 'b' flag when working with binary files, you * may experience strange problems with your data, including broken image * files and strange problems with \r\n characters. *

* For portability, it is strongly recommended that you always * use the 'b' flag when opening files with fopen. *

* Again, for portability, it is also strongly recommended that * you re-write code that uses or relies upon the 't' * mode so that it uses the correct line endings and * 'b' mode instead. *

* The optional third use_include_path parameter * can be set to '1' or TRUE if you want to search for the file in the * include_path, too. *

* The file pointer. *

* The handle must be open for writing. *

* The size to truncate to. *

* If size is larger than the file then the file * is extended with null bytes. *

* If size is smaller than the file then the file * is truncated to that size. *

* The offset. *

* To move to a position before the end-of-file, you need to pass * a negative value in offset and * set whence * to SEEK_END. *

* whence values are: * SEEK_SET - Set position equal to offset bytes. * SEEK_CUR - Set position to current location plus offset. * SEEK_END - Set position to end-of-file plus offset. *

* The file pointer must be valid, and must point to a file successfully * opened by fopen or popen. * ftell gives undefined results for append-only streams * (opened with "a" flag). *

* If an error occurs, returns FALSE. */ function ftell ($handle) {} /** * (PHP 4 >= 4.0.1, PHP 5)
* Flushes the output to a file * @link http://php.net/manual/en/function.fflush.php * @param resource $handle The file pointer must be valid, and must point to * a file successfully opened by fopen or * fsockopen (and not yet closed by * fclose).

* The string that is to be written. *

* If the length argument is given, writing will * stop after length bytes have been written or * the end of string is reached, whichever comes * first. *

* Note that if the length argument is given, * then the magic_quotes_runtime * configuration option will be ignored and no slashes will be * stripped from string. *

* The directory path. *

* The mode is 0777 by default, which means the widest possible * access. For more information on modes, read the details * on the chmod page. *

* mode is ignored on Windows. *

* Note that you probably want to specify the mode as an octal number, * which means it should have a leading zero. The mode is also modified * by the current umask, which you can change using * umask. *

* Allows the creation of nested directories specified in the * pathname. *

*

* The old name. The wrapper used in oldname * must match the wrapper used in * newname. *

* The new name. *

* Path to the source file. *

* The destination path. If dest is a URL, the * copy operation may fail if the wrapper does not support overwriting of * existing files. *

* If the destination file already exists, it will be overwritten. *

* A valid context resource created with * stream_context_create. *

* The directory where the temporary filename will be created. *

* The prefix of the generated temporary filename. *

* Path to the file. *

* The optional parameter flags can be one, or * more, of the following constants: * FILE_USE_INCLUDE_PATH * Search for the file in the include_path. * @param resource $context [optional]

* A context resource created with the * stream_context_create function. *

* Context support was added * with PHP 5.0.0. For a description of contexts, refer to * . *

* Each line in the resulting array will include the line ending, unless * FILE_IGNORE_NEW_LINES is used, so you still need to * use rtrim if you do not want the line ending * present. */ function file ($filename, $flags = 0, $context = null) {} /** * (PHP 4 >= 4.3.0, PHP 5)
* Reads entire file into a string * @link http://php.net/manual/en/function.file-get-contents.php * @param string $filename

* Name of the file to read. *

* As of PHP 5 the FILE_USE_INCLUDE_PATH can be used * to trigger include path * search. *

* A valid context resource created with * stream_context_create. If you don't need to use a * custom context, you can skip this parameter by NULL. *

* The offset where the reading starts on the original stream. *

* Seeking (offset) is not supported with remote files. * Attempting to seek on non-local files may work with small offsets, but this * is unpredictable because it works on the buffered stream. *

* Maximum length of data read. The default is to read until end * of file is reached. Note that this parameter is applied to the * stream processed by the filters. *

* Path to the file where to write the data. *

* The data to write. Can be either a string, an * array or a stream resource. *

* If data is a stream resource, the * remaining buffer of that stream will be copied to the specified file. * This is similar with using stream_copy_to_stream. *

* You can also specify the data parameter as a single * dimension array. This is equivalent to * file_put_contents($filename, implode('', $array)). *

* The value of flags can be any combination of * the following flags, joined with the binary OR (|) * operator. *

* * Available flags * * * * * * * * * * * * * * * * *

Flag	Description
* FILE_USE_INCLUDE_PATH *	* Search for filename in the include directory. * See include_path for more * information. *
* FILE_APPEND *	* If file filename already exists, append * the data to the file instead of overwriting it. *
* LOCK_EX *	* Acquire an exclusive lock on the file while proceeding to the * writing. *

*

* A valid context resource created with * stream_context_create. *

* The streams listed in the read array will be watched to * see if characters become available for reading (more precisely, to see if * a read will not block - in particular, a stream resource is also ready on * end-of-file, in which case an fread will return * a zero length string). *

* The streams listed in the write array will be * watched to see if a write will not block. *

* The streams listed in the except array will be * watched for high priority exceptional ("out-of-band") data arriving. *

* When stream_select returns, the arrays * read, write and * except are modified to indicate which stream * resource(s) actually changed status. *

* The tv_sec and tv_usec * together form the timeout parameter, * tv_sec specifies the number of seconds while * tv_usec the number of microseconds. * The timeout is an upper bound on the amount of time * that stream_select will wait before it returns. * If tv_sec and tv_usec are * both set to 0, stream_select will * not wait for data - instead it will return immediately, indicating the * current status of the streams. *

* If tv_sec is NULL stream_select * can block indefinitely, returning only when an event on one of the * watched streams occurs (or if a signal interrupts the system call). *

* Using a timeout value of 0 allows you to * instantaneously poll the status of the streams, however, it is NOT a * good idea to use a 0 timeout value in a loop as it * will cause your script to consume too much CPU time. *

* It is much better to specify a timeout value of a few seconds, although * if you need to be checking and running other code concurrently, using a * timeout value of at least 200000 microseconds will * help reduce the CPU usage of your script. *

* Remember that the timeout value is the maximum time that will elapse; * stream_select will return as soon as the * requested streams are ready for use. *

* See tv_sec description. *

* Must be an associative array of associative arrays in the format * $arr['wrapper']['option'] = $value. *

* Default to an empty array. *

* Must be an associative array in the format * $arr['parameter'] = $value. * Refer to context parameters for * a listing of standard stream parameters. *

* The stream or context to apply the parameters too. *

* An array of parameters to set. *

* params should be an associative array of the structure: * $params['paramname'] = "paramvalue";. *

* A stream resource or a * context resource *

* The stream or context resource to apply the options too. *

* The stream or context to get options from *

* As of PHP 5.3.0, the stream_context_set_default function * can be used to set the default context. *

* The options to set for the default context. *

* options must be an associative * array of associative arrays in the format * $arr['wrapper']['option'] = $value. *

* The target stream. *

* The filter name. *

* By default, stream_filter_prepend will * attach the filter to the read filter chain * if the file was opened for reading (i.e. File Mode: * r, and/or +). The filter * will also be attached to the write filter chain * if the file was opened for writing (i.e. File Mode: * w, a, and/or +). * STREAM_FILTER_READ, * STREAM_FILTER_WRITE, and/or * STREAM_FILTER_ALL can also be passed to the * read_write parameter to override this behavior. * See stream_filter_append for an example of * using this parameter. *

* This filter will be added with the specified params * to the beginning of the list and will therefore be * called first during stream operations. To add a filter to the end of the * list, use stream_filter_append. *

* The target stream. *

* The filter name. *

* By default, stream_filter_append will * attach the filter to the read filter chain * if the file was opened for reading (i.e. File Mode: * r, and/or +). The filter * will also be attached to the write filter chain * if the file was opened for writing (i.e. File Mode: * w, a, and/or +). * STREAM_FILTER_READ, * STREAM_FILTER_WRITE, and/or * STREAM_FILTER_ALL can also be passed to the * read_write parameter to override this behavior. *

* This filter will be added with the specified * params to the end of * the list and will therefore be called last during stream operations. * To add a filter to the beginning of the list, use * stream_filter_prepend. *

* The stream filter to be removed. *

* Address to the socket to connect to. *

* Will be set to the system level error number if connection fails. *

* Will be set to the system level error message if the connection fails. *

* Number of seconds until the connect() system call * should timeout. * This parameter only applies when not making asynchronous * connection attempts. *

* To set a timeout for reading/writing data over the socket, use the * stream_set_timeout, as the * timeout only applies while making connecting * the socket. *

* Bitmask field which may be set to any combination of connection flags. * Currently the select of connection flags is limited to * STREAM_CLIENT_CONNECT (default), * STREAM_CLIENT_ASYNC_CONNECT and * STREAM_CLIENT_PERSISTENT. *

* A valid context resource created with stream_context_create. *

* The type of socket created is determined by the transport specified * using standard URL formatting: transport://target. *

* For Internet Domain sockets (AF_INET) such as TCP and UDP, the * target portion of the * remote_socket parameter should consist of a * hostname or IP address followed by a colon and a port number. For * Unix domain sockets, the target portion should * point to the socket file on the filesystem. *

* Depending on the environment, Unix domain sockets may not be available. * A list of available transports can be retrieved using * stream_get_transports. See * for a list of bulitin transports. *

* If the optional errno and errstr * arguments are present they will be set to indicate the actual system * level error that occurred in the system-level socket(), * bind(), and listen() calls. If * the value returned in errno is * 0 and the function returned FALSE, it is an * indication that the error occurred before the bind() * call. This is most likely due to a problem initializing the socket. * Note that the errno and * errstr arguments will always be passed by reference. *

* See errno description. *

* A bitmask field which may be set to any combination of socket creation * flags. *

* For UDP sockets, you must use STREAM_SERVER_BIND as * the flags parameter. *

* The server socket to accept a connection from. *

* Override the default socket accept timeout. Time should be given in * seconds. *

* Will be set to the name (address) of the client which connected, if * included and available from the selected transport. *

* Can also be determined later using * stream_socket_get_name. *

* The socket to get the name of. *

* If set to TRUE the remote socket name will be returned, if set * to FALSE the local socket name will be returned. *

* The remote socket. *

* The number of bytes to receive from the socket. *

* The value of flags can be any combination * of the following: * * Possible values for flags * * * * * * * * *

STREAM_OOB	* Process OOB (out-of-band) data. *
STREAM_PEEK	* Retrieve data from the socket, but do not consume the buffer. * Subsequent calls to fread or * stream_socket_recvfrom will see * the same data. *

*

* If address is provided it will be populated with * the address of the remote socket. *

* The socket to send data to. *

* The data to be sent. *

* The value of flags can be any combination * of the following: * * possible values for flags * * * * *

STREAM_OOB

* Process OOB (out-of-band) data. *

*

* The address specified when the socket stream was created will be used * unless an alternate address is specified in address. *

* If specified, it must be in dotted quad (or [ipv6]) format. *

* The stream resource. *

* Enable/disable cryptography on the stream. *

* Setup encryption on the stream. * Valid methods are * STREAM_CRYPTO_METHOD_SSLv2_CLIENT * @param resource $session_stream [optional]

* Seed the stream with settings from session_stream. *

* An open stream (opened with stream_socket_client, * for example) *

* One of the following constants: STREAM_SHUT_RD * (disable further receptions), STREAM_SHUT_WR * (disable further transmissions) or * STREAM_SHUT_RDWR (disable further receptions and * transmissions). *

* The protocol family to be used: STREAM_PF_INET, * STREAM_PF_INET6 or * STREAM_PF_UNIX *

* The type of communication to be used: * STREAM_SOCK_DGRAM, * STREAM_SOCK_RAW, * STREAM_SOCK_RDM, * STREAM_SOCK_SEQPACKET or * STREAM_SOCK_STREAM *

* The protocol to be used: STREAM_IPPROTO_ICMP, * STREAM_IPPROTO_IP, * STREAM_IPPROTO_RAW, * STREAM_IPPROTO_TCP or * STREAM_IPPROTO_UDP *

* The source stream *

* The destination stream *

* Maximum bytes to copy *

* The offset where to start to copy data *

* A stream resource (e.g. returned from fopen) *

* The maximum bytes to read. Defaults to -1 (read all the remaining * buffer). *

* Seek to the specified offset before reading. If this number is negative, * no seeking will occur and reading will start from the current position. *

* The stream to check. *

* A valid file pointer to a file successfully opened by * fopen, popen, or * fsockopen. *

* Must be greater than the longest line (in characters) to be found in * the CSV file (allowing for trailing line-end characters). It became * optional in PHP 5. Omitting this parameter (or setting it to 0 in PHP * 5.0.4 and later) the maximum line length is not limited, which is * slightly slower. *

* Set the field delimiter (one character only). *

* Set the field enclosure character (one character only). *

* Set the escape character (one character only). Defaults as a backslash. *

* A blank line in a CSV file will be returned as an array * comprising a single null field, and will not be treated * as an error. *

* fgetcsv returns NULL if an invalid * handle is supplied or FALSE on other errors, * including end of file. */ function fgetcsv ($handle, $length = 0, $delimiter = ',', $enclosure = '"', $escape = '\\') {} /** * (PHP 5 >= 5.1.0)
* Format line as CSV and write to file pointer * @link http://php.net/manual/en/function.fputcsv.php * @param resource $handle The file pointer must be valid, and must point to * a file successfully opened by fopen or * fsockopen (and not yet closed by * fclose).

* An array of values. *

* The optional delimiter parameter sets the field * delimiter (one character only). *

* The optional enclosure parameter sets the field * enclosure (one character only). *

* operation is one of the following: * LOCK_SH to acquire a shared lock (reader). * @param int $wouldblock [optional]

* The optional third argument is set to TRUE if the lock would block * (EWOULDBLOCK errno condition). (not supported on Windows) *

* The path to the HTML file, as a string. This can be a local file or an * URL. *

* What get_meta_tags parses *

 * 

* Setting use_include_path to TRUE will result * in PHP trying to open the file along the standard include path as per * the include_path directive. * This is used for local files, not URLs. *

* 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. If two meta tags have the same * name, only the last one is returned. */ function get_meta_tags ($filename, $use_include_path = false) {} /** * (PHP 5 >= 5.3.3)
* Set read file buffering on the given stream * @link http://php.net/manual/en/function.stream-set-read-buffer.php * @param resource $stream

* The file pointer. *

* The number of bytes to buffer. If buffer * is 0 then read operations are unbuffered. This ensures that all reads * with fread are completed before other processes are * allowed to read from that input stream. *

* The file pointer. *

* The number of bytes to buffer. If buffer * is 0 then write operations are unbuffered. This ensures that all writes * with fwrite are completed before other processes are * allowed to write to that output stream. *

* The target stream. *

* The desired new chunk size. *

* Will return FALSE if chunk_size is less than 1 or * greater than PHP_INT_MAX. */ function stream_set_chunk_size ($fp, $chunk_size) {} /** * (PHP 4, PHP 5)
* Alias of stream_set_blocking * @link http://php.net/manual/en/function.set-socket-blocking.php * @param $socket * @param $mode */ function set_socket_blocking ($socket, $mode) {} /** * (PHP 4 >= 4.3.0, PHP 5)
* Set blocking/non-blocking mode on a stream * @link http://php.net/manual/en/function.stream-set-blocking.php * @param resource $stream

* The stream. *

* If mode is 0, the given stream * will be switched to non-blocking mode, and if 1, it * will be switched to blocking mode. This affects calls like * fgets and fread * that read from the stream. In non-blocking mode an * fgets call will always return right away * while in blocking mode it will wait for data to become available * on the stream. *

* The stream can be any stream created by fopen, * fsockopen and pfsockopen. *

* timed_out (bool) - TRUE if the stream * timed out while waiting for data on the last call to * fread or fgets. *

* blocked (bool) - TRUE if the stream is * in blocking IO mode. See stream_set_blocking. *

* eof (bool) - TRUE if the stream has reached * end-of-file. Note that for socket streams this member can be TRUE * even when unread_bytes is non-zero. To * determine if there is more data to be read, use * feof instead of reading this item. *

* unread_bytes (int) - the number of bytes * currently contained in the PHP's own internal buffer. *

* stream_type (string) - a label describing * the underlying implementation of the stream. *

* wrapper_type (string) - a label describing * the protocol wrapper implementation layered over the stream. * See for more information about wrappers. *

* wrapper_data (mixed) - wrapper specific * data attached to this stream. See for * more information about wrappers and their wrapper data. *

* filters (array) - and array containing * the names of any filters that have been stacked onto this stream. * Documentation on filters can be found in the * Filters appendix. *

* mode (string) - the type of access required for * this stream (see Table 1 of the fopen() reference) *

* seekable (bool) - whether the current stream can * be seeked. *

* uri (string) - the URI/filename associated with this * stream. */ function stream_get_meta_data ($stream) {} /** * (PHP 5)
* Gets line from stream resource up to a given delimiter * @link http://php.net/manual/en/function.stream-get-line.php * @param resource $handle

* A valid file handle. *

* The number of bytes to read from the handle. *

* An optional string delimiter. *

* If an error occurs, returns FALSE. */ function stream_get_line ($handle, $length, $ending = null) {} /** * (PHP 4 >= 4.3.2, PHP 5)
* Register a URL wrapper implemented as a PHP class * @link http://php.net/manual/en/function.stream-wrapper-register.php * @param string $protocol

* The wrapper name to be registered. *

* The classname which implements the protocol. *

* Should be set to STREAM_IS_URL if * protocol is a URL protocol. Default is 0, local * stream. *

* stream_wrapper_register will return FALSE if the * protocol already has a handler. */ function stream_wrapper_register ($protocol, $classname, $flags = null) {} /** * (PHP 4 >= 4.3.0, PHP 5)
* Alias of stream_wrapper_register * @link http://php.net/manual/en/function.stream-register-wrapper.php * @param $protocol * @param $classname * @param $flags [optional] */ function stream_register_wrapper ($protocol, $classname, $flags) {} /** * (PHP 5 >= 5.1.0)
* Unregister a URL wrapper * @link http://php.net/manual/en/function.stream-wrapper-unregister.php * @param string $protocol * @return bool TRUE on success or FALSE on failure. */ function stream_wrapper_unregister ($protocol) {} /** * (PHP 5 >= 5.1.0)
* Restores a previously unregistered built-in wrapper * @link http://php.net/manual/en/function.stream-wrapper-restore.php * @param string $protocol * @return bool TRUE on success or FALSE on failure. */ function stream_wrapper_restore ($protocol) {} /** * (PHP 5)
* Retrieve list of registered streams * @link http://php.net/manual/en/function.stream-get-wrappers.php * @return array an indexed array containing the name of all stream wrappers * available on the running system. */ function stream_get_wrappers () {} /** * (PHP 5)
* Retrieve list of registered socket transports * @link http://php.net/manual/en/function.stream-get-transports.php * @return array an indexed array of socket transports names. */ function stream_get_transports () {} /** * (PHP 5 >= 5.3.2)
* Resolve filename against the include path * @link http://php.net/manual/en/function.stream-resolve-include-path.php * @param string $filename

* The filename to resolve. *

* A valid context resource created with stream_context_create. *

* The stream resource or URL to check. *

* The target URL. *

* If the optional format parameter is set to non-zero, * get_headers parses the response and sets the * array's keys. *

* The target stream. *

* The seconds part of the timeout to be set. *

* The microseconds part of the timeout to be set. *

* The path being checked. *

* Whilst a path must be supplied, the value can be blank or NULL * In these cases, the value is interpreted as the current directory. *

* realpath returns FALSE on failure, e.g. if * the file does not exist. *

* The running script must have executable permissions on all directories in * the hierarchy, otherwise realpath will return * FALSE. */ function realpath ($path) {} /** * (PHP 4 >= 4.3.0, PHP 5)
* Match filename against a pattern * @link http://php.net/manual/en/function.fnmatch.php * @param string $pattern

* The shell wildcard pattern. *

* The tested string. This function is especially useful for filenames, * but may also be used on regular strings. *

* The average user may be used to shell patterns or at least in their * simplest form to '?' and '*' * wildcards so using fnmatch instead of * preg_match for * frontend search expression input may be way more convenient for * non-programming users. *

* The value of flags can be any combination of * the following flags, joined with the * binary OR (|) operator. * * A list of possible flags for fnmatch * * * * * * * * * * * * * * * * * * * * *

Flag	Description
FNM_NOESCAPE	* Disable backslash escaping. *
FNM_PATHNAME	* Slash in string only matches slash in the given pattern. *
FNM_PERIOD	* Leading period in string must be exactly matched by period in the given pattern. *
FNM_CASEFOLD	* Caseless match. Part of the GNU extension. *

*

* If OpenSSL support is * installed, you may prefix the hostname * with either ssl:// or tls:// to * use an SSL or TLS client connection over TCP/IP to connect to the * remote host. *

* The port number. *

* If provided, holds the system level error number that occurred in the * system-level connect() call. *

* If the value returned in errno is * 0 and the function returned FALSE, it is an * indication that the error occurred before the * connect() call. This is most likely due to a * problem initializing the socket. *

* The error message as a string. *

* The connection timeout, in seconds. *

* If you need to set a timeout for reading/writing data over the * socket, use stream_set_timeout, as the * timeout parameter to * fsockopen only applies while connecting the * socket. *

* The format string consists of format codes * followed by an optional repeater argument. The repeater argument can * be either an integer value or * for repeating to * the end of the input data. For a, A, h, H the repeat count specifies * how many characters of one data argument are taken, for @ it is the * absolute position where to put the next data, for everything else the * repeat count specifies how many data arguments are consumed and packed * into the resulting binary string. *

* Currently implemented formats are: * * pack format characters * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Code	Description
a	NUL-padded string
A	SPACE-padded string
h	Hex string, low nibble first
H	Hex string, high nibble first
c	signed char
C	unsigned char
s	signed short (always 16 bit, machine byte order)
S	unsigned short (always 16 bit, machine byte order)
n	unsigned short (always 16 bit, big endian byte order)
v	unsigned short (always 16 bit, little endian byte order)
i	signed integer (machine dependent size and byte order)
I	unsigned integer (machine dependent size and byte order)
l	signed long (always 32 bit, machine byte order)
L	unsigned long (always 32 bit, machine byte order)
N	unsigned long (always 32 bit, big endian byte order)
V	unsigned long (always 32 bit, little endian byte order)
f	float (machine dependent size and representation)
d	double (machine dependent size and representation)
x	NUL byte
X	Back up one byte
@	NUL-fill to absolute position

*

* See pack for an explanation of the format codes. *

* The packed data. *

* The User Agent to be analyzed. By default, the value of HTTP * User-Agent header is used; however, you can alter this (i.e., look up * another browser's info) by passing this parameter. *

* You can bypass this parameter with a NULL value. *

* If set to TRUE, this function will return an array * instead of an object. *

* The cookies value simply means that the browser * itself is capable of accepting cookies and does not mean the user has * enabled the browser to accept cookies or not. The only way to test if * cookies are accepted is to set one with setcookie, * reload, and check for the value. */ function get_browser ($user_agent = null, $return_array = false) {} /** * (PHP 4, PHP 5)
* One-way string hashing * @link http://php.net/manual/en/function.crypt.php * @param string $str

* The string to be hashed. *

* An optional salt string to base the hashing on. If not provided, the * behaviour is defined by the algorithm implementation and can lead to * unexpected results. *

* The directory path that is to be opened *

* For a description of the context parameter, * refer to the streams section of * the manual. *

* If path is not a valid directory or the * directory can not be opened due to permission restrictions or * filesystem errors, opendir returns FALSE and * generates a PHP error of level * E_WARNING. You can suppress the error output of * opendir by prepending * '@' to the * front of the function name. */ function opendir ($path, $context = null) {} /** * (PHP 4, PHP 5)
* Close directory handle * @link http://php.net/manual/en/function.closedir.php * @param resource $dir_handle [optional]

* The directory handle resource previously opened * with opendir. If the directory handle is * not specified, the last link opened by opendir * is assumed. *

* The new current directory *

* On some Unix variants, getcwd will return * FALSE if any one of the parent directories does not have the * readable or search mode set, even if the current directory * does. See chmod for more information on * modes and permissions. */ function getcwd () {} /** * (PHP 4, PHP 5)
* Rewind directory handle * @link http://php.net/manual/en/function.rewinddir.php * @param resource $dir_handle [optional]

* The directory handle resource previously opened * with opendir. If the directory handle is * not specified, the last link opened by opendir * is assumed. *

* The directory handle resource previously opened * with opendir. If the directory handle is * not specified, the last link opened by opendir * is assumed. *

* Directory to open *

* Context support was added * with PHP 5.0.0. For a description of contexts, refer to * . *

* The directory that will be scanned. *

* By default, the sorted order is alphabetical in ascending order. If * the optional sorting_order is set to * SCANDIR_SORT_DESCENDING, then the sort order is * alphabetical in descending order. If it is set to * SCANDIR_SORT_NONE then the result is unsorted. *

* For a description of the context parameter, * refer to the streams section of * the manual. *

* The pattern. No tilde expansion or parameter substitution is done. *

* Valid flags: * GLOB_MARK - Adds a slash to each directory returned * @return array an array containing the matched files/directories, an empty array * if no file matched or FALSE on error. *

* On some systems it is impossible to distinguish between empty match and an * error. */ function glob ($pattern, $flags = 0) {} /** * (PHP 4, PHP 5)
* Gets last access time of file * @link http://php.net/manual/en/function.fileatime.php * @param string $filename

* Path to the file. *

* Path to the file. *

* Path to the file. *

* Path to the file. *

* Path to the file. *

* Path to the file. *

* Path to the file. *

* For local files, the specific return value is that of the * st_mode member of the structure returned by the C * library's stat function. Exactly which bits are set * can vary from platform to platform, and looking up your specific platform's * documentation is recommended if parsing the non-permission bits of the * return value is required. */ function fileperms ($filename) {} /** * (PHP 4, PHP 5)
* Gets file size * @link http://php.net/manual/en/function.filesize.php * @param string $filename

* Path to the file. *

* Path to the file. *

* Returns FALSE if an error occurs. filetype will also * produce an E_NOTICE message if the stat call fails * or if the file type is unknown. */ function filetype ($filename) {} /** * (PHP 4, PHP 5)
* Checks whether a file or directory exists * @link http://php.net/manual/en/function.file-exists.php * @param string $filename

* Path to the file or directory. *

* On windows, use //computername/share/filename or * \\computername\share\filename to check files on * network shares. *

* This function will return FALSE for symlinks pointing to non-existing * files. *

* This function returns FALSE for files inaccessible due to safe mode restrictions. However these * files still can be included if * they are located in safe_mode_include_dir. *

* The check is done using the real UID/GID instead of the effective one. */ function file_exists ($filename) {} /** * (PHP 4, PHP 5)
* Tells whether the filename is writable * @link http://php.net/manual/en/function.is-writable.php * @param string $filename

* The filename being checked. *

* Path to the file. *

* Path to the file. *

* Path to the file. *

* Path to the file. If filename is a relative * filename, it will be checked relative to the current working * directory. If filename is a symbolic or hard link * then the link will be resolved and checked. If you have enabled safe mode, * or open_basedir further * restrictions may apply. *

* Path to the file. *

* Path to the file. *

* ** Only valid on systems supporting the st_blksize type - other * systems (e.g. Windows) return -1. *

* In case of error, stat returns FALSE. */ function stat ($filename) {} /** * (PHP 4, PHP 5)
* Gives information about a file or symbolic link * @link http://php.net/manual/en/function.lstat.php * @param string $filename

* Path to a file or a symbolic link. *

* Path to the file. *

* A user name or number. *

* Path to the file. *

* A group name or number. *

* Path to the file. *

* User name or number. *

* Path to the symlink. *

* The group specified by name or number. *

* Path to the file. *

* Note that mode is not automatically * assumed to be an octal value, so strings (such as "g+w") will * not work properly. To ensure the expected operation, * you need to prefix mode with a zero (0): *

* * chmod("/somedir/somefile", 755); // decimal; probably incorrect * chmod("/somedir/somefile", "u+rwx,go+rx"); // string; incorrect * chmod("/somedir/somefile", 0755); // octal; correct value of mode * *

* The mode parameter consists of three octal * number components specifying access restrictions for the owner, * the user group in which the owner is in, and to everybody else in * this order. One component can be computed by adding up the needed * permissions for that target user base. Number 1 means that you * grant execute rights, number 2 means that you make the file * writeable, number 4 means that you make the file readable. Add * up these numbers to specify needed rights. You can also read more * about modes on Unix systems with 'man 1 chmod' * and 'man 2 chmod'. *

* * // Read and write for owner, nothing for everybody else * chmod("/somedir/somefile", 0600); * // Read and write for owner, read for everybody else * chmod("/somedir/somefile", 0644); * // Everything for owner, read and execute for others * chmod("/somedir/somefile", 0755); * // Everything for owner, read and execute for owner's group * chmod("/somedir/somefile", 0750); * *

* The name of the file being touched. *

* The touch time. If time is not supplied, * the current system time is used. *

* If present, the access time of the given filename is set to * the value of atime. Otherwise, it is set to * the value passed to the time parameter. * If neither are present, the current system time is used. *

* Whether to clear the realpath cache or not. *

* Clear the realpath and the stat cache for a specific filename only; only * used if clear_realpath_cache is TRUE. *

* A directory of the filesystem or disk partition. *

* A directory of the filesystem or disk partition. *

* Given a file name instead of a directory, the behaviour of the * function is unspecified and may differ between operating systems and * PHP versions. *

* Receiver, or receivers of the mail. *

* The formatting of this string must comply with * RFC 2822. Some examples are: * user@example.com * user@example.com, anotheruser@example.com * User <user@example.com> * User <user@example.com>, Another User <anotheruser@example.com> *

* Subject of the email to be sent. *

* Subject must satisfy RFC 2047. *

* Message to be sent. *

* Each line should be separated with a LF (\n). Lines should not be larger * than 70 characters. *

* (Windows only) When PHP is talking to a SMTP server directly, if a full * stop is found on the start of a line, it is removed. To counter-act this, * replace these occurrences with a double dot. * * $text = str_replace("\n.", "\n..", $text); * *

* String to be inserted at the end of the email header. *

* This is typically used to add extra headers (From, Cc, and Bcc). * Multiple extra headers should be separated with a CRLF (\r\n). *

* When sending mail, the mail must contain * a From header. This can be set with the * additional_headers parameter, or a default * can be set in php.ini. *

* Failing to do this will result in an error * message similar to Warning: mail(): "sendmail_from" not * set in php.ini or custom "From:" header missing. * The From header sets also * Return-Path under Windows. *

* If messages are not received, try using a LF (\n) only. * Some Unix mail transfer agents (most notably * qmail) replace LF by CRLF * automatically (which leads to doubling CR if CRLF is used). * This should be a last resort, as it does not comply with * RFC 2822. *

* The additional_parameters parameter * can be used to pass additional flags as command line options to the * program configured to be used when sending mail, as defined by the * sendmail_path configuration setting. For example, * this can be used to set the envelope sender address when using * sendmail with the -f sendmail option. *

* The user that the webserver runs as should be added as a trusted user to the * sendmail configuration to prevent a 'X-Warning' header from being added * to the message when the envelope sender (-f) is set using this method. * For sendmail users, this file is /etc/mail/trusted-users. *

* It is important to note that just because the mail was accepted for delivery, * it does NOT mean the mail will actually reach the intended destination. */ function mail ($to, $subject, $message, $additional_headers = null, $additional_parameters = null) {} /** * (PHP 4 >= 4.0.2, PHP 5)
* Calculate the hash value needed by EZMLM * @link http://php.net/manual/en/function.ezmlm-hash.php * @param string $addr

* The email address that's being hashed. *

* The string ident is added to each message. *

* The option argument is used to indicate * what logging options will be used when generating a log message. * * openlog Options * * * * * * * * * * * * * * * * * * * * * * * * *

Constant	Description
LOG_CONS	* if there is an error while sending data to the system logger, * write directly to the system console *
LOG_NDELAY	* open the connection to the logger immediately *
LOG_ODELAY	* (default) delay opening the connection until the first * message is logged *
LOG_PERROR	print log message also to standard error
LOG_PID	include PID with each message

* You can use one or more of this options. When using multiple options * you need to OR them, i.e. to open the connection * immediately, write to the console and include the PID in each message, * you will use: LOG_CONS | LOG_NDELAY | LOG_PID *

* The facility argument is used to specify what * type of program is logging the message. This allows you to specify * (in your machine's syslog configuration) how messages coming from * different facilities will be handled. * * openlog Facilities * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Constant	Description
LOG_AUTH	* security/authorization messages (use * LOG_AUTHPRIV instead * in systems where that constant is defined) *
LOG_AUTHPRIV	security/authorization messages (private)
LOG_CRON	clock daemon (cron and at)
LOG_DAEMON	other system daemons
LOG_KERN	kernel messages
LOG_LOCAL0 ... LOG_LOCAL7	reserved for local use, these are not available in Windows
LOG_LPR	line printer subsystem
LOG_MAIL	mail subsystem
LOG_NEWS	USENET news subsystem
LOG_SYSLOG	messages generated internally by syslogd
LOG_USER	generic user-level messages
LOG_UUCP	UUCP subsystem

*

* LOG_USER is the only valid log type under Windows * operating systems *

* priority is a combination of the facility and * the level. Possible values are: * * syslog Priorities (in descending order) * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Constant	Description
LOG_EMERG	system is unusable
LOG_ALERT	action must be taken immediately
LOG_CRIT	critical conditions
LOG_ERR	error conditions
LOG_WARNING	warning conditions
LOG_NOTICE	normal, but significant, condition
LOG_INFO	informational message
LOG_DEBUG	debug-level message

*

* The message to send, except that the two characters * %m will be replaced by the error message string * (strerror) corresponding to the present value of * errno. *

* The input string. *

* This parameter restricts the returned metaphone key to * phonemes characters in length. * The default value of 0 means no restriction. *

* An optional output_callback function may be * specified. This function takes a string as a parameter and should * return a string. The function will be called when * the output buffer is flushed (sent) or cleaned (with * ob_flush, ob_clean or similar * function) or when the output buffer * is flushed to the browser at the end of the request. When * output_callback is called, it will receive the * contents of the output buffer as its parameter and is expected to * return a new output buffer as a result, which will be sent to the * browser. If the output_callback is not a * callable function, this function will return FALSE. *

* If the callback function has two parameters, the second parameter is * filled with a bit-field consisting of * PHP_OUTPUT_HANDLER_* constants. *

* If output_callback returns FALSE original * input is sent to the browser. *

* The output_callback parameter may be bypassed * by passing a NULL value. *

* ob_end_clean, ob_end_flush, * ob_clean, ob_flush and * ob_start may not be called from a callback * function. If you call them from callback function, the behavior is * undefined. If you would like to delete the contents of a buffer, * return "" (a null string) from callback function. * You can't even call functions using the output buffering functions like * print_r($expression, true) or * highlight_file($filename, true) from a callback * function. *

* In PHP 4.0.4, ob_gzhandler was introduced to * facilitate sending gz-encoded data to web browsers that support * compressed web pages. ob_gzhandler determines * what type of content encoding the browser will accept and will return * its output accordingly. *

* If the optional parameter chunk_size is passed, the * buffer will be flushed after any output call which causes the buffer's * length to equal or exceed chunk_size. The default * value 0 means that the output function will only be * called when the output buffer is closed. *

* Prior to PHP 5.4.0, the value 1 was a special case * value that set the chunk size to 4096 bytes. *

* If the optional parameter erase is set to FALSE, * the buffer will not be deleted until the script finishes. * This causes that flushing and cleaning functions would issue a notice * and return FALSE if called. *

* TRUE to return all active output buffer levels. If FALSE or not * set, only the top level output buffer is returned. *

 * Array
 * (
 * [level] => 2
 * [type] => 0
 * [status] => 0
 * [name] => URL-Rewriter
 * [del] => 1
 * )
 * 

* If called with full_status = TRUE an array * with one element for each active output buffer level is returned. * The output level is used as key of the top level array and each array * element itself is another array holding status information * on one active output level. *

 * Array
 * (
 * [0] => Array
 * (
 * [chunk_size] => 0
 * [size] => 40960
 * [block_size] => 10240
 * [type] => 1
 * [status] => 0
 * [name] => default output handler
 * [del] => 1
 * )
 * [1] => Array
 * (
 * [chunk_size] => 0
 * [size] => 40960
 * [block_size] => 10240
 * [type] => 0
 * [buffer_size] => 0
 * [status] => 0
 * [name] => URL-Rewriter
 * [del] => 1
 * )
 * )
 * 

* The full output contains these additional elements: * Full ob_get_status results * KeyValue * chunk_sizeChunk size as set by ob_start * size... * blocksize... */ function ob_get_status ($full_status = null) {} /** * (PHP 4, PHP 5)
* Return the contents of the output buffer * @link http://php.net/manual/en/function.ob-get-contents.php * @return string This will return the contents of the output buffer or FALSE, if output * buffering isn't active. */ function ob_get_contents () {} /** * (PHP 4, PHP 5)
* Turn implicit flush on/off * @link http://php.net/manual/en/function.ob-implicit-flush.php * @param int $flag [optional]

* TRUE to turn implicit flushing on, FALSE otherwise. *

* The input array. *

* You may modify the behavior of the sort using the optional * parameter sort_flags, for details * see sort. *

* The input array. *

* You may modify the behavior of the sort using the optional parameter * sort_flags, for details see * sort. *

* The input array. *

* The input array. *

* The input array. *

* You may modify the behavior of the sort using the optional * parameter sort_flags, for details * see sort. *

* The input array. *

* You may modify the behavior of the sort using the optional parameter * sort_flags, for details see * sort. *

* The input array. *

* The optional second parameter sort_flags * may be used to modify the sorting behavior using these values: *

* Sorting type flags: * SORT_REGULAR - compare items normally * (don't change types) * @return bool TRUE on success or FALSE on failure. */ function sort (array &$array, $sort_flags = 'SORT_REGULAR') {} /** * (PHP 4, PHP 5)
* Sort an array in reverse order * @link http://php.net/manual/en/function.rsort.php * @param array $array

* The input array. *

* You may modify the behavior of the sort using the optional * parameter sort_flags, for details see * sort. *

* The input array. *

* The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. *

* Returning non-integer values from the comparison * function, such as float, will result in an internal cast to * integer of the callback's return value. So values such as * 0.99 and 0.1 will both be cast to an integer value of 0, which will * compare such values as equal. *

* The input array. *

* See usort and uksort for * examples of user-defined comparison functions. *

* The input array. *

* The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. *

* The array. *

* The input array. *

* Typically, funcname takes on two parameters. * The array parameter's value being the first, and * the key/index second. *

* If funcname needs to be working with the * actual values of the array, specify the first parameter of * funcname as a * reference. Then, * any changes made to those elements will be made in the * original array itself. *

* Many internal functions (for example strtolower) * will throw a warning if more than the expected number of argument * are passed in and are not usable directly as * funcname. *

* Only the values of the array may potentially be * changed; its structure cannot be altered, i.e., the programmer cannot * add, unset or reorder elements. If the callback does not respect this * requirement, the behavior of this function is undefined, and * unpredictable. *

* If the optional userdata parameter is supplied, * it will be passed as the third parameter to the callback * funcname. *

* The input array. *

* Typically, funcname takes on two parameters. * The input parameter's value being the first, and * the key/index second. *

* If funcname needs to be working with the * actual values of the array, specify the first parameter of * funcname as a * reference. Then, * any changes made to those elements will be made in the * original array itself. *

* If the optional userdata parameter is supplied, * it will be passed as the third parameter to the callback * funcname. *

* The array or the object. *

* If the optional mode parameter is set to * COUNT_RECURSIVE (or 1), count * will recursively count the array. This is particularly useful for * counting all the elements of a multidimensional array. *

* count can detect recursion to avoid an infinite * loop, but will emit an E_WARNING every time it * does (in case the array contains itself more than once) and return a * count higher than may be expected. *

* count may return 0 for a variable that isn't set, * but it may also return 0 for a variable that has been initialized with an * empty array. Use isset to test if a variable is set. */ function count ($var, $mode = 'COUNT_NORMAL') {} /** * (PHP 4, PHP 5)
* Set the internal pointer of an array to its last element * @link http://php.net/manual/en/function.end.php * @param array $array

* The array. This array is passed by reference because it is modified by * the function. This means you must pass it a real variable and not * a function returning an array because only actual variables may be * passed by reference. *

* The input array. *

* The array being affected. *

* The input array. *

* The array. *

* The array. *

* An array containing the values. *

* An array containing the values. *

* When max is given multiple arrays, the * longest array is returned. If all the arrays have the same length, * max will use lexicographic ordering to find the return * value. *

* When given a string it will be cast as an integer * when comparing. */ function max (array $values) {} /** * (PHP 4, PHP 5)
* Checks if a value exists in an array * @link http://php.net/manual/en/function.in-array.php * @param mixed $needle

* The searched value. *

* If needle is a string, the comparison is done * in a case-sensitive manner. *

* The array. *

* If the third parameter strict is set to TRUE * then the in_array function will also check the * types of the * needle in the haystack. *

* The searched value. *

* If needle is a string, the comparison is done * in a case-sensitive manner. *

* The array. *

* If the third parameter strict is set to TRUE * then the array_search function will search for * identical elements in the * haystack. This means it will also check the * types of the * needle in the haystack, * and objects must be the same instance. *

* If needle is found in haystack * more than once, the first matching key is returned. To return the keys for * all matching values, use array_keys with the optional * search_value parameter instead. */ function array_search ($needle, array $haystack, $strict = false) {} /** * (PHP 4, PHP 5)
* Import variables into the current symbol table from an array * @link http://php.net/manual/en/function.extract.php * @param array $var_array

* Note that prefix is only required if * extract_type is EXTR_PREFIX_SAME, * EXTR_PREFIX_ALL, EXTR_PREFIX_INVALID * or EXTR_PREFIX_IF_EXISTS. If * the prefixed result is not a valid variable name, it is not * imported into the symbol table. Prefixes are automatically separated from * the array key by an underscore character. *

* The way invalid/numeric keys and collisions are treated is determined * by the extract_type. It can be one of the * following values: * EXTR_OVERWRITE * If there is a collision, overwrite the existing variable. * @param string $prefix [optional] Only overwrite the variable if it already exists in the * current symbol table, otherwise do nothing. This is useful * for defining a list of valid variables and then extracting * only those variables you have defined out of * $_REQUEST, for example. * @return int the number of variables successfully imported into the symbol * table. */ function extract (array &$var_array, $extract_type = 'EXTR_OVERWRITE', $prefix = null) {} /** * (PHP 4, PHP 5)
* Create array containing variables and their values * @link http://php.net/manual/en/function.compact.php * @param mixed $varname

* compact takes a variable number of parameters. * Each parameter can be either a string containing the name of the * variable, or an array of variable names. The array can contain other * arrays of variable names inside it; compact * handles it recursively. *

* The first index of the returned array. *

* If start_index is negative, * the first index of the returned array will be * start_index and the following * indices will start from zero * (see example). *

* Number of elements to insert. * Must be greater than zero. *

* Value to use for filling *

* Array of values that will be used as keys. Illegal values * for key will be converted to string. *

* Value to use for filling *

* First value of the sequence. *

* The sequence is ended upon reaching the * end value. *

* If a step value is given, it will be used as the * increment between elements in the sequence. step * should be given as a positive number. If not specified, * step will default to 1. *

* An array being sorted. *

* Optionally another array, or sort options for the * previous array argument: * SORT_ASC, * SORT_DESC, * SORT_REGULAR, * SORT_NUMERIC, * SORT_STRING. *

* Additional arg's. *

* The input array. *

* The pushed value. *

* The array to get the value from. *

* The input array. *

* The input array. *

* The prepended variable. *

* The input array. *

* If offset is positive then the start of removed * portion is at that offset from the beginning of the * input array. If offset * is negative then it starts that far from the end of the * input array. *

* If length is omitted, removes everything * from offset to the end of the array. If * length is specified and is positive, then * that many elements will be removed. If * length is specified and is negative then * the end of the removed portion will be that many elements from * the end of the array. Tip: to remove everything from * offset to the end of the array when * replacement is also specified, use * count($input) for * length. *

* If replacement array is specified, then the * removed elements are replaced with elements from this array. *

* If offset and length * are such that nothing is removed, then the elements from the * replacement array are inserted in the place * specified by the offset. Note that keys in * replacement array are not preserved. *

* If replacement is just one element it is * not necessary to put array() * around it, unless the element is an array itself, an object or NULL. *

* The input array. *

* If offset is non-negative, the sequence will * start at that offset in the array. If * offset is negative, the sequence will * start that far from the end of the array. *

* If length is given and is positive, then * the sequence will have up to that many elements in it. If the array * is shorter than the length, then only the * available array elements will be present. If * length is given and is negative then the * sequence will stop that many elements from the end of the * array. If it is omitted, then the sequence will have everything * from offset up until the end of the * array. *

* Note that array_slice will reorder and reset the * numeric array indices by default. You can change this behaviour by setting * preserve_keys to TRUE. *

* Initial array to merge. *

* Variable list of arrays to merge. *

* Initial array to merge. *

* Variable list of arrays to recursively merge. *

* The array in which elements are replaced. *

* The array from which elements will be extracted. *

* More arrays from which elements will be extracted. * Values from later arrays overwrite the previous values. *

* The array in which elements are replaced. *

* The array from which elements will be extracted. *

* Optional. More arrays from which elements will be extracted. *

* An array containing keys to return. *

* If specified, then only keys containing these values are returned. *

* Determines if strict comparison (===) should be used during the search. *

* The array. *

* The array of values to count *

* The input array. *

* If set to TRUE numeric keys are preserved. * Non-numeric keys are not affected by this setting and will always be preserved. *

* The input array. *

* The callback function. *

* If the optional initial is available, it will * be used at the beginning of the process, or as a final result in case * the array is empty. *

* If the array is empty and initial is not passed, * array_reduce returns NULL. */ function array_reduce (array $input, callable $function, $initial = null) {} /** * (PHP 4, PHP 5)
* Pad array to the specified length with a value * @link http://php.net/manual/en/function.array-pad.php * @param array $input

* Initial array of values to pad. *

* New size of the array. *

* Value to pad if input is less than * pad_size. *

* An array of key/value pairs to be flipped. *

* The array to work on *

* Either CASE_UPPER or * CASE_LOWER (default) *

* The input array. *

* Specifies how many entries you want to pick. Trying to pick more * elements than there are in the array will result in an * E_WARNING level error. *

* The input array. *

* The optional second parameter sort_flags * may be used to modify the sorting behavior using these values: *

* Sorting type flags: * SORT_REGULAR - compare items normally * (don't change types) * @return array the filtered array. */ function array_unique (array $array, $sort_flags = 'SORT_STRING') {} /** * (PHP 4 >= 4.0.1, PHP 5)
* Computes the intersection of arrays * @link http://php.net/manual/en/function.array-intersect.php * @param array $array1

* The array with master values to check. *

* An array to compare values against. *

* The array with master keys to check. *

* An array to compare keys against. *

* Initial array for comparison of the arrays. *

* First array to compare keys against. *

* The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. *

* The first array. *

* The second array. *

* The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. *

* The array with master values to check. *

* An array to compare values against. *

* The first array. *

* The second array. *

* The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. *

* Initial array for comparison of the arrays. *

* First array to compare keys against. *

* The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. *

* The first array. *

* The second array. *

* The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. *

* Key comparison callback function. *

* The array to compare from *

* An array to compare against *

* More arrays to compare against *

* The array to compare from *

* An array to compare against *

* More arrays to compare against *

* The array to compare from *

* An array to compare against *

* More arrays to compare against *

* The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. *

* The first array. *

* The second array. *

* The callback comparison function. *

* The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. *

* The array to compare from *

* An array to compare against *

* More arrays to compare against *

* The first array. *

* The second array. *

* The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. *

* The array to compare from *

* An array to compare against *

* More arrays to compare against *

* The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. *

* The first array. *

* The second array. *

* The comparison function must return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second. *

* The comparison of keys (indices) is done also by the callback function * key_compare_func. This behaviour is unlike what * array_udiff_assoc does, since the latter compares * the indices by using an internal function. *

* The input array. *

* The array. *

* The array to iterate over *

* The callback function to use *

* If no callback is supplied, all entries of * input equal to FALSE (see * converting to * boolean) will be removed. *

* Callback function to run for each element in each array. *

* An array to run through the callback function. *

* The array to work on *

* The size of each chunk *

* When set to TRUE keys will be preserved. * Default is FALSE which will reindex the chunk numerically *

* Array of keys to be used. Illegal values for key will be * converted to string. *

* Array of values to be used *

* Value to check. *

* An array with keys to check. *

* The assertion. *

* An optional description that will be included in the failure message if * the assertion fails. *

* * Assert Options * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * NULL) * * *

Option	INI Setting	Default value	Description
ASSERT_ACTIVE	assert.active	1	enable assert evaluation
ASSERT_WARNING	assert.warning	1	issue a PHP warning for each failed assertion
ASSERT_BAIL	assert.bail	0	terminate execution on failed assertions
ASSERT_QUIET_EVAL	assert.quiet_eval	0	* disable error_reporting during assertion expression * evaluation *
ASSERT_CALLBACK	assert.callback	Callback to call on failed assertions

*

* An optional new value for the option. *

* First version number. *

* Second version number. *

* If you specify the third optional operator * argument, you can test for a particular relationship. The * possible operators are: <, * lt, <=, * le, >, * gt, >=, * ge, ==, * =, eq, * !=, <>, * ne respectively. *

* This parameter is case-sensitive, so values should be lowercase. *

* When using the optional operator argument, the * function will return TRUE if the relationship is the one specified * by the operator, FALSE otherwise. */ function version_compare ($version1, $version2, $operator = null) {} /** * (PHP 4 >= 4.2.0, PHP 5)
* Convert a pathname and a project identifier to a System V IPC key * @link http://php.net/manual/en/function.ftok.php * @param string $pathname

* Path to an accessible file. *

* Project identifier. This must be a one character string. *

* The input string. *

* The filter name to be registered. *

* To implement a filter, you need to define a class as an extension of * php_user_filter with a number of member * functions. When performing read/write operations on the stream * to which your filter is attached, PHP will pass the data through your * filter (and any other filters attached to that stream) so that the * data may be modified as desired. You must implement the methods * exactly as described in php_user_filter - doing * otherwise will lead to undefined behaviour. *

* stream_filter_register will return FALSE if the * filtername is already defined. */ function stream_filter_register ($filtername, $classname) {} /** * (PHP 5)
* Return a bucket object from the brigade for operating on * @link http://php.net/manual/en/function.stream-bucket-make-writeable.php * @param resource $brigade * @return object */ function stream_bucket_make_writeable ($brigade) {} /** * (PHP 5)
* Prepend bucket to brigade * @link http://php.net/manual/en/function.stream-bucket-prepend.php * @param resource $brigade

* brigade is a resource pointing to a bucket brigade * which contains one or more bucket objects. *

* A bucket object. *

* The variable name. *

* The variable value. *

* Text mode (since PHP 5.2.7). *

* This constant has no effect, and is only available for * forward compatibility. *

* Binary mode (since PHP 5.2.7). *

* This constant has no effect, and is only available for * forward compatibility. *