@inst/vscode-bin-darwin/Visual Studio Code.app/Contents/Resources/app/extensions/php/out/features/phpGlobals.js

BINARY ONLY - VSCode binary deployment for macOS

"use strict";
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.globalfunctions = {
    password_get_info: {
        description: 'Returns information about the given hash. (5.5 only)',
        signature: '( string $hash ): array'
    },
    password_hash: {
        description: 'Creates a password hash. (5.5 only)',
        signature: '( string $password , integer $algo [, array $options ] ): string'
    },
    password_needs_rehash: {
        description: 'Checks if the given hash matches the given options. (5.5 only)',
        signature: '( string $hash , string $algo [, string $options ] ): boolean'
    },
    password_verify: {
        description: 'Verifies that a password matches a hash. (5.5 only)',
        signature: '( string $password , string $hash ): boolean'
    },
    hex2bin: {
        description: 'Decodes a hexadecimally encoded binary string. (5.4 only)',
        signature: '(string $data): string'
    },
    http_response_code: {
        description: 'If you pass no parameters then http_response_code will get the current status code. If you pass a parameter it will set the response code. (5.4 only)',
        signature: '([ int $response_code ] ): int'
    },
    get_declared_traits: {
        description: 'Returns an array of all declared traits. (5.4 only)',
        signature: '( void ): array'
    },
    getimagesizefromstring: {
        description: 'Get the size of an image from a string. (5.4 only)',
    },
    socket_import_stream: {
        description: 'Imports a stream that encapsulates a socket into a socket extension resource. (5.4 only)',
        signature: '( resource $stream ): void'
    },
    stream_set_chunk_size: {
        description: 'Set the stream chunk size. (5.4 only)',
    },
    trait_exists: {
        description: 'Checks if the trait exists. (5.4 only)',
        signature: '( string $traitname [, bool $autoload ] ): bool'
    },
    header_register_callback: {
        description: 'Registers a function that will be called when PHP starts sending output.  The callback is executed just after PHP prepares all headers to be sent, and before any other output is sent, creating a window to manipulate the outgoing headers before being sent. (5.4 only)',
        signature: '( callable $callback ): bool'
    },
    class_uses: {
        description: 'Returns an array with the names of the traits that the given class uses. This does however not include any traits used by a parent class. (5.4 only)',
        signature: '( mixed $class [, bool $autoload = true ] ): array'
    },
    session_status: {
        description: 'Returns the current session status. (5.4 only)',
        signature: '( void ): int'
    },
    session_register_shutdown: {
        description: 'Registers session_write_close() as a shutdown function. (5.4 only)',
        signature: '( void ): void'
    },
    mysqli_error_list: {
        description: 'Returns a array of errors for the most recent MySQLi function call that can succeed or fail. (5.4 only)',
        signature: '( mysqli $link ): array'
    },
    mysqli_stmt_error_list: {
        description: 'Returns an array of errors for the most recently invoked statement function that can succeed or fail. (5.4 only)',
        signature: '( mysqli_stmt $stmt ): array'
    },
    libxml_set_external_entity_loader: {
        description: 'Changes the default external entity loader. (5.4 only)',
        signature: '( callable $resolver_function ): void'
    },
    zlib_decode: {
        description: 'Uncompress any raw/gzip/zlib encoded data. (5.4 only)',
        signature: '( string $data [, string $max_decoded_len ] ): string'
    },
    zlib_encode: {
        description: 'Compress data with the specified encoding. (5.4 only)',
        signature: '( string $data , string $encoding [, string $level = -1 ] ): string'
    },
    zend_version: {
        description: 'Returns a string containing the version of the currently running Zend Engine.',
        signature: '(void): string'
    },
    func_num_args: {
        description: 'Gets the number of arguments passed to the function.',
        signature: '(void): int'
    },
    func_get_arg: {
        description: 'Gets the specified argument from a user-defined function\'s argument list.',
        signature: '(int $arg_num): mixed'
    },
    func_get_args: {
        description: 'Gets an array of the function\'s argument list.',
        signature: '(void): array'
    },
    strlen: {
        description: 'Returns the length of the given string.',
        signature: '(string $string): int'
    },
    strcmp: {
        description: 'Note that this comparison is case sensitive.',
        signature: '(string $str1 , string $str2): int'
    },
    strncmp: {
        description: 'This function is similar to strcmp(), with the difference that you can specify the (upper limit of the) number of characters from each string to be used in the comparison.',
        signature: '(string $str1 , string $str2 , int $len): int'
    },
    strcasecmp: {
        description: 'Binary safe case-insensitive string comparison.',
        signature: '(string $str1 , string $str2): int'
    },
    strncasecmp: {
        description: 'This function is similar to strcasecmp(), with the difference that you can specify the (upper limit of the) number of characters from each string to be used in the comparison.',
        signature: '(string $str1 , string $str2 , int $len): int'
    },
    each: {
        description: 'Return the current key and value pair from an array and advance the array cursor.',
        signature: '(array &$array): array'
    },
    error_reporting: {
        description: 'The error_reporting() function sets the error_reporting directive at runtime. PHP has many levels of errors, using this function sets that level for the duration (runtime) of your script. If the optional level is not set, error_reporting() will just return the current error reporting level.',
        signature: '([ int $level ]): int'
    },
    define: {
        description: 'Defines a named constant at runtime.',
        signature: '(string $name , mixed $value [, bool $case_insensitive = false ]): bool'
    },
    defined: {
        description: 'Checks whether the given constant exists and is defined.',
        signature: '(string $name): bool'
    },
    get_class: {
        description: 'Gets the name of the class of the given object.',
        signature: '([ object $object = NULL ]): string'
    },
    get_called_class: {
        description: 'Gets the name of the class the static method is called in.',
        signature: '(void): string'
    },
    get_parent_class: {
        description: 'Retrieves the parent class name for object or class.',
        signature: '([ mixed $object ]): string'
    },
    method_exists: {
        description: 'Checks if the class method exists in the given object.',
        signature: '(mixed $object , string $method_name): bool'
    },
    property_exists: {
        description: 'This function checks if the given property exists in the specified class.',
        signature: '(mixed $class , string $property): bool'
    },
    class_exists: {
        description: 'This function checks whether or not the given class has been defined.',
        signature: '(string $class_name [, bool $autoload = true ]): bool'
    },
    interface_exists: {
        description: 'Checks if the given interface has been defined.',
        signature: '(string $interface_name [, bool $autoload = true ]): bool'
    },
    function_exists: {
        description: 'Checks the list of defined functions, both built-in (internal) and user-defined, for function_name.',
        signature: '(string $function_name): bool'
    },
    class_alias: {
        description: 'Creates an alias named alias based on the defined class original. The aliased class is exactly the same as the original class.',
        signature: '([ string $original [, string $alias ]]): bool'
    },
    get_included_files: {
        description: 'Gets the names of all files that have been included using include(), include_once(), require() or require_once().',
        signature: '(void): array'
    },
    get_required_files: {
        description: 'Alias of get_included_files get_magic_quotes_runtime getenv PHP Options/Info Functions PHP Manual get_required_files (PHP 4, PHP 5)',
    },
    is_subclass_of: {
        description: 'Checks if the given object has the class class_name as one of its parents.',
        signature: '(mixed $object , string $class_name): bool'
    },
    is_a: {
        description: 'Checks if the given object is of this class or has this class as one of its parents.',
        signature: '(object $object , string $class_name): bool'
    },
    get_class_vars: {
        description: 'Get the default properties of the given class.',
        signature: '(string $class_name): array'
    },
    get_object_vars: {
        description: 'Gets the accessible non-static properties of the given object according to scope.',
        signature: '(object $object): array'
    },
    get_class_methods: {
        description: 'Gets the class methods names.',
        signature: '(mixed $class_name): array'
    },
    trigger_error: {
        description: 'Used to trigger a user error condition, it can be used by in conjunction with the built-in error handler, or with a user defined function that has been set as the new error handler (set_error_handler()).',
        signature: '(string $error_msg [, int $error_type = E_USER_NOTICE ]): bool'
    },
    user_error: {
        description: 'Alias of trigger_error trigger_error htscanner Error Handling Functions PHP Manual user_error (PHP 4, PHP 5)',
    },
    set_error_handler: {
        description: 'Sets a user function (error_handler) to handle errors in a script.',
        signature: '(callback $error_handler [, int $error_types = E_ALL | E_STRICT ]): mixed'
    },
    restore_error_handler: {
        description: 'Used after changing the error handler function using set_error_handler(), to revert to the previous error handler (which could be the built-in or a user defined function).',
        signature: '(void): bool'
    },
    set_exception_handler: {
        description: 'Sets the default exception handler if an exception is not caught within a try/catch block. Execution will stop after the exception_handler is called.',
        signature: '(callback $exception_handler): callback'
    },
    restore_exception_handler: {
        description: 'Used after changing the exception handler function using set_exception_handler(), to revert to the previous exception handler (which could be the built-in or a user defined function).',
        signature: '(void): bool'
    },
    get_declared_classes: {
        description: 'Gets the declared classes.',
        signature: '(void): array'
    },
    get_declared_interfaces: {
        description: 'Gets the declared interfaces.',
        signature: '(void): array'
    },
    get_defined_functions: {
        description: 'Gets an array of all defined functions.',
        signature: '(void): array'
    },
    get_defined_vars: {
        description: 'This function returns a multidimensional array containing a list of all defined variables, be them environment, server or user-defined variables, within the scope that get_defined_vars() is called.',
        signature: '(void): array'
    },
    create_function: {
        description: 'Creates an anonymous function from the parameters passed, and returns a unique name for it.',
        signature: '(string $args , string $code): string'
    },
    get_resource_type: {
        description: 'This function gets the type of the given resource.',
        signature: '(resource $handle): string'
    },
    get_loaded_extensions: {
        description: 'This function returns the names of all the modules compiled and loaded in the PHP interpreter.',
        signature: '([ bool $zend_extensions = false ]): array'
    },
    extension_loaded: {
        description: 'Finds out whether the extension is loaded.',
        signature: '(string $name): bool'
    },
    get_extension_funcs: {
        description: 'This function returns the names of all the functions defined in the module indicated by module_name.',
        signature: '(string $module_name): array'
    },
    get_defined_constants: {
        description: 'Returns the names and values of all the constants currently defined. This includes those created by extensions as well as those created with the define() function.',
        signature: '([ bool $categorize = false ]): array'
    },
    debug_backtrace: {
        description: 'debug_backtrace() generates a PHP backtrace.',
        signature: '([ int $options = DEBUG_BACKTRACE_PROVIDE_OBJECT [, int $limit = 0 ]]): array'
    },
    debug_print_backtrace: {
        description: 'debug_print_backtrace() prints a PHP backtrace. It prints the function calls, included/required files and eval()ed stuff.',
        signature: '([ int $options = 0 [, int $limit = 0 ]]): void'
    },
    gc_collect_cycles: {
        description: 'This function is currently not documented; only its argument list is available.',
        signature: '(void): int'
    },
    gc_enabled: {
        description: 'This function is currently not documented; only its argument list is available.',
        signature: '(void): bool'
    },
    gc_enable: {
        description: 'This function is currently not documented; only its argument list is available.',
        signature: '(void): void'
    },
    gc_disable: {
        description: 'This function is currently not documented; only its argument list is available.',
        signature: '(void): void'
    },
    bcadd: {
        description: 'Sums left_operand and right_operand.',
        signature: '(string $left_operand , string $right_operand [, int $scale ]): string'
    },
    bcsub: {
        description: 'Subtracts the right_operand from the left_operand.',
        signature: '(string $left_operand , string $right_operand [, int $scale ]): string'
    },
    bcmul: {
        description: 'Multiply the left_operand by the right_operand.',
        signature: '(string $left_operand , string $right_operand [, int $scale ]): string'
    },
    bcdiv: {
        description: 'Divides the left_operand by the right_operand.',
        signature: '(string $left_operand , string $right_operand [, int $scale ]): string'
    },
    bcmod: {
        description: 'Get the modulus of the left_operand using modulus.',
        signature: '(string $left_operand , string $modulus): string'
    },
    bcpow: {
        description: 'Raise left_operand to the power right_operand.',
        signature: '(string $left_operand , string $right_operand [, int $scale ]): string'
    },
    bcsqrt: {
        description: 'Return the square root of the operand.',
        signature: '(string $operand [, int $scale ]): string'
    },
    bcscale: {
        description: 'Sets the default scale parameter for all subsequent bc math functions that do not explicitly specify a scale parameter.',
        signature: '(int $scale): bool'
    },
    bccomp: {
        description: 'Compares the left_operand to the right_operand and returns the result as an integer.',
        signature: '(string $left_operand , string $right_operand [, int $scale ]): int'
    },
    bcpowmod: {
        description: 'Use the fast-exponentiation method to raise left_operand to the power right_operand with respect to the modulus modulus.',
        signature: '(string $left_operand , string $right_operand , string $modulus [, int $scale ]): string'
    },
    jdtogregorian: {
        description: 'Converts Julian Day Count to a string containing the Gregorian date in the format of \"month/day/year\".',
        signature: '(int $julianday): string'
    },
    gregoriantojd: {
        description: 'Valid Range for Gregorian Calendar 4714 B.C. to 9999 A.D.',
        signature: '(int $month , int $day , int $year): int'
    },
    jdtojulian: {
        description: 'Converts Julian Day Count to a string containing the Julian Calendar Date in the format of \"month/day/year\".',
        signature: '(int $julianday): string'
    },
    juliantojd: {
        description: 'Valid Range for Julian Calendar 4713 B.C. to 9999 A.D.',
        signature: '(int $month , int $day , int $year): int'
    },
    jdtojewish: {
        description: 'Converts a Julian Day Count to the Jewish Calendar.',
        signature: '(int $juliandaycount [, bool $hebrew = false [, int $fl = 0 ]]): string'
    },
    jewishtojd: {
        description: 'Although this function can handle dates all the way back to the year 1 (3761 B.C.), such use may not be meaningful. The Jewish calendar has been in use for several thousand years, but in the early days there was no formula to determine the start of a month. A new month was started when the new moon was first observed.',
        signature: '(int $month , int $day , int $year): int'
    },
    jdtofrench: {
        description: 'Converts a Julian Day Count to the French Republican Calendar.',
        signature: '(int $juliandaycount): string'
    },
    frenchtojd: {
        description: 'Converts a date from the French Republican Calendar to a Julian Day Count.',
        signature: '(int $month , int $day , int $year): int'
    },
    jddayofweek: {
        description: 'Returns the day of the week. Can return a string or an integer depending on the mode.',
        signature: '(int $julianday [, int $mode = CAL_DOW_DAYNO ]): mixed'
    },
    jdmonthname: {
        description: 'Returns a string containing a month name. mode tells this function which calendar to convert the Julian Day Count to, and what type of month names are to be returned. Calendar modes Mode Meaning Values 0 Gregorian - abbreviated Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec 1 Gregorian January, February, March, April, May, June, July, August, September, October, November, December 2 Julian - abbreviated Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec 3 Julian January, February, March, April, May, June, July, August, September, October, November, December 4 Jewish Tishri, Heshvan, Kislev, Tevet, Shevat, AdarI, AdarII, Nisan, Iyyar, Sivan, Tammuz, Av, Elul 5 French Republican Vendemiaire, Brumaire, Frimaire, Nivose, Pluviose, Ventose, Germinal, Floreal, Prairial, Messidor, Thermidor, Fructidor, Extra',
        signature: '(int $julianday , int $mode): string'
    },
    easter_date: {
        description: 'Returns the Unix timestamp corresponding to midnight on Easter of the given year.',
        signature: '([ int $year ]): int'
    },
    easter_days: {
        description: 'Returns the number of days after March 21 on which Easter falls for a given year. If no year is specified, the current year is assumed.',
        signature: '([ int $year [, int $method = CAL_EASTER_DEFAULT ]]): int'
    },
    unixtojd: {
        description: 'Return the Julian Day for a Unix timestamp (seconds since 1.1.1970), or for the current day if no timestamp is given.',
        signature: '([ int $timestamp = time() ]): int'
    },
    jdtounix: {
        description: 'This function will return a Unix timestamp corresponding to the Julian Day given in jday or FALSE if jday is not inside the Unix epoch (Gregorian years between 1970 and 2037 or 2440588 <= jday <= 2465342). The time returned is localtime (and not GMT).',
        signature: '(int $jday): int'
    },
    cal_to_jd: {
        description: 'cal_to_jd() calculates the Julian day count for a date in the specified calendar. Supported calendars are CAL_GREGORIAN, CAL_JULIAN, CAL_JEWISH and CAL_FRENCH.',
        signature: '(int $calendar , int $month , int $day , int $year): int'
    },
    cal_from_jd: {
        description: 'cal_from_jd() converts the Julian day given in jd into a date of the specified calendar. Supported calendar values are CAL_GREGORIAN, CAL_JULIAN, CAL_JEWISH and CAL_FRENCH.',
        signature: '(int $jd , int $calendar): array'
    },
    cal_days_in_month: {
        description: 'This function will return the number of days in the month of year for the specified calendar.',
        signature: '(int $calendar , int $month , int $year): int'
    },
    cal_info: {
        description: 'cal_info() returns information on the specified calendar.',
        signature: '([ int $calendar = -1 ]): array'
    },
    variant_set: {
        description: 'Converts value to a variant and assigns it to the variant object; no new variant object is created, and the old value of variant is freed/released.',
        signature: '(variant $variant , mixed $value): void'
    },
    variant_add: {
        description: 'Adds left to right using the following rules (taken from the MSDN library), which correspond to those of Visual Basic: Variant Addition Rules If Then Both expressions are of the string type Concatenation One expression is a string type and the other a character Addition One expression is numeric and the other is a string Addition Both expressions are numeric Addition Either expression is NULL NULL is returned Both expressions are empty Integer subtype is returned',
        signature: '(mixed $left , mixed $right): mixed'
    },
    variant_cat: {
        description: 'Concatenates left with right and returns the result.',
        signature: '(mixed $left , mixed $right): mixed'
    },
    variant_sub: {
        description: 'Subtracts right from left.',
        signature: '(mixed $left , mixed $right): mixed'
    },
    variant_mul: {
        description: 'Multiplies left by right.',
        signature: '(mixed $left , mixed $right): mixed'
    },
    variant_and: {
        description: 'Performs a bitwise AND operation. Note that this is slightly different from a regular AND operation.',
        signature: '(mixed $left , mixed $right): mixed'
    },
    variant_div: {
        description: 'Divides left by right and returns the result.',
        signature: '(mixed $left , mixed $right): mixed'
    },
    variant_eqv: {
        description: 'Performs a bitwise equivalence on two variants.',
        signature: '(mixed $left , mixed $right): mixed'
    },
    variant_idiv: {
        description: 'Converts left and right to integer values, and then performs integer division.',
        signature: '(mixed $left , mixed $right): mixed'
    },
    variant_imp: {
        description: 'Performs a bitwise implication operation.',
        signature: '(mixed $left , mixed $right): mixed'
    },
    variant_mod: {
        description: 'Divides left by right and returns the remainder.',
        signature: '(mixed $left , mixed $right): mixed'
    },
    variant_or: {
        description: 'Performs a bitwise OR operation. Note that this is slightly different from a regular OR operation.',
        signature: '(mixed $left , mixed $right): mixed'
    },
    variant_pow: {
        description: 'Returns the result of left to the power of right.',
        signature: '(mixed $left , mixed $right): mixed'
    },
    variant_xor: {
        description: 'Performs a logical exclusion.',
        signature: '(mixed $left , mixed $right): mixed'
    },
    variant_abs: {
        description: 'Returns the absolute value of a variant.',
        signature: '(mixed $val): mixed'
    },
    variant_fix: {
        description: 'Gets the integer portion of a variant.',
        signature: '(mixed $variant): mixed'
    },
    variant_int: {
        description: 'Gets the integer portion of a variant.',
        signature: '(mixed $variant): mixed'
    },
    variant_neg: {
        description: 'Performs logical negation of variant.',
        signature: '(mixed $variant): mixed'
    },
    variant_not: {
        description: 'Performs bitwise not negation on variant and returns the result.',
        signature: '(mixed $variant): mixed'
    },
    variant_round: {
        description: 'Returns the value of variant rounded to decimals decimal places.',
        signature: '(mixed $variant , int $decimals): mixed'
    },
    variant_cmp: {
        description: 'Compares left with right.',
        signature: '(mixed $left , mixed $right [, int $lcid [, int $flags ]]): int'
    },
    variant_date_to_timestamp: {
        description: 'Converts variant from a VT_DATE (or similar) value into a Unix timestamp. This allows easier interopability between the Unix-ish parts of PHP and COM.',
        signature: '(variant $variant): int'
    },
    variant_date_from_timestamp: {
        description: 'Converts timestamp from a unix timestamp value into a variant of type VT_DATE. This allows easier interopability between the unix-ish parts of PHP and COM.',
        signature: '(int $timestamp): variant'
    },
    variant_get_type: {
        description: 'Returns the type of a variant object.',
        signature: '(variant $variant): int'
    },
    variant_set_type: {
        description: 'This function is similar to variant_cast() except that the variant is modified \"in-place\"; no new variant is created. The parameters for this function have identical meaning to those of variant_cast().',
        signature: '(variant $variant , int $type): void'
    },
    variant_cast: {
        description: 'This function makes a copy of variant and then performs a variant cast operation to force the copy to have the type given by type.',
        signature: '(variant $variant , int $type): variant'
    },
    com_create_guid: {
        description: 'Generates a Globally Unique Identifier (GUID).',
        signature: '(void): string'
    },
    com_event_sink: {
        description: 'Instructs COM to sink events generated by comobject into the PHP object sinkobject.',
        signature: '(variant $comobject , object $sinkobject [, mixed $sinkinterface ]): bool'
    },
    com_print_typeinfo: {
        description: 'The purpose of this function is to help generate a skeleton class for use as an event sink. You may also use it to generate a dump of any COM object, provided that it supports enough of the introspection interfaces, and that you know the name of the interface you want to display.',
        signature: '(object $comobject [, string $dispinterface [, bool $wantsink = false ]]): bool'
    },
    com_message_pump: {
        description: 'This function will sleep for up to timeoutms milliseconds, or until a message arrives in the queue.',
        signature: '([ int $timeoutms = 0 ]): bool'
    },
    com_load_typelib: {
        description: 'Loads a type-library and registers its constants in the engine, as though they were defined using define().',
        signature: '(string $typelib_name [, bool $case_insensitive = true ]): bool'
    },
    com_get_active_object: {
        description: 'com_get_active_object() is similar to creating a new instance of a COM object, except that it will only return an object to your script if the object is already running. OLE applications use something known as the Running Object Table to allow well-known applications to be launched only once; this function exposes the COM library function GetActiveObject() to get a handle on a running instance.',
        signature: '(string $progid [, int $code_page ]): variant'
    },
    ctype_alnum: {
        description: 'Checks if all of the characters in the provided string, text, are alphanumeric. In the standard C locale letters are just [A-Za-z].',
        signature: '(string $text): bool'
    },
    ctype_alpha: {
        description: 'Checks if all of the characters in the provided string, text, are alphabetic. In the standard C locale letters are just [A-Za-z] and ctype_alpha() is equivalent to (ctype_upper($text) || ctype_lower($text)) if $text is just a single character, but other languages have letters that are considered neither upper nor lower case.',
        signature: '(string $text): bool'
    },
    ctype_cntrl: {
        description: 'Checks if all of the characters in the provided string, text, are control characters. Control characters are e.g. line feed, tab, escape.',
        signature: '(string $text): bool'
    },
    ctype_digit: {
        description: 'Checks if all of the characters in the provided string, text, are numerical.',
        signature: '(string $text): bool'
    },
    ctype_lower: {
        description: 'Checks if all of the characters in the provided string, text, are lowercase letters.',
        signature: '(string $text): bool'
    },
    ctype_graph: {
        description: 'Checks if all of the characters in the provided string, text, creates visible output.',
        signature: '(string $text): bool'
    },
    ctype_print: {
        description: 'Checks if all of the characters in the provided string, text, are printable.',
        signature: '(string $text): bool'
    },
    ctype_punct: {
        description: 'Checks if all of the characters in the provided string, text, are punctuation character.',
        signature: '(string $text): bool'
    },
    ctype_space: {
        description: 'Checks if all of the characters in the provided string, text, creates whitespace.',
        signature: '(string $text): bool'
    },
    ctype_upper: {
        description: 'Checks if all of the characters in the provided string, text, are uppercase characters.',
        signature: '(string $text): bool'
    },
    ctype_xdigit: {
        description: 'Checks if all of the characters in the provided string, text, are hexadecimal \'digits\'.',
        signature: '(string $text): bool'
    },
    strtotime: {
        description: 'The function expects to be given a string containing an English date format and will try to parse that format into a Unix timestamp (the number of seconds since January 1 1970 00:00:00 UTC), relative to the timestamp given in now, or the current time if now is not supplied.',
        signature: '(string $time [, int $now ]): int'
    },
    date: {
        description: 'Returns a string formatted according to the given format string using the given integer timestamp or the current time if no timestamp is given. In other words, timestamp is optional and defaults to the value of time().',
        signature: '(string $format [, int $timestamp = time() ]): string'
    },
    idate: {
        description: 'Returns a number formatted according to the given format string using the given integer timestamp or the current local time if no timestamp is given. In other words, timestamp is optional and defaults to the value of time().',
        signature: '(string $format [, int $timestamp = time() ]): int'
    },
    gmdate: {
        description: 'Identical to the date() function except that the time returned is Greenwich Mean Time (GMT).',
        signature: '(string $format [, int $timestamp = time() ]): string'
    },
    mktime: {
        description: 'Returns the Unix timestamp corresponding to the arguments given. This timestamp is a long integer containing the number of seconds between the Unix Epoch (January 1 1970 00:00:00 GMT) and the time specified.',
        signature: '([ int $hour = date(\"H\") [, int $minute = date(\"i\") [, int $second = date(\"s\") [, int $month = date(\"n\") [, int $day = date(\"j\") [, int $year = date(\"Y\") [, int $is_dst = -1 ]]]]]]]): int'
    },
    gmmktime: {
        description: 'Identical to mktime() except the passed parameters represents a GMT date. gmmktime() internally uses mktime() so only times valid in derived local time can be used.',
        signature: '([ int $hour = gmdate(\"H\") [, int $minute = gmdate(\"i\") [, int $second = gmdate(\"s\") [, int $month = gmdate(\"n\") [, int $day = gmdate(\"j\") [, int $year = gmdate(\"Y\") [, int $is_dst = -1 ]]]]]]]): int'
    },
    checkdate: {
        description: 'Checks the validity of the date formed by the arguments. A date is considered valid if each parameter is properly defined.',
        signature: '(int $month , int $day , int $year): bool'
    },
    strftime: {
        description: 'Format the time and/or date according to locale settings. Month and weekday names and other language-dependent strings respect the current locale set with setlocale().',
        signature: '(string $format [, int $timestamp = time() ]): string'
    },
    gmstrftime: {
        description: 'Behaves the same as strftime() except that the time returned is Greenwich Mean Time (GMT). For example, when run in Eastern Standard Time (GMT -0500), the first line below prints \"Dec 31 1998 20:00:00\", while the second prints \"Jan 01 1999 01:00:00\".',
        signature: '(string $format [, int $timestamp = time() ]): string'
    },
    time: {
        description: 'Returns the current time measured in the number of seconds since the Unix Epoch (January 1 1970 00:00:00 GMT).',
        signature: '(void): int'
    },
    localtime: {
        description: 'The localtime() function returns an array identical to that of the structure returned by the C function call.',
        signature: '([ int $timestamp = time() [, bool $is_associative = false ]]): array'
    },
    getdate: {
        description: 'Returns an associative array containing the date information of the timestamp, or the current local time if no timestamp is given.',
        signature: '([ int $timestamp = time() ]): array'
    },
    date_create: {
        description: 'Alias of DateTime::__construct date_create_from_format date_date_set Date/Time Functions PHP Manual date_create (PHP 5 >= 5.2.0)',
    },
    date_create_from_format: {
        description: 'Alias of DateTime::createFromFormat date_add date_create Date/Time Functions PHP Manual date_create_from_format (PHP 5 >= 5.3.0)',
    },
    date_parse: {
        description: 'Parameters date Date in format accepted by strtotime().',
        signature: '(string $date): array'
    },
    date_parse_from_format: {
        description: 'Returns associative array with detailed info about given date.',
        signature: '(string $format , string $date): array'
    },
    date_get_last_errors: {
        description: 'Alias of DateTime::getLastErrors date_format date_interval_create_from_date_string Date/Time Functions PHP Manual date_get_last_errors (PHP 5 >= 5.3.0)',
    },
    date_format: {
        description: 'Alias of DateTime::format date_diff date_get_last_errors Date/Time Functions PHP Manual date_format (PHP 5 >= 5.2.0)',
    },
    date_modify: {
        description: 'Alias of DateTime::modify date_isodate_set date_offset_get Date/Time Functions PHP Manual date_modify (PHP 5 >= 5.2.0)',
    },
    date_add: {
        description: 'Alias of DateTime::add checkdate date_create_from_format Date/Time Functions PHP Manual date_add (PHP 5 >= 5.3.0)',
    },
    date_sub: {
        description: 'Alias of DateTime::sub date_parse date_sun_info Date/Time Functions PHP Manual date_sub (PHP 5 >= 5.3.0)',
    },
    date_timezone_get: {
        description: 'Alias of DateTime::getTimezone date_timestamp_set date_timezone_set Date/Time Functions PHP Manual date_timezone_get (PHP 5 >= 5.2.0)',
    },
    date_timezone_set: {
        description: 'Alias of DateTime::setTimezone date_timezone_get date Date/Time Functions PHP Manual date_timezone_set (PHP 5 >= 5.2.0)',
    },
    date_offset_get: {
        description: 'Alias of DateTime::getOffset date_modify date_parse_from_format Date/Time Functions PHP Manual date_offset_get (PHP 5 >= 5.2.0)',
    },
    date_diff: {
        description: 'Alias of DateTime::diff date_default_timezone_set date_format Date/Time Functions PHP Manual date_diff (PHP 5 >= 5.3.0)',
    },
    date_time_set: {
        description: 'Alias of DateTime::setTime date_sunset date_timestamp_get Date/Time Functions PHP Manual date_time_set (PHP 5 >= 5.2.0)',
    },
    date_date_set: {
        description: 'Alias of DateTime::setDate date_create date_default_timezone_get Date/Time Functions PHP Manual date_date_set (PHP 5 >= 5.2.0)',
    },
    date_isodate_set: {
        description: 'Alias of DateTime::setISODate date_interval_format date_modify Date/Time Functions PHP Manual date_isodate_set (PHP 5 >= 5.2.0)',
    },
    date_timestamp_set: {
        description: 'Alias of DateTime::setTimestamp date_timestamp_get date_timezone_get Date/Time Functions PHP Manual date_timestamp_set (PHP 5 >= 5.3.0)',
    },
    date_timestamp_get: {
        description: 'Alias of DateTime::getTimestamp date_time_set date_timestamp_set Date/Time Functions PHP Manual date_timestamp_get (PHP 5 >= 5.3.0)',
    },
    timezone_open: {
        description: 'Alias of DateTimeZone::__construct timezone_offset_get timezone_transitions_get Date/Time Functions PHP Manual timezone_open (PHP 5 >= 5.2.0)',
    },
    timezone_name_get: {
        description: 'Alias of DateTimeZone::getName timezone_name_from_abbr timezone_offset_get Date/Time Functions PHP Manual timezone_name_get (PHP 5 >= 5.2.0)',
    },
    timezone_name_from_abbr: {
        description: 'Parameters abbr Time zone abbreviation.',
        signature: '(string $abbr [, int $gmtOffset = -1 [, int $isdst = -1 ]]): string'
    },
    timezone_offset_get: {
        description: 'Alias of DateTimeZone::getOffset timezone_name_get timezone_open Date/Time Functions PHP Manual timezone_offset_get (PHP 5 >= 5.2.0)',
    },
    timezone_transitions_get: {
        description: 'Alias of DateTimeZone::getTransitions timezone_open timezone_version_get Date/Time Functions PHP Manual timezone_transitions_get (PHP 5 >= 5.2.0)',
    },
    timezone_location_get: {
        description: 'Alias of DateTimeZone::getLocation timezone_identifiers_list timezone_name_from_abbr Date/Time Functions PHP Manual timezone_location_get (PHP 5 >= 5.3.0)',
    },
    timezone_identifiers_list: {
        description: 'Alias of DateTimeZone::listIdentifiers timezone_abbreviations_list timezone_location_get Date/Time Functions PHP Manual timezone_identifiers_list (PHP 5 >= 5.2.0)',
    },
    timezone_abbreviations_list: {
        description: 'Alias of DateTimeZone::listAbbreviations time timezone_identifiers_list Date/Time Functions PHP Manual timezone_abbreviations_list (PHP 5 >= 5.2.0)',
    },
    timezone_version_get: {
        description: 'Returns the current version of the timezonedb.',
        signature: '(void): string'
    },
    date_interval_create_from_date_string: {
        description: 'Alias of DateInterval::createFromDateString date_get_last_errors date_interval_format Date/Time Functions PHP Manual date_interval_create_from_date_string (PHP 5 >= 5.3.0)',
    },
    date_interval_format: {
        description: 'Alias of DateInterval::format date_interval_create_from_date_string date_isodate_set Date/Time Functions PHP Manual date_interval_format (PHP 5 >= 5.3.0)',
    },
    date_default_timezone_set: {
        description: 'date_default_timezone_set() sets the default timezone used by all date/time functions.',
        signature: '(string $timezone_identifier): bool'
    },
    date_default_timezone_get: {
        description: 'In order of preference, this function returns the default timezone by: Reading the timezone set using the date_default_timezone_set() function (if any)',
        signature: '(void): string'
    },
    date_sunrise: {
        description: 'date_sunrise() returns the sunrise time for a given day (specified as a timestamp) and location.',
        signature: '(int $timestamp [, int $format = SUNFUNCS_RET_STRING [, float $latitude = ini_get(\"date.default_latitude\") [, float $longitude = ini_get(\"date.default_longitude\") [, float $zenith = ini_get(\"date.sunrise_zenith\") [, float $gmt_offset = 0 ]]]]]): mixed'
    },
    date_sunset: {
        description: 'date_sunset() returns the sunset time for a given day (specified as a timestamp) and location.',
        signature: '(int $timestamp [, int $format = SUNFUNCS_RET_STRING [, float $latitude = ini_get(\"date.default_latitude\") [, float $longitude = ini_get(\"date.default_longitude\") [, float $zenith = ini_get(\"date.sunset_zenith\") [, float $gmt_offset = 0 ]]]]]): mixed'
    },
    date_sun_info: {
        description: 'Parameters time Timestamp.',
        signature: '(int $time , float $latitude , float $longitude): array'
    },
    ereg: {
        description: 'Searches a string for matches to the regular expression given in pattern in a case-sensitive way.',
        signature: '(string $pattern , string $string [, array &$regs ]): int'
    },
    ereg_replace: {
        description: 'This function scans string for matches to pattern, then replaces the matched text with replacement.',
        signature: '(string $pattern , string $replacement , string $string): string'
    },
    eregi: {
        description: 'This function is identical to ereg() except that it ignores case distinction when matching alphabetic characters.',
        signature: '(string $pattern , string $string [, array &$regs ]): int'
    },
    eregi_replace: {
        description: 'This function is identical to ereg_replace() except that this ignores case distinction when matching alphabetic characters.',
        signature: '(string $pattern , string $replacement , string $string): string'
    },
    split: {
        description: 'Splits a string into array by regular expression.',
        signature: '(string $pattern , string $string [, int $limit = -1 ]): array'
    },
    spliti: {
        description: 'Splits a string into array by regular expression.',
        signature: '(string $pattern , string $string [, int $limit = -1 ]): array'
    },
    sql_regcase: {
        description: 'Creates a regular expression for a case insensitive match.',
        signature: '(string $string): string'
    },
    filter_input: {
        description: 'Parameters type One of INPUT_GET, INPUT_POST, INPUT_COOKIE, INPUT_SERVER, or INPUT_ENV.',
        signature: '(int $type , string $variable_name [, int $filter = FILTER_DEFAULT [, mixed $options ]]): mixed'
    },
    filter_var: {
        description: 'Parameters variable Value to filter.',
        signature: '(mixed $variable [, int $filter = FILTER_DEFAULT [, mixed $options ]]): mixed'
    },
    filter_input_array: {
        description: 'This function is useful for retrieving many values without repetitively calling filter_input().',
        signature: '(int $type [, mixed $definition ]): mixed'
    },
    filter_var_array: {
        description: 'This function is useful for retrieving many values without repetitively calling filter_var().',
        signature: '(array $data [, mixed $definition ]): mixed'
    },
    filter_list: {
        description: 'Return Values Returns an array of names of all supported filters, empty array if there are no such filters. Indexes of this array are not filter IDs, they can be obtained with filter_id() from a name instead.',
        signature: '(void): array'
    },
    filter_has_var: {
        description: 'Parameters type One of INPUT_GET, INPUT_POST, INPUT_COOKIE, INPUT_SERVER, or INPUT_ENV.',
        signature: '(int $type , string $variable_name): bool'
    },
    filter_id: {
        description: 'Parameters filtername Name of a filter to get.',
        signature: '(string $filtername): int'
    },
    ftp_connect: {
        description: 'ftp_connect() opens an FTP connection to the specified host.',
        signature: '(string $host [, int $port = 21 [, int $timeout = 90 ]]): resource'
    },
    ftp_login: {
        description: 'Logs in to the given FTP stream.',
        signature: '(resource $ftp_stream , string $username , string $password): bool'
    },
    ftp_pwd: {
        description: 'Returns the current directory name',
        signature: '(resource $ftp_stream): string'
    },
    ftp_cdup: {
        description: 'Changes to the parent directory.',
        signature: '(resource $ftp_stream): bool'
    },
    ftp_chdir: {
        description: 'Changes the current directory to the specified one.',
        signature: '(resource $ftp_stream , string $directory): bool'
    },
    ftp_exec: {
        description: 'Sends a SITE EXEC command request to the FTP server.',
        signature: '(resource $ftp_stream , string $command): bool'
    },
    ftp_raw: {
        description: 'Sends an arbitrary command to the FTP server.',
        signature: '(resource $ftp_stream , string $command): array'
    },
    ftp_mkdir: {
        description: 'Creates the specified directory on the FTP server.',
        signature: '(resource $ftp_stream , string $directory): string'
    },
    ftp_rmdir: {
        description: 'Removes the specified directory on the FTP server.',
        signature: '(resource $ftp_stream , string $directory): bool'
    },
    ftp_chmod: {
        description: 'Sets the permissions on the specified remote file to mode.',
        signature: '(resource $ftp_stream , int $mode , string $filename): int'
    },
    ftp_alloc: {
        description: 'Sends an ALLO command to the remote FTP server to allocate space for a file to be uploaded.',
        signature: '(resource $ftp_stream , int $filesize [, string &$result ]): bool'
    },
    ftp_nlist: {
        description: 'Parameters ftp_stream The link identifier of the FTP connection.',
        signature: '(resource $ftp_stream , string $directory): array'
    },
    ftp_rawlist: {
        description: 'ftp_rawlist() executes the FTP LIST command, and returns the result as an array.',
        signature: '(resource $ftp_stream , string $directory [, bool $recursive = false ]): array'
    },
    ftp_systype: {
        description: 'Returns the system type identifier of the remote FTP server.',
        signature: '(resource $ftp_stream): string'
    },
    ftp_pasv: {
        description: 'ftp_pasv() turns on or off passive mode. In passive mode, data connections are initiated by the client, rather than by the server. It may be needed if the client is behind firewall.',
        signature: '(resource $ftp_stream , bool $pasv): bool'
    },
    ftp_get: {
        description: 'ftp_get() retrieves a remote file from the FTP server, and saves it into a local file.',
        signature: '(resource $ftp_stream , string $local_file , string $remote_file , int $mode [, int $resumepos = 0 ]): bool'
    },
    ftp_fget: {
        description: 'ftp_fget() retrieves remote_file from the FTP server, and writes it to the given file pointer.',
        signature: '(resource $ftp_stream , resource $handle , string $remote_file , int $mode [, int $resumepos = 0 ]): bool'
    },
    ftp_put: {
        description: 'ftp_put() stores a local file on the FTP server.',
        signature: '(resource $ftp_stream , string $remote_file , string $local_file , int $mode [, int $startpos = 0 ]): bool'
    },
    ftp_fput: {
        description: 'ftp_fput() uploads the data from a file pointer to a remote file on the FTP server.',
        signature: '(resource $ftp_stream , string $remote_file , resource $handle , int $mode [, int $startpos = 0 ]): bool'
    },
    ftp_size: {
        description: 'ftp_size() returns the size of the given file in bytes.',
        signature: '(resource $ftp_stream , string $remote_file): int'
    },
    ftp_mdtm: {
        description: 'ftp_mdtm() gets the last modified time for a remote file.',
        signature: '(resource $ftp_stream , string $remote_file): int'
    },
    ftp_rename: {
        description: 'ftp_rename() renames a file or a directory on the FTP server.',
        signature: '(resource $ftp_stream , string $oldname , string $newname): bool'
    },
    ftp_delete: {
        description: 'ftp_delete() deletes the file specified by path from the FTP server.',
        signature: '(resource $ftp_stream , string $path): bool'
    },
    ftp_site: {
        description: 'ftp_site() sends the given SITE command to the FTP server.',
        signature: '(resource $ftp_stream , string $command): bool'
    },
    ftp_close: {
        description: 'ftp_close() closes the given link identifier and releases the resource.',
        signature: '(resource $ftp_stream): bool'
    },
    ftp_set_option: {
        description: 'This function controls various runtime options for the specified FTP stream.',
        signature: '(resource $ftp_stream , int $option , mixed $value): bool'
    },
    ftp_get_option: {
        description: 'This function returns the value for the requested option from the specified FTP connection.',
        signature: '(resource $ftp_stream , int $option): mixed'
    },
    ftp_nb_fget: {
        description: 'ftp_nb_fget() retrieves a remote file from the FTP server.',
        signature: '(resource $ftp_stream , resource $handle , string $remote_file , int $mode [, int $resumepos = 0 ]): int'
    },
    ftp