深入PHP内核之函数

1、关于返回值，PHP内核中使用了大量的宏来实现，我们先看一个函数

PHP_FUNCTION  宏的定义(Zend/zend_API.h)

#define PHP_FUNCTION                    ZEND_FUNCTION
#define ZEND_FUNCTION(name)                             ZEND_NAMED_FUNCTION(ZEND_FN(name))
#define ZEND_FN(name) zif_##name
#define ZEND_NAMED_FUNCTION(name)               void name(INTERNAL_FUNCTION_PARAMETERS)
#define INTERNAL_FUNCTION_PARAMETERS int ht, zval *return_value, zval **return_value_ptr,zval *this_ptr, int return_value_used TSRMLS_DC

//最终
void zif_hello_world(int ht, zval *return_value, zval **return_value_ptr,
                     zval *this_ptr, int return_value_used TSRMLS_DC)
{
}

参数解释

INTERNAL_FUNCTION_PARAMETERS
名称和类型 描述 访问宏
int ht 用户实际传递参数的数量 ZEND_NUM_ARGS()
zval *return_value PHP 变量的指针，可填充返回值传递给用户。默认值是 IS_NULL。 RETVAL_*, RETURN_*
zval **return_value_ptr 当返回引用时，PHP 将其设为变量的指针。不建议返回引用。  
zval *this_ptr 假如这是一个方法调用，其指向存放 $this 对象的 PHP 变量。 getThis()
int return_value_used 指示返回值是否会被调用者使用的标志。 caller.  

函数入口可含有一个对参数信息结构的指针。 不是必须要提供此信息，除非打算接受参数引用或返回一个引用，及提供由 PHP 的反射 API 访问的信息。参数可以直接作为函数参数传递，也可以是通过一个堆栈(stack)

2、用于返回值的宏

a)RETURN_BOOL(0); //返回bool值
#define RETVAL_BOOL(b)                                  ZVAL_BOOL(return_value, b)
#define RETURN_BOOL(b)                                  { RETVAL_BOOL(b); return; }
#define ZVAL_BOOL(z, b) do {                            zval *__z = (z);                                        Z_LVAL_P(__z) = ((b) != 0);                     Z_TYPE_P(__z) = IS_BOOL;                } while (0)

所以展开这个RETURN_BOOL(0)，最终在函数里返回值的操作即是

do {
    zval *__z = (return_value);
    Z_LVAL_P(__z) = ((0) != 0); //定义return_value值
    Z_TYPE_P(__z) = IS_BOOL; //定义return_value的类型
}while(0)

b) RETURN_STRING("hello world", 1);

展开之后

do {
    const char *__s = ("hello world");
    zval *__z = return_value;
    Z_STRLEN_P(__z) = strlen(__s);//定义长度
    Z_STRVAL_P(__z) = (1?estrndup(__s, Z_STRLEN_P(__z)):(char*)__s);//定义值，estrndup函数实现字符串的复制
    Z_TYPE_P(__z) = IS_STRING;
}while(0)

c) RETURN_LONG(100);

展开之后

zval *__z = return_value;
Z_LVAL_P(__z) = 100;
Z_TYPE_P(__z) = IS_LONG;

d)返回数组

array_init(return_value);//初始化return_value成数组，此操作完后就可以返回一个空的数组

e)返回object

object_init(return_value);//初始化return_value成Object，此操作完成后返回一个空的对像

其他的

#define ZVAL_FALSE(z)                                   ZVAL_BOOL(z, 0)
#define ZVAL_TRUE(z)                                    ZVAL_BOOL(z, 1)

#define RETVAL_RESOURCE(l)                              ZVAL_RESOURCE(return_value, l)
#define RETVAL_BOOL(b)                                  ZVAL_BOOL(return_value, b)
#define RETVAL_NULL()                                   ZVAL_NULL(return_value)
#define RETVAL_LONG(l)                                  ZVAL_LONG(return_value, l)
#define RETVAL_DOUBLE(d)                                ZVAL_DOUBLE(return_value, d)
#define RETVAL_STRING(s, duplicate)             ZVAL_STRING(return_value, s, duplicate)
#define RETVAL_STRINGL(s, l, duplicate)         ZVAL_STRINGL(return_value, s, l, duplicate)
#define RETVAL_EMPTY_STRING()                   ZVAL_EMPTY_STRING(return_value)
#define RETVAL_ZVAL(zv, copy, dtor)             ZVAL_ZVAL(return_value, zv, copy, dtor)
#define RETVAL_FALSE                                    ZVAL_BOOL(return_value, 0)
#define RETVAL_TRUE                                     ZVAL_BOOL(return_value, 1)

#define RETURN_RESOURCE(l)                              { RETVAL_RESOURCE(l); return; }
#define RETURN_BOOL(b)                                  { RETVAL_BOOL(b); return; }
#define RETURN_NULL()                                   { RETVAL_NULL(); return;}
#define RETURN_LONG(l)                                  { RETVAL_LONG(l); return; }
#define RETURN_DOUBLE(d)                                { RETVAL_DOUBLE(d); return; }
#define RETURN_STRING(s, duplicate)     { RETVAL_STRING(s, duplicate); return; }
#define RETURN_STRINGL(s, l, duplicate) { RETVAL_STRINGL(s, l, duplicate); return; }
#define RETURN_EMPTY_STRING()                   { RETVAL_EMPTY_STRING(); return; }
#define RETURN_ZVAL(zv, copy, dtor)             { RETVAL_ZVAL(zv, copy, dtor); return; }
#define RETURN_FALSE                                    { RETVAL_FALSE; return; }
#define RETURN_TRUE                                     { RETVAL_TRUE; return; }

 3、数组以及对象的操作

zval *arr;
MAKE_STD_ZVAL(arr);
array_init(arr); //$arr = array();
add_assoc_long(arr, "a", 10); //$arr["a"] = 10;
add_asoc_unset(arr, "a"); //unset(arr["a"]);
add_assoc_bool(arr, "b", 1); //$arr["b"] = true;
add_assoc_resource(arr, "c", 10); //$arr["c"] = $resource;
add_assoc_double(arr, "d", 2.15); //$arr["d"] = 2.15;
add_assoc_string(arr, "e", "hello", 1); //$arr["e"] = "hello";最后一个参数表示字符串值是否复制
add_assoc_stringl();

zval *sub;
MAKE_STD_ZVAL(sub);
array_init(sub);
add_assoc_zval(arr, "f", sub); //$arr["f"] = $sub;

zval *arr;
MAKE_STD_ZVAL(arr);
array_init(arr); //$arr = array();
add_index_long(arr, 1, 10); //$arr[1] = 10;
add_index_unset(arr, 1); //unset($arr[1]);
add_index_bool(arr, 2, 1); //$arr[2] = true;
add_index_resource(arr, 3, 10); //$arr[3] = $resource;
add_index_double(arr, 4, 2.15); //$arr[4] = 2.15;
add_index_string(arr, 5, "hello", 1); //$arr[5] = "hello";最后一个参数表示字符串值是否复制
add_index_stringl();

zval *sub;
MAKE_STD_ZVAL(sub);
array_init(sub);
add_index_zval(arr, 6, sub); //$arr[6] = $sub;

zval *arr;
MAKE_STD_ZVAL(arr);
array_init(arr); //$arr = array();
add_next_index_long(arr, 10); //$arr[] = 10;
add_next_index_unset(arr); //unset($arr[]);
add_next_index_bool(arr, 1); //$arr[] = true;
add_next_index_resource(arr, 10); //$arr[] = $resource;
add_next_index_double(arr, 2.15); //$arr[] = 2.15;
add_next_index_string(arr, "hello", 1); //$arr[] = "hello";最后一个参数表示字符串值是否复制
add_next_index_stringl();

zval *sub;
MAKE_STD_ZVAL(sub);
array_init(sub);
add_next_index_zval(arr, sub); //$arr[] = $sub;

zval *obj;
MAKE_STD_ZVAL(obj);
object_init(obj);//$obj = new stdClass;
add_property_long(obj, "a", 10); //$obj->a = 10;
add_property_unset(obj, "a"); //unset($obj->a);
add_property_bool(obj, "b", 1); //$obj->b = true;
add_property_resource(obj, "c", 10); //$obj->c = $resource;
add_property_double(obj, "d", 2.15); //$obj->d = 2.15;
add_property_string(obj, "e", "hello", 1);//$obj->e = "hello"; 最后一个参数表示字符串值是否复制
add_property_stringl();

zval *sub;
MAKE_STD_ZVAL(sub);
object_init(sub); //$sub  = new stdClass;
add_property_zval(obj, "f", sub); //$obj->f = $sub;

一些操作的宏

#define Z_LVAL(zval)    (zval).value.lval
#define Z_BVAL(zval)    ((zend_bool)(zval).value.lval)
#define Z_DVAL(zval)    (zval).value.dval
#define Z_STRVAL(zval)  (zval).value.str.val
#define Z_STRLEN(zval)   (zval).value.str.len
#define Z_ARRVAL(zval)  (zval).value.ht
#define Z_OBJVAL(zval)  (zval).value.obj
#define Z_OBJ_HANDLE(zval)  Z_OBJVAL(zval).handle
#define Z_OBJ_HT(zval)      Z_OBJVAL(zval).handlers
#define Z_OBJCE(zval)       zend_get_class_entry(&(zval) TSRMLS_CC)
#define Z_OBJPROP(zval)     Z_OBJ_HT((zval))->get_properties(&(zval) TSRMLS_CC)
#define Z_OBJ_HANDLER(zval, hf) Z_OBJ_HT((zval))->hf
#define Z_RESVAL(zval)      (zval).value.lval
#define Z_OBJDEBUG(zval,is_tmp) (Z_OBJ_HANDLER((zval),get_debug_info)?Z_OBJ_HANDLER((zval),get_debug_info)(&(zval),&is_tmp TSRMLS_CC):(is_tmp=0,Z_OBJ_HANDLER((zval),get_properties)?Z_OBJPROP(zval):NULL)) 

#define Z_LVAL_P(zval_p)        Z_LVAL(*zval_p)
#define Z_BVAL_P(zval_p)        Z_BVAL(*zval_p)
#define Z_DVAL_P(zval_p)        Z_DVAL(*zval_p)
#define Z_STRVAL_P(zval_p)      Z_STRVAL(*zval_p)
#define Z_STRLEN_P(zval_p)      Z_STRLEN(*zval_p)
#define Z_ARRVAL_P(zval_p)      Z_ARRVAL(*zval_p)
#define Z_OBJPROP_P(zval_p)     Z_OBJPROP(*zval_p)
#define Z_OBJCE_P(zval_p)       Z_OBJCE(*zval_p)
#define Z_RESVAL_P(zval_p)      Z_RESVAL(*zval_p)
#define Z_OBJVAL_P(zval_p)      Z_OBJVAL(*zval_p)
#define Z_OBJ_HANDLE_P(zval_p)  Z_OBJ_HANDLE(*zval_p)
#define Z_OBJ_HT_P(zval_p)      Z_OBJ_HT(*zval_p)
#define Z_OBJ_HANDLER_P(zval_p, h)  Z_OBJ_HANDLER(*zval_p, h)   #define Z_OBJDEBUG_P(zval_p,is_tmp) Z_OBJDEBUG(*zval_p,is_tmp)

#define Z_LVAL_PP(zval_pp)      Z_LVAL(**zval_pp)
#define Z_BVAL_PP(zval_pp)      Z_BVAL(**zval_pp)
#define Z_DVAL_PP(zval_pp)      Z_DVAL(**zval_pp)
#define Z_STRVAL_PP(zval_pp)    Z_STRVAL(**zval_pp)
#define Z_STRLEN_PP(zval_pp)    Z_STRLEN(**zval_pp)
#define Z_ARRVAL_PP(zval_pp)    Z_ARRVAL(**zval_pp)
#define Z_OBJPROP_PP(zval_pp)   Z_OBJPROP(**zval_pp)
#define Z_OBJCE_PP(zval_pp)     Z_OBJCE(**zval_pp)
#define Z_RESVAL_PP(zval_pp)    Z_RESVAL(**zval_pp)
#define Z_OBJVAL_PP(zval_pp)    Z_OBJVAL(**zval_pp)
#define Z_OBJ_HANDLE_PP(zval_p) Z_OBJ_HANDLE(**zval_p)
#define Z_OBJ_HT_PP(zval_p)     Z_OBJ_HT(**zval_p)
#define Z_OBJ_HANDLER_PP(zval_p, h)     Z_OBJ_HANDLER(**zval_p, h)
#define Z_OBJDEBUG_PP(zval_pp,is_tmp)   Z_OBJDEBUG(**zval_pp,is_tmp)

#define Z_TYPE(zval)        (zval).type
#define Z_TYPE_P(zval_p)    Z_TYPE(*zval_p)
#define Z_TYPE_PP(zval_pp)  Z_TYPE(**zval_pp)
时间： 2024-12-29 09:55:54

深入PHP内核之函数的相关文章

Linux-0.12内核sleep_on函数分析

sleep_on用于进程休眠,原型如下: void sleep_on(struct task_struct **p) 当进程访问某个互斥资源时,如果资源被另外进程占用,当前进程就需要休眠. 假设资源的结构如下: struct res { .... struct task_struct *wait; } 其实我们参考下文件系统的i节点就会发现,i节点也是一种资源,它的结构体中就有一个变量i_wait.那么我们就用i节点举例.如果进程访问某个i节点,发现i节点被锁住,当前进程就需要睡眠:sleep_

嵌入式linux 内核关机函数实现

arch/arm/kernel/process.c 实现pm_power_off = 关机函数 参考 board-omap3touchbook.c 文件中 pm_power_off = omap3_touchbook_poweroff; static void omap3_touchbook_poweroff(void) { int pwr_off = TB_KILL_POWER_GPIO; if (gpio_request_one(pwr_off, GPIOF_OUT_INIT_LOW, "D

标准C IO函数和 内核IO函数 效率（时间）比较

前言 标准C提供的文件相关的IO函数,除标准错误输出是不带缓冲的(可以尽快的将错误消息显示出来)之外,所有与终端相关的都是行缓冲,其余都是全缓冲的. 我们可以使用setbuf,setvbuf改变指定流的缓冲类型. 原型: void setbuf(FILE *stream, char *buf);int setvbuf(FILE *stream, char *buf, int mode, size_t size); //成功返回0,失败非0 函数的用法一目了然,当参数buf指定为NULL时,操作系

内核延时函数

1) msleep:实现毫秒级的延时,该延时保证至少延时所设置的延时时间,不会提前超时返回,会让出CPU void msleep(unsigned int msecs) { unsigned long timeout = msecs_to_jiffies(msecs) + 1; while (timeout) timeout = schedule_timeout_uninterruptible(timeout); } 为什么在转换成jiffies时要+1呢?前边我们讲到,该延时要至少保证延时转换

深入理解PHP内核(六)函数的定义、传参及返回值

一.函数的定义 用户函数的定义从function 关键字开始,如下 function foo($var) { echo $var; } 1.词法分析 在Zend/zend_language_scanner.l中我们找到如下所示的代码: <ST_IN_SCRIPTING>"function" { return T_FUNCTION; } 它所表示的含义是function将会生成T_FUNCTION标记.在获取这个标记后,我们开始语法分析. 2.语法分析 在Zend/zend_

GPU并行编程：内核及函数的实现

原文链接 回想一下我们之前在设备上使用“kernelFunction<<<1,1>>>(..)”执行一个函数的代码,我在那里还曾说过后面会细说,本文就详细介绍一下参数N1,<<>>,这里就是并行魔法发生地. N1是我们想并行运行的块数,如果我们调用“kernelFunction<<<5,1>>>(..)”,这个函数将分成5个副本并行运行,每个副本称为一个块. 接下来我们必须要做的事情是,使用一个索引让每个副本为

深入理解PHP内核(五)函数的内部结构

php的函数包括用户定义的函数.内部函数(print_r count...).匿名函数.变量函数($func = 'print_r'; $func(array('a','b'));) PHP内核源码中将函数分为以下类型 #define ZEND_INTERNAL_FUNCTION 1 #define ZEND_USER_FUNCTION 2 #define ZEND_OVERLOADED_FUNCTION 3 #define ZEND_EVAL_CODE 4 #define ZEND_OVERL

linux中内核延时函数

第一类延时函数原型是:(忙等) void ndelay(unsigned long nsecs); void udelay(unsigned long usecs); void mdelay(unsigned long msecs); 说明:内核函数 ndelay, udelay, 以及 mdelay 对于短延时好用, 分别延后执行指定的纳秒数, 微秒数或者毫秒数. 它们涉及到的延时常常是最多几个毫秒. 第二类延时函数原型是:(使进程进入休眠) void msleep(unsigned int

内核链表函数详解

内核中经常采用链表来管理对象,先看一下内核中对链表的定义    struct list_head {        struct list_head *next, *prev;    }; 一般将该数据结构嵌入到其他的数据结构中,从而使得内核可以通过链表的方式管理新的数据结构,看一个例子: struct example {        member a;        struct list_head list;        member b;    }; 1.链表的定义和初始化 您可以通过