How are PHP's built-in functions implemented internally?

are these functions written the same way as user functions? I mean with PHP code and with regular expressions and 开发者_StackOverflow中文版stuff like that?

For example:

filter_var($email, FILTER_VALIDATE_EMAIL);

vs.

http://www.totallyphp.co.uk/code/validate_an_email_address_using_regular_expressions.htm

---

PHP is written in C. The PHP functions are written in high quality C code then compiled to form the PHP langugae library

if you want to extend PHP (edit / write) own functions check this out: http://www.php.net/~wez/extending-php.pdf

EDIT:

here you go :

This is the original C code for the function:

/* {{{ proto mixed filter_var(mixed variable [, long filter [, mixed options]])
 * Returns the filtered version of the vriable.
 */
PHP_FUNCTION(filter_var)
{
    long filter = FILTER_DEFAULT;
    zval **filter_args = NULL, *data;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/|lZ", &data, &filter, &filter_args) == FAILURE) {
        return;
    }

    if (!PHP_FILTER_ID_EXISTS(filter)) {
        RETURN_FALSE;
    }

    MAKE_COPY_ZVAL(&data, return_value);

    php_filter_call(&return_value, filter, filter_args, 1, FILTER_REQUIRE_SCALAR TSRMLS_CC);
}
/* }}} */



static void php_filter_call(zval **filtered, long filter, zval **filter_args, const int copy, long filter_flags TSRMLS_DC) /* {{{ */
{
    zval  *options = NULL;
    zval **option;
    char  *charset = NULL;

    if (filter_args && Z_TYPE_PP(filter_args) != IS_ARRAY) {
        long lval;

        PHP_FILTER_GET_LONG_OPT(filter_args, lval);

        if (filter != -1) { /* handler for array apply */
            /* filter_args is the filter_flags */
            filter_flags = lval;

            if (!(filter_flags & FILTER_REQUIRE_ARRAY ||  filter_flags & FILTER_FORCE_ARRAY)) {
                filter_flags |= FILTER_REQUIRE_SCALAR;
            }
        } else {
            filter = lval;
        }
    } else if (filter_args) {
        if (zend_hash_find(HASH_OF(*filter_args), "filter", sizeof("filter"), (void **)&option) == SUCCESS) {
            PHP_FILTER_GET_LONG_OPT(option, filter);
        }

        if (zend_hash_find(HASH_OF(*filter_args), "flags", sizeof("flags"), (void **)&option) == SUCCESS) {
            PHP_FILTER_GET_LONG_OPT(option, filter_flags);

            if (!(filter_flags & FILTER_REQUIRE_ARRAY ||  filter_flags & FILTER_FORCE_ARRAY)) {
                filter_flags |= FILTER_REQUIRE_SCALAR;
            }
        }

        if (zend_hash_find(HASH_OF(*filter_args), "options", sizeof("options"), (void **)&option) == SUCCESS) {
            if (filter != FILTER_CALLBACK) {
                if (Z_TYPE_PP(option) == IS_ARRAY) {
                    options = *option;
                }
            } else {
                options = *option;
                filter_flags = 0;
            }
        }
    }

    if (Z_TYPE_PP(filtered) == IS_ARRAY) {
        if (filter_flags & FILTER_REQUIRE_SCALAR) {
            if (copy) {
                SEPARATE_ZVAL(filtered);
            }
            zval_dtor(*filtered);
            if (filter_flags & FILTER_NULL_ON_FAILURE) {
                ZVAL_NULL(*filtered);
            } else {
                ZVAL_FALSE(*filtered);
            }
            return;
        }
        php_zval_filter_recursive(filtered, filter, filter_flags, options, charset, copy TSRMLS_CC);
        return;
    }
    if (filter_flags & FILTER_REQUIRE_ARRAY) {
        if (copy) {
            SEPARATE_ZVAL(filtered);
        }
        zval_dtor(*filtered);
        if (filter_flags & FILTER_NULL_ON_FAILURE) {
            ZVAL_NULL(*filtered);
        } else {
            ZVAL_FALSE(*filtered);
        }
        return;
    }

    php_zval_filter(filtered, filter, filter_flags, options, charset, copy TSRMLS_CC);
    if (filter_flags & FILTER_FORCE_ARRAY) {
        zval *tmp;

        ALLOC_ZVAL(tmp);
        MAKE_COPY_ZVAL(filtered, tmp);

        zval_dtor(*filtered);

        array_init(*filtered);
        add_next_index_zval(*filtered, tmp);
    }
}

AND HERE IS YOUR VALIDATE EMAIL ROUTINE: -- this answers your question. Yes, it is done by regex internally.

void php_filter_validate_email(PHP_INPUT_FILTER_PARAM_DECL) /* {{{ */
{
    /*
     * The regex below is based on a regex by Michael Rushton.
     * However, it is not identical.  I changed it to only consider routeable
     * addresses as valid.  Michael's regex considers a@b a valid address
     * which conflicts with section 2.3.5 of RFC 5321 which states that:
     *
     *   Only resolvable, fully-qualified domain names (FQDNs) are permitted
     *   when domain names are used in SMTP.  In other words, names that can
     *   be resolved to MX RRs or address (i.e., A or AAAA) RRs (as discussed
     *   in Section 5) are permitted, as are CNAME RRs whose targets can be
     *   resolved, in turn, to MX or address RRs.  Local nicknames or
     *   unqualified names MUST NOT be used.
     *
     * This regex does not handle comments and folding whitespace.  While
     * this is technically valid in an email address, these parts aren't
     * actually part of the address itself.
     *
     * Michael's regex carries this copyright:
     *
     * Copyright © Michael Rushton 2009-10
     * http://squiloople.com/
     * Feel free to use and redistribute this code. But please keep this copyright notice.
     *
     */
    const char regexp[] = "/^(?!(?:(?:\\x22?\\x5C[\\x00-\\x7E]\\x22?)|(?:\\x22?[^\\x5C\\x22]\\x22?)){255,})(?!(?:(?:\\x22?\\x5C[\\x00-\\x7E]\\x22?)|(?:\\x22?[^\\x5C\\x22]\\x22?)){65,}@)(?:(?:[\\x21\\x23-\\x27\\x2A\\x2B\\x2D\\x2F-\\x39\\x3D\\x3F\\x5E-\\x7E]+)|(?:\\x22(?:[\\x01-\\x08\\x0B\\x0C\\x0E-\\x1F\\x21\\x23-\\x5B\\x5D-\\x7F]|(?:\\x5C[\\x00-\\x7F]))*\\x22))(?:\\.(?:(?:[\\x21\\x23-\\x27\\x2A\\x2B\\x2D\\x2F-\\x39\\x3D\\x3F\\x5E-\\x7E]+)|(?:\\x22(?:[\\x01-\\x08\\x0B\\x0C\\x0E-\\x1F\\x21\\x23-\\x5B\\x5D-\\x7F]|(?:\\x5C[\\x00-\\x7F]))*\\x22)))*@(?:(?:(?!.*[^.]{64,})(?:(?:(?:xn--)?[a-z0-9]+(?:-[a-z0-9]+)*\\.){1,126}){1,}(?:(?:[a-z][a-z0-9]*)|(?:(?:xn--)[a-z0-9]+))(?:-[a-z0-9]+)*)|(?:\\[(?:(?:IPv6:(?:(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){7})|(?:(?!(?:.*[a-f0-9][:\\]]){7,})(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,5})?::(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,5})?)))|(?:(?:IPv6:(?:(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){5}:)|(?:(?!(?:.*[a-f0-9]:){5,})(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,3})?::(?:[a-f0-9]{1,4}(?::[a-f0-9]{1,4}){0,3}:)?)))?(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:1[0-9]{2})|(?:[1-9]?[0-9]))(?:\\.(?:(?:25[0-5])|(?:2[0-4][0-9])|(?:1[0-9]{2})|(?:[1-9]?[0-9]))){3}))\\]))$/iD";

    pcre       *re = NULL;
    pcre_extra *pcre_extra = NULL;
    int preg_options = 0;
    int         ovector[150]; /* Needs to be a multiple of 3 */
    int         matches;


    /* The maximum length of an e-mail address is 320 octets, per RFC 2821. */
    if (Z_STRLEN_P(value) > 320) {
        RETURN_VALIDATION_FAILED
    }

    re = pcre_get_compiled_regex((char *)regexp, &pcre_extra, &preg_options TSRMLS_CC);
    if (!re) {
        RETURN_VALIDATION_FAILED
    }
    matches = pcre_exec(re, NULL, Z_STRVAL_P(value), Z_STRLEN_P(value), 0, 0, ovector, 3);

    /* 0 means that the vector is too small to hold all the captured substring offsets */
    if (matches < 0) {
        RETURN_VALIDATION_FAILED
    }

}
/* }}} */

---

PHP functions are either :

• Written in C -- and not in PHP
• Or just wrappers to functions provided by other libraries (For instance, PHP's curl extension is just a wrapper arround the curl library).

If you are curious, you can take a look at the sources of PHP -- here's its SVN : http://svn.php.net/viewvc/

For instance, the filter_var() function should be defined somewhere in the sources of the filter extension.

---

Nope. PHP-internal functions are written in C, not with PHP code. Which looks quite unwieldy due to the many Zend-runtime macros and how parameters are transferred from PHP into C structures.

That particular function does use a regular expression. It also makes a nice example:
http://svn.php.net/repository/php/php-src/branches/PHP_5_3/ext/filter/logical_filters.c
Look for regexp[] somewhere in the middle.