/hphp/system/idl/error.idl.json

{
    "preamble": "",
    "consts": [
        {
            "name": "DEBUG_BACKTRACE_PROVIDE_OBJECT",
            "type": "Int64"
        },
        {
            "name": "DEBUG_BACKTRACE_IGNORE_ARGS",
            "type": "Int64"
        }
    ],
    "funcs": [
        {
            "name": "debug_backtrace",
            "desc": "debug_backtrace() generates a PHP backtrace.",
            "flags": [
                "NeedsActRec"
            ],
            "return": {
                "type": "StringVec",
                "desc": "Returns an associative array. The possible returned elements are as follows:\n\nPossible returned elements from debug_backtrace() Name Type Description function string The current function name. See also __FUNCTION__. line integer The current line number. See also __LINE__. file string The current file name. See also __FILE__. class string The current class name. See also __CLASS__ object object The current object. type string The current call type. If a method call, \"->\" is returned. If a static method call, \"::\" is returned. If a function call, nothing is returned. args array If inside a function, this lists the functions arguments. If inside an included file, this lists the included file name(s)."
            },
            "args": [
                {
                    "name": "options",
                    "type": "Int64",
                    "value": "1",
                    "desc": "Whether or not to populate the \"object\" index.\n\nDEBUG_BACKTRACE_PROVIDE_OBJECT: Whether or not to populate the \"object\" index.\nDEBUG_BACKTRACE_IGNORE_ARGS: Whether or not to omit the \"args\" index, and thus all the function/method arguments, to save memory."
                },
                {
                    "name": "limit",
                    "type": "Int64",
                    "value": "0",
                    "desc": "This parameter can be used to limit the number of stack frames returned. By default (limit=0) it returns all stack frames."
                }
            ]
        },
        {
            "name": "debug_print_backtrace",
            "desc": "debug_print_backtrace() prints a PHP backtrace. It prints the function calls, included\/required files and eval()ed stuff.\nThis function has no parameters.",
            "flags": [
                "NeedsActRec"
            ],
            "return": {
                "type": null,
                "desc": "No value is returned."
            },
            "args": [
                {
                    "name": "options",
                    "type": "Int64",
                    "value": "0",
                    "desc": "Whether or not to populate the \"object\" index.\n\nDEBUG_BACKTRACE_IGNORE_ARGS: Whether or not to omit the \"args\" index, and thus all the function/method arguments, to save memory."
                },
                {
                    "name": "limit",
                    "type": "Int64",
                    "value": "0",
                    "desc": "This parameter can be used to limit the number of stack frames returned. By default (limit=0) it returns all stack frames."
                }
            ]
        },
        {
            "name": "error_get_last",
            "desc": "Gets information about the last error that occurred.",
            "flags": [
            ],
            "return": {
                "type": "StringVec",
                "desc": "Returns an associative array describing the last error with keys \"type\", \"message\", \"file\" and \"line\". Returns NULL if there hasn't been an error yet."
            },
            "args": [
            ]
        },
        {
            "name": "error_log",
            "desc": "Sends an error message to the web server's error log, a TCP port or to a file.",
            "flags": [
            ],
            "return": {
                "type": "Boolean",
                "desc": "Returns TRUE on success or FALSE on failure."
            },
            "args": [
                {
                    "name": "message",
                    "type": "String",
                    "desc": "The error message that should be logged."
                },
                {
                    "name": "message_type",
                    "type": "Int32",
                    "value": "0",
                    "desc": "Says where the error should go. The possible message types are as follows:\n\nerror_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."
                },
                {
                    "name": "destination",
                    "type": "String",
                    "value": "null_string",
                    "desc": "The destination. Its meaning depends on the message_type parameter as described above."
                },
                {
                    "name": "extra_headers",
                    "type": "String",
                    "value": "null_string",
                    "desc": "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."
                }
            ]
        },
        {
            "name": "error_reporting",
            "desc": "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.",
            "flags": [
            ],
            "return": {
                "type": "Int64",
                "desc": "Returns the old error_reporting level or the current level if no level parameter is given."
            },
            "args": [
                {
                    "name": "level",
                    "type": "Variant",
                    "value": "null",
                    "desc": "The new error_reporting level. It takes on either a bitmask, or named constants. Using named constants is strongly encouraged to ensure compatibility for future versions. As error levels are added, the range of integers increases, so older integer-based error levels will not always behave as expected.\n\nThe available error level constants and the actual meanings of these error levels are described in the predefined constants."
                }
            ]
        },
        {
            "name": "restore_error_handler",
            "desc": "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).",
            "flags": [
            ],
            "return": {
                "type": "Boolean",
                "desc": "This function always returns TRUE."
            },
            "args": [
            ]
        },
        {
            "name": "restore_exception_handler",
            "desc": "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).",
            "flags": [
            ],
            "return": {
                "type": "Boolean",
                "desc": "This function always returns TRUE."
            },
            "args": [
            ]
        },
        {
            "name": "set_error_handler",
            "desc": "Sets a user function (error_handler) to handle errors in a script.\n\nThis function can be used for defining your own way of handling errors during runtime, for example in applications in which you need to do cleanup of data\/files when a critical error happens, or when you need to trigger an error under certain conditions (using trigger_error()).\n\nIt is important to remember that the standard PHP error handler is completely bypassed for the error types specified by error_types unless the callback function returns FALSE. error_reporting() settings will have no effect and your error handler will be called regardless - however you are still able to read the current value of error_reporting and act appropriately. Of particular note is that this value will be 0 if the statement that caused the error was prepended by the @ error-control operator.\n\nAlso note that it is your responsibility to die() if necessary. If the error-handler function returns, script execution will continue with the next statement after the one that caused an error.\n\nThe following error types cannot be handled with a user defined function: E_ERROR, E_PARSE, E_CORE_ERROR, E_CORE_WARNING, E_COMPILE_ERROR, E_COMPILE_WARNING, and most of E_STRICT raised in the file where set_error_handler() is called.\n\nIf errors occur before the script is executed (e.g. on file uploads) the custom error handler cannot be called since it is not registered at that time.",
            "flags": [
            ],
            "return": {
                "type": "Variant",
                "desc": "Returns a string containing the previously defined error handler (if any). If the built-in error handler is used NULL is returned. NULL is also returned in case of an error such as an invalid callback. If the previous error handler was a class method, this function will return an indexed array with the class and the method name."
            },
            "args": [
                {
                    "name": "error_handler",
                    "type": "Variant",
                    "desc": "The user function needs to accept two parameters: the error code, and a string describing the error. Then there are three optional parameters that may be supplied: the filename in which the error occurred, the line number in which the error occurred, and the context in which the error occurred (an array that points to the active symbol table at the point the error occurred). The function can be shown as:\n\nhandler ( int $errno , string $errstr [, string $errfile [, int $errline [, array $errcontext ]]] ) errno The first parameter, errno, contains the level of the error raised, as an integer."
                },
                {
                    "name": "error_types",
                    "type": "Int32",
                    "value": "k_E_ALL",
                    "desc": "The second parameter, errstr, contains the error message, as a string."
                }
            ]
        },
        {
            "name": "set_exception_handler",
            "desc": "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.",
            "flags": [
            ],
            "return": {
                "type": "Variant",
                "desc": "Returns the name of the previously defined exception handler, or NULL on error. If no previous handler was defined, NULL is also returned."
            },
            "args": [
                {
                    "name": "exception_handler",
                    "type": "Variant",
                    "desc": "Name of the function to be called when an uncaught exception occurs. This function must be defined before calling set_exception_handler(). This handler function needs to accept one parameter, which will be the exception object that was thrown."
                }
            ]
        },
        {
            "name": "hphp_set_error_page",
            "desc": "Displays fatal errors with this PHP document. When 500 fatal error is about to display, it will invoke this PHP page with all global states right at when the error happens. This is useful for gracefully displaying something helpful information to end users when a fatal error has happened. Otherwise, a blank page will be displayed by default.",
            "flags": [
                "HipHopSpecific"
            ],
            "return": {
                "type": null
            },
            "args": [
                {
                    "name": "page",
                    "type": "String",
                    "desc": "Relative path of the PHP document."
                }
            ]
        },
        {
            "name": "hphp_throw_fatal_error",
            "desc": "Raises a fatal error.",
            "flags": [
                "HipHopSpecific"
            ],
            "return": {
                "type": null
            },
            "args": [
                {
                    "name": "error_msg",
                    "type": "String",
                    "desc": "The error message for the fatal."
                }
            ]
        },
        {
            "name": "hphp_clear_unflushed",
            "desc": "Clears any output contents that have not been flushed to networked. This is useful when handling a fatal error. Before displaying a customized PHP page, one may call this function to clear previously written content, so to replay what will be displayed.",
            "flags": [
                "HipHopSpecific"
            ],
            "return": {
                "type": null
            },
            "args": [
            ]
        },
        {
            "name": "hphp_debug_caller_info",
            "desc": "Retrieves information about the caller that invoked the current function or method",
            "flags": [
                "HipHopSpecific"
            ],
            "return": {
                "type": "StringVec",
                "desc": "Returns an associative array. On success, the array will contain two keys 'file' and 'line' which indicate the filename and line number of the callsite that invoked the current function or method."
            },
            "args": [
            ]
        },
        {
            "name": "trigger_error",
            "desc": "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()).\n\nThis function is useful when you need to generate a particular response to an exception at runtime.",
            "flags": [
            ],
            "return": {
                "type": "Boolean",
                "desc": "This function returns FALSE if wrong error_type is specified, TRUE otherwise."
            },
            "args": [
                {
                    "name": "error_msg",
                    "type": "String",
                    "desc": "The designated error message for this error. It's limited to 1024 characters in length. Any additional characters beyond 1024 will be truncated."
                },
                {
                    "name": "error_type",
                    "type": "Int32",
                    "value": "k_E_USER_NOTICE",
                    "desc": "The designated error type for this error. It only works with the E_USER family of constants, and will default to E_USER_NOTICE."
                }
            ]
        },
        {
            "name": "user_error",
            "flags": [
            ],
            "return": {
                "type": "Boolean"
            },
            "args": [
                {
                    "name": "error_msg",
                    "type": "String"
                },
                {
                    "name": "error_type",
                    "type": "Int32",
                    "value": "k_E_USER_NOTICE"
                }
            ]
        }
    ],
    "classes": [
    ]
}