PHP Manual
Prev | Chapter 31. Source Discussion | Next

# Declaration of the Zend Function Block

Now that you have declared the functions to be exported, you also have to introduce them to Zend. Introducing the list of functions is done by using an array of `zend_function_entry`. This array consecutively contains all functions that are to be made available externally, with the function's name as it should appear in PHP and its name as defined in the C source. Internally, `zend_function_entry` is defined as shown in Example 31-1.

Example 31-1. Internal declaration of `zend_function_entry`.
    typedef struct _zend_function_entry {
        char *fname;
        void (*handler)(INTERNAL_FUNCTION_PARAMETERS);
        unsigned char *func_arg_types;
    } zend_function_entry;
Entry | Description
`fname` | Denotes the function name as seen in PHP (for example, `fopen`, `mysql_connect`, or, in our example, `first_module`).
`handler` | Pointer to the C function responsible for handling calls to this function. For example, see the standard macro `INTERNAL_FUNCTION_PARAMETERS` discussed earlier.
`func_arg_types` | Allows you to mark certain parameters so that they're forced to be passed by reference. You usually should set this to NULL.

In the example above, the declaration looks like this:

    zend_function_entry firstmod_functions[] =
    {
        ZEND_FE(first_module, NULL)
        {NULL, NULL, NULL}
    };

You can see that the last entry in the list always has to be `{NULL, NULL, NULL}`. This marker has to be set for Zend to know when the end of the list of exported functions is reached.

> Note: You cannot use the predefined macros for the end marker, as these would try to refer to a function named "NULL"!

The macro `ZEND_FE` (short for 'Zend Function Entry') simply expands to a structure entry in `zend_function_entry`. Note that these macros introduce a special naming scheme to your functions - your C functions will be prefixed with `zif_`, meaning that `ZEND_FE(first_module)` will refer to a C function zif_first_module(). If you want to mix macro usage with hand-coded entries (not a good practice), keep this in mind.

Tip: Compilation errors that refer to functions named zif_*() relate to functions defined with `ZEND_FE`.

Table 31-2 shows a list of all the macros that you can use to define functions.

Table 31-2. Macros for Defining Functions

Macro Name | Description
`ZEND_FE(name, arg_types)` | Defines a function entry of the name `name` in `zend_function_entry`. Requires a corresponding C function. `arg_types` needs to be set to `NULL`. This function uses automatic C function name generation by prefixing the PHP function name with `zif_`. For example, `ZEND_FE("first_module", NULL)` introduces a function first_module() to PHP and links it to the C function zif_first_module(). Use in conjunction with `ZEND_FUNCTION`.
`ZEND_NAMED_FE(php_name, name, arg_types)` | Defines a function that will be available to PHP by the name `php_name` and links it to the corresponding C function `name`. `arg_types` needs to be set to `NULL`. Use this function if you don't want the automatic name prefixing introduced by `ZEND_FE`. Use in conjunction with `ZEND_NAMED_FUNCTION`.
`ZEND_FALIAS(name, alias, arg_types)` | Defines an alias named `alias` for `name`. `arg_types` needs to be set to `NULL`. Doesn't require a corresponding C function; refers to the alias target instead.
`PHP_FE(name, arg_types)` | Old PHP API equivalent of `ZEND_FE`.
`PHP_NAMED_FE(runtime_name, name, arg_types)` | Old PHP API equivalent of `ZEND_NAMED_FE`.

Note: You can't use `ZEND_FE` in conjunction with `PHP_FUNCTION`, or `PHP_FE` in conjunction with `ZEND_FUNCTION`. However, it's perfectly legal to mix `ZEND_FE` and `ZEND_FUNCTION` with `PHP_FE` and `PHP_FUNCTION` when staying with the same macro set for each function to be declared. But mixing is not recommended; instead, you're advised to use the `ZEND_*` macros only.

Prev | Home | Next
Declaring Exported Functions | Up | Declaration of the Zend Module Block