PHP内核-Zend引擎的详解

╰半橙微兮° 2022-01-09 19:21 280阅读 0赞

## 【精简版】 ##

在前面的章节介绍了PHP的生命周期，PHP的SAPI，SAPI处于PHP整个架构较上层，而真正脚本的执行主要由Zend引擎来完成， 这一小节我们介绍PHP脚本的执行。

目前编程语言可以分为两大类:

*  **第一类是像C/C++， .NET， Java之类的编译型语言， 它们的共性是: 运行之前必须对源代码进行编译，然后运行编译后的目标文件。**
 *  **第二类比如:PHP， Javascript， Ruby， Python这些解释型语言， 他们都无需经过编译即可"运行"，虽然可以理解为直接运行**

但它们并不是真的直接就被能被机器理解， 机器只能理解机器语言，那这些语言是怎么被执行的呢， 一般这些语言都需要一个解释器， 由解释器来执行这些源码， 实际上这些语言还是会经过编译环节， 只不过它们一般会在运行的时候实时进行编译。为了效率，并不是所有语言在每次执行的时候都会重新编译一遍， 比如PHP的各种opcode缓存扩展(如APC， xcache， eAccelerator等)，比如Python会将编译的中间文件保存成pyc/pyo文件， 避免每次运行重新进行编译所带来的性能损失。

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 </td> 
 <td> <code>&lt;?php</code> <code>$str</code> <code>= </code><code>"Hello, Tipi!\n"</code><code>;</code> <code>echo</code> <code>$str</code><code>;</code> <code>?&gt;</code> </td> 
 </tr> 
 </tbody> 
</table>

PHP的脚本的执行也需要一个解释器， 比如命令行下的php程序，或者apache的mod\_php模块等等。 前一节提到了PHP的SAPI接口， 下面就以PHP命令行程序为例解释PHP脚本是怎么被执行的。 例如如下的这段PHP脚本：

假设上面的代码保存在名为hello.php的文件中， 用PHP命令行程序执行这个脚本：

<table> 
 <tbody> 
 <tr> 
 <td> 1 </td> 
 <td> <code>$ php ./hello.php</code> </td> 
 </tr> 
 </tbody> 
</table>

这段代码的输出显然是Hello， Tipi!， 那么在执行脚本的时候PHP/Zend都做了些什么呢？ 这些语句是怎么样让php输出这段话的呢? 下面将一步一步的进行介绍。

![e835a466aebe5682d31840c8293dfe41-0.png][]

即:词法分析 => 语法分析 => opcode(中间代码)编译 =>Zend Engineer 执行

![f5d36566378a6b92b88b3aa2c6194f65-2.png][]

![7c9023e1323d734267a06d193a1a1676-5.png][]

![39c161b10256a517c153aa320712f3f0-7.png][]

\------------------------------------------------------------------------------------------------------------------------------------

## 【详情版】 ##

# [深入理解php内核 编写扩展 I：介绍PHP和Zend][php_ _ I_PHP_Zend] #

内容:

编写扩展I -  PHP和Zend起步  
原文：http://devzone.zend.com/public/view/tag/Extension  
Part I: Introduction to PHP and Zend  
http://devzone.zend.com/article/1021-Extension-Writing-Part-I-Introduction-to-PHP-and-Zend  
  
编写扩展\_II - 参数、数组和ZVALs  
编写扩展\_II - 参数、数组和ZVALs\[继续\]  
原文：http://devzone.zend.com/article/1022-Extension-Writing-Part-II-Parameters-Arrays-and-ZVALs  
Part II: Parameters,Arrays, and ZVALs  
原文：http://devzone.zend.com/article/1023-Extension-Writing-Part-II-Parameters-Arrays-and-ZVALs-continued  
Part II: Parameters,Arrays, and ZVALs \[continued\]  
  
编写扩展\_III - 资源  
Part III: Resources  
http://devzone.zend.com/article/1024-Extension-Writing-Part-III-Resources

# 编写扩展 I：介绍PHP和Zend #

介绍

扩展是什么？

生存周期

内存分配

建立构建环境

Hello World

构建你的扩展

初始设置（INI）

全局数值

初始设置（INI）作为全局数值

核对（代码）完整性

下一步是什么？

##  1.1介绍 ##

既然您正在阅读本教程，那么您或许对编写[PHP][]语言的扩展感兴趣。如果不是...呃，或许你并不知道这一兴趣，那么我们结束的时候你就会发现它。

本教程假定您基本熟悉PHP语言及其解释器实现所用的语言：C.

让我们从指明为什么你想要编写PHP扩展开始。

限于PHP语言本身的抽象程度，它不能直接访问某些库或特定于操作系统的调用。

你想要通过某些不平常的方法定制PHP的行为。

你有一些现成的PHP代码，但是你知道它可以（运行）更快、（占用空间）更小，而且消耗更少的内存。

你有一些不错的代码出售，买家可以使用它，但重要的是不能看到源代码。

这些都是非常正当的理由，但是，在创建扩展之前，你需要首先明白zend和php以及扩展分别是什么？

##  1.2 Zend 和PHP ##

Zend 指的是语言引擎，PHP 指的是我们从外面看到的一套完整的系统。这听起来有点糊涂，但其实并不复杂（见图3-1 PHP 内部结构图）。为了实现一个 WEB 脚本的解释器，你需要完成以下三个部分的工作：

1、 解释器部分，负责对输入代码的分析、翻译和执行；  
2、 功能性部分，负责具体实现语言的各种功能（比如它的函数等等）；  
3、 接口部分，负责同 WEB 服务器的会话等功能。

Zend包括了第一部分的全部和第二部分的局部，PHP 包括了第二部分的局部和第三部分的全部。他们合起来称之为 PHP 包。Zend 构成了语言的核心，同时也包含了一些最基本的 PHP 预定义函数的实现。PHP 则包含了所有创造出语言本身各种显著特性的模块。  
  ![0_133230415132n5.gif][]

## 1.3 扩展是什么？ ##

如果你用过PHP，那么你肯定用到过扩展。除了少数例外，每个用户空间的函数都被组织在不同的扩展中。这些函数中的很多够成了standard扩展－总数超过400。PHP本身带有86个扩展（原文写就之时－译注），平均每个含有大约30个函数。数学操作方面大约有2500个函数。似乎这还不够， PECL仓库另外提供了超过100个扩展，而且互联网上可以找到更多。

“除了扩展中的函数，还有什么？”我听到了你的疑问。 “扩展的里面是什么？PHP的‘核心’是什么？”

**PHP的核心由两部分组成**：

**1）Zend引擎**：最底层是Zend引擎（ZE）。ZE把人类易读的脚本解析成机器可读的符号，然后在进程空间内执行这些符号。ZE也处理内存管理、变量作用域及调度程序调用。

** 2）PHP内核**：另一部分是PHP内核，它绑定了SAPI层（Server Application Programming Interface，通常涉及主机环境，如Apache，IIS，CLI，CGI等），并处理与它的通信。它同时对safe\_mode和open\_basedir的检测提供一致的控制层，就像流层将fopen()、fread()和fwrite()等用户空间的函数与文件和网络I/O联系起来一样。

##  1.4 生存周期 ##

当给定的SAPI启动时，例如在对/usr/local/apache/bin/apachectl start的响应中，PHP由初始化其内核子系统开始。在接近启动例程的末尾，它加载每个扩展的代码并调用其模块初始化例程（MINIT）。这使得每个扩展可以初始化内部变量、分配资源、注册资源处理器，以及向ZE注册自己的函数，以便于脚本调用这其中的函数时候ZE知道执行哪些代码。

接下来，PHP等待SAPI层请求要处理的页面。对于CGI或CLI等SAPI，这将立刻发生且只发生一次。对于Apache、IIS或其他成熟的web服务器SAPI，每次远程用户请求页面时都将发生，因此重复很多次，也可能并发。不管请求如何产生，PHP开始于要求ZE建立脚本的运行环境，然后调用每个扩展的请求初始化 （RINIT）函数。RINIT使得扩展有机会设定特定的环境变量，根据请求分配资源，或者执行其他任务，如审核。 session扩展中有个RINIT作用的典型示例，如果启用了session.auto\_start选项，RINIT将自动触发用户空间的session\_start()函数以及预组装$\_SESSION变量。

一旦请求被初始化了，ZE开始接管控制权，将PHP脚本翻译成符号，最终形成操作码并逐步运行之。如任一操作码需要调用扩展的函数，ZE将会把参数绑定到该函数，并且临时交出控制权直到函数运行结束。

脚本运行结束后，PHP调用每个扩展的请求关闭（RSHUTDOWN）函数以执行最后的清理工作（如将session变量存入磁盘）。接下来，ZE执行清理过程（垃圾收集）－有效地对之前的请求期间用到的每个变量执行unset()。

一旦完成，PHP继续等待SAPI的其他文档请求或者是关闭信号。对于CGI和CLI等SAPI，没有“下一个请求”，所以SAPI立刻开始关闭。关闭期间，PHP再次遍历每个扩展，调用其模块关闭（MSHUTDOWN）函数，并最终关闭自己的内核子系统。

这个过程乍听起来很让人气馁，但是一旦你深入一个运转的扩展，你会逐渐开始了解它。

无论通过多进程(通常编译为apache的模块来处理单进程(CLI/CGI模式)还是PHP请求),多线程模式  
     SAPI运行PHP都经过下面几个阶段:  
       1、**模块初始化阶段(Module init)   **  ：  
           即调用每个拓展源码中的的PHP\_MINIT\_FUNCTION中的方法初始化模块,进行一些模块所需变量的申请,内存分配等。  
        2、**请求初始化阶段(Request init)** ：  
           即接受到客户端的请求后调用每个拓展的PHP\_RINIT\_FUNCTION中的方法,初始化PHP脚本的执行环境。  
        3、**执行PHP脚本**  
        4、**请求结束(Request Shutdown) **：  
          这时候调用每个拓展的PHP\_RSHUTDOWN\_FUNCTION方法清理请求现场,并且ZE开始回收变量和内存。  
        5、**关闭模块(Module shutdown) **    ：  
           Web服务器退出或者命令行脚本执行完毕退出会调用拓展源码中的PHP\_MSHUTDOWN\_FUNCTION 方法

详细的内容在后面的博文[ 深入理解php内核：php生命周期][php_php]：http://blog.csdn[.NET][]/hguisu/article/details/7377520

## 1.4  内存分配 ##

资源管理仍然是一个极为关键的问题，尤其是对服务器软件而言。资源里最具宝贵的则非内存莫属了，内存管理也必须极端小心。内存管理在 Zend 中已经被部分抽象，而且你也应该坚持使用这些抽象，原因显而易见：由于得以抽象，Zend 就可以完全控制内存的分配。Zend 可以确定一块内存是否在使用，也可以自动释放未使用和失去引用的内存块，因此就可以避免内存泄漏。

为了避免内存泄漏，ZE使用附加的标志来执行自己内部的内存管理器以标识持久性。持久分配的内存意味着比单次请求更持久。对比之下，对于在请求期间的非持久分配，不论是否调用释放（内存）函数，都将在请求尾期被释放。例如，用户空间的变量被分配为非持久的，因为请求结束后它们就没用了。

然而，理论上，扩展可以依赖ZE在页面请求结束时自动释放非持久内存，但是不推荐这样做。因为分配的内存将在很长时间保持为未回收状态，与之相关联的资源可能得不到适当的关闭，并且吃饭不擦嘴是坏习惯。稍后你会发现，事实上确保所有分配的数据都被正确清理很容易。

让我们简单地比较传统的内存分配函数（只应当在外部库中使用）和PHP/ZE的持久的以及非持久的内存非配函数。

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;"> 传统的 </td> 
 <td style="vertical-align:top;"> 非持久的 </td> 
 <td style="vertical-align:top;"> 持久的 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> malloc(count) calloc(count, num) </td> 
 <td style="vertical-align:top;"> emalloc(count)&nbsp;用于替代malloc()。 ecalloc(count, num)&nbsp;用于替代calloc()。 </td> 
 <td style="vertical-align:top;"> pemalloc(count, 1)* pecalloc(count, num, 1) </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> strdup(str) strndup(str, len) </td> 
 <td style="vertical-align:top;"> estrdup(str) estrndup(str, len) </td> 
 <td style="vertical-align:top;"> pestrdup(str, 1) pemalloc() &amp; memcpy() </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> free(ptr) </td> 
 <td style="vertical-align:top;"> efree(ptr) </td> 
 <td style="vertical-align:top;"> pefree(ptr, 1) </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> realloc(ptr, newsize) </td> 
 <td style="vertical-align:top;"> erealloc(ptr, newsize) </td> 
 <td style="vertical-align:top;"> perealloc(ptr, newsize, 1) </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> malloc(count * num + extr)** </td> 
 <td style="vertical-align:top;"> safe_emalloc(count, num, extr) </td> 
 <td style="vertical-align:top;"> safe_pemalloc(count, num, extr) </td> 
 </tr> 
 </tbody> 
</table>

\* pemalloc()族包含一个‘持久’标志以允许它们实现对应的非持久函数的功能。

例如：emalloc(1234)与pemalloc(1234, 0)相同。

\*\* safe\_emalloc()和（PHP 5中的）safe\_pemalloc()执行附加检测以防整数溢出。

## 1.5建立构建环境 ##

既然你已经了解了一些PHP和Zend引擎的内部运行理论，我打赌你希望继续深入并开始构建一些东西。在此之前，你需要收集一些必需的构建工具并设定适合于你的目的的环境。

首先，你需要PHP本身及其所需要的构建工具集。如果你不熟悉从源码构建PHP，我建议你看看http://www.php[.Net][.NET]/install.unix。（为Windows开发PHP扩展将在以后的文章中提到）。然而，使用PHP的二进制分发包有些冒险，这些版本倾向于忽略./configure的两个重要选项，它们在开发过程中很便利。第一个--enable-debug。这个选项将把附加的符号信息编译进PHP的执行文件，以便如果发生段错误，你能从中得到一个内核转储文件，使用gdb追踪并发现什么地方以及为什么会发生段错误。另一个选项依赖于你的PHP版本。在PHP 4.3中该选项名为--enable-experimental-zts，在PHP 5及以后的版本中为--enable-maintainer-zts。这个选项使PHP以为自己执行于多线程环境，并且使你能捕获通常的程序错误，然而它们在非多线程环境中是无害的，却使你的扩展不可安全用于多线程环境。一旦你已经使用这些额外的选项编译了PHP并安装于你的开发服务器（或者工作站）中，你就可以把你的第一个扩展加入其中了。

## 1.5 Hello World ##

什么程序设计的介绍可以完全忽略必需的Hello World程序？此例中，你将制作的扩展导出一个简单函数，它返回一个含有“Hello World”的字符串。用PHP的话你或许这样做：

1. <?php  
2.   
3. function hello\_world() \{  
4.      return 'Hello World';  
5. \}

现在你将把它转入PHP扩展。首先，我们在你的PHP源码树的目录ext/中创建一个名为hello的目录，并且chdir进入该目录。事实上，这个目录可以置于PHP源码树之中或之外的任何地方，但是我希望你把它放在这儿，以例示一个在以后的文章中出现的与此无关的概念。你需要在这儿创建3个文件：包含hello\_world函数的源码文件，包含引用的头文件，PHP用它们加载你的扩展，以及phpize用来准备编译你的扩展的配置文件。

**其实这个三个文件都使用php自带的工具ext\_skel生成。ext\_skel工具在源码包目录下。然后使用phpize建立php扩展**

**步骤：**

**生成模块名为hello\_module : $ ./ext\_skel --extname=hello\_module**

**执行phpize:$ /usr/local/php/bin/phpize**

**Confugre: :$ ./configure --enable-hello\_module --with-apxs=/usr/local/apache/bin/apxs --with-php-              config=/usr/local/php/bin/php-config**

**编译   ：$ make**

### phpize用来准备编译你的扩展的配置文件:config.m4 ###

对于config.m4文档的说明：[http://www.php.net/manual/zh/internals2.buildsys.configunix.php][http_www.php.net_manual_zh_internals2.buildsys.configunix.php]

在这里我们使用PHP\_ARG\_ENABLE()来简单创建--enable-\* 选项 --enable-hello\_module

1.  PHP\_ARG\_ENABLE(hello,whether to enable Hello World support,  
2.    
3.  \[ --enable-hello  Enable Hello World support\])  
4.    
5.  if test"$PHP\_HELLO" = "yes"; then  
6.    
7.    AC\_DEFINE(HAVE\_HELLO,1, \[Whether you have Hello World\])  
8.    
9.    PHP\_NEW\_EXTENSION(hello,hello.c, $ext\_shared)  
10.   
11. fi  
12.   
13.

### 包含引用的头文件:php\_hello.h ###

1.  \#ifndef PHP\_HELLO\_H  
2.      \#define PHP\_HELLO\_H 1  
3.      \#definePHP\_HELLO\_WORLD\_VERSION "1.0"  
4.      \#define PHP\_HELLO\_WORLD\_EXTNAME"hello"  
5.    
6.      PHP\_FUNCTION(hello\_world);  
7.      extern zend\_module\_entry   hello\_module\_entry;  
8.      \#define phpext\_hello\_ptr&hello\_module\_entry  
9.  \#endif

### 包含hello\_world函数的源码文件 :hello.c ###

1.  \#ifdef HAVE\_CONFIG\_H  
2.     \#include"config.h"  
3.  \#endif  
4.    
5.  \#include "php.h"  
6.  \#include"php\_hello.h"  
7.    
8.  static function\_entry    hello\_functions\[\] = \{  
9.         PHP\_FE(hello\_world, NULL)  
10.        \{NULL, NULL, NULL\}  
11. \};  
12.   
13. zend\_module\_entry    hello\_module\_entry = \{  
14.         \#if ZEND\_MODULE\_API\_NO>= 20010901  
15.                STANDARD\_MODULE\_HEADER,  
16.        \#endif  
17.        hello\_module,  
18.        hello\_functions,  
19.        NULL,  
20.        NULL,  
21.        NULL,  
22.        NULL,  
23.        NULL,  
24.       \#if ZEND\_MODULE\_API\_NO>= 20010901  
25.                 PHP\_HELLO\_WORLD\_VERSION,  
26.       \#endif  
27.       STANDARD\_MODULE\_PROPERTIES  
28. \};  
29.   
30. \#ifdef  COMPILE\_DL\_HELLO  
31.        ZEND\_GET\_MODULE(hello)  
32. \#endif  
33.   
34. PHP\_FUNCTION(hello\_world)  
35. \{  
36.          RETURN\_STRING("HelloWorld", 1);  
37. \}

在上面的示例扩展中，你所看到的代码大多是黏合剂，作为将扩展引入PHP的协议语言并且在其间建立会话用于通信。**只有最后四行才是你所认为“实际做事的代码”**，它们负责与用户空间的脚本交互这一层次。这些代码看起来确实非常像之前看到的PHP代码，而且一看就懂：

声明一个名为hello\_world的函数

让该函数返回字符串：“Hello World” , 那个1是怎么回事儿？

回忆一下，ZE包含一个复杂的内存管理层，它可以确保分配的资源在脚本退出时被释放。然而，在内存管理领域，两次释放同一块内存是绝对禁止的（big no-no）。这种被称为二次释放（double freeing）的做法，是引起段错误的一个常见因素，原因是它使调用程序试图访问不再拥有的内存。类似地，你不应该让ZE去释放一个静态字符串缓冲区（如我们的示例扩展中的“Hello World”），因为它存在于程序空间，而不是被任何进程（process）拥有的数据块。RETURN\_STRING()可以假定传入其中的任何字符串都需要被复制以便稍后可被安全地释放；但是由于内部的函数给字符串动态地分配内存、填充并返回并不罕见，第二参数RETURN\_STRING()允许我们指定是否需要拷贝字符串的副本。要进一步说明这个概念，下面的代码片段与上面的对应版本等效：

1.  PHP\_FUNCTION(hello\_world)  
2.  \{  
3.         char \*str;  
4.         str = estrdup("HelloWorld");  
5.         RETURN\_STRING(str, 0);  
6.  \}

在这个版本中，你手工为最终将被传回调用脚本的字符串“Hello World”分配内存，然后把这快内存“给予”RETURN\_STRING()，用第二参数0指出它不需要制作自己的副本，可以拥有我们的。

## 1.6构建你的扩展 ##

本练习的最后一步是将你的扩展构建为可动态加载的模块。如果你已经正确地拷贝了上面的代码，只需要在ext/hello/中运行3个命令：

$ phpize

$ ./configure--enable-hello\_module

$ make

每个命令都运行后，可在目录ext/hello/modules/中看到文件hello.so。现在，你可像其他扩展一样把它拷贝到你的扩展目录（默认是/usr/local/lib/php/extensions/，检查你的php.ini以确认），把extension=hello.so加入你的php.ini以使PHP启动时加载它。 对于CGI/CLI，下次运行PHP就会生效；对于web服务器SAPI，如Apache，需要重新启动web服务器。我们现在从命令行尝试下：

$ php -r 'echo  hello\_world();'

如果一切正常，你会看到这个脚本输出的Hello World，因为你的已加载的扩展中的函数hello\_world()返回这个字符串，而且echo命令原样输出传给它的内容（本例中是函数的结果）。

可以同样的方式返回其他标量:

整数值用 ：RETURN\_LONG()，

浮点值用 ：RETURN\_DOUBLE()，

布尔值值用：RETURN\_BOOL()，

NULL 值用：RETURN\_NULL()。

我们看下它们各自在实例中的应用，通过在文件hello.c中的function\_entry结构中添加对应的几行PHP\_FE()，并且在文件结尾添加一些PHP\_FUNCTION()。

1.  static function\_entry   hello\_functions\[\] = \{  
2.      PHP\_FE(hello\_world, NULL)  
3.      PHP\_FE(hello\_long, NULL)  
4.      PHP\_FE(hello\_double, NULL)  
5.      PHP\_FE(hello\_bool, NULL)  
6.      PHP\_FE(hello\_null, NULL)  
7.      \{NULL, NULL, NULL\}  
8.  \};  
9.  PHP\_FUNCTION(hello\_long)  
10. \{  
11.       RETURN\_LONG(42);  
12. \}  
13. PHP\_FUNCTION(hello\_double)  
14. \{  
15.      RETURN\_DOUBLE(3.1415926535);  
16. \}  
17. PHP\_FUNCTION(hello\_bool)  
18. \{  
19.      RETURN\_BOOL(1);  
20. \}  
21. PHP\_FUNCTION(hello\_null)  
22. \{  
23.       RETURN\_NULL();  
24. \}

你也需要在头文件php\_hello.h中函数hello\_world()的原型声明旁边加入这些函数的原型声明，以便构建进程正确进行：

1.  PHP\_FUNCTION(hello\_world);  
2.  PHP\_FUNCTION(hello\_long);  
3.  PHP\_FUNCTION(hello\_double);  
4.  PHP\_FUNCTION(hello\_bool);  
5.  PHP\_FUNCTION(hello\_null);

由于你没有改变文件config.m4，这次跳过phpize和./configure步骤直接跳到make在技术上是安全的。然而，此时我要你再次做完全部构建步骤，以确保构建良好。另外，你应该调用make clean all而不是简单地在最后一步make，确保所有源文件被重建。重复一遍，迄今为止，根据你所做得改变的类型这些（步骤）不是必需的，但是安全比混淆要好。一旦模块构建好了，再次把它拷贝到你的扩展目录，替换旧版本。

此时你可以再次调用PHP解释器， 简单地传入脚本[测试][Link 1]刚加入的函数。事实上，为什么不现在就做呢？我会在这儿等待...

完成了？好的。如果用了var\_dump()而不是echo查看每个函数的输出，你或许注意到了hello\_bool()返回true。那就是RETURN\_BOOL()中的值1表现的结果。和在PHP脚本中一样，整数值0等于FALSE，而其他整数等于TRUE。仅仅是作为约定，扩展作者通常用1，鼓励你也这么做，但是不要感觉被它限制了。出于另外的可读性目的，也可用宏RETURN\_TRUE和RETURN\_FALSE；再来一个hello\_bool()，这次使用RETURN\_TRUE：

1.  PHP\_FUNCTION(hello\_bool)  
2.  \{  
3.       RETURN\_TRUE;  
4.  \}

注意这儿没用括号。那样的话，与其他的宏RETURN\_\*()相比，RETURN\_TRUE和RETURN\_FALSE的样式有区别（are aberrations），所以确信不要被它误导了（to get caught by this one）。

大概你注意到了，上面的每个范例中，我们都没传入0或1以表明是否进行拷贝。这是因为，对于类似这些简单的小型标量，不需要分配或释放额外的内存（除了变量容器自身－我们将在第二部分作更深入的考查。）

还有其他的三种返回类型：资源（就像mysql\_connect()，fsockopen()和ftp\_connect()返回的值的名字一样，但是不限于此），数组（也被称为HASH）和对象（由关键字new返回）。当我们深入地讲解变量时，会在第二部分看到它们。

## 1.7初始设置（INI） ##

Zend引擎提供了两种管理INI值的途径。现在我们来看简单一些的，然后当你处理全局数据时再探究更完善但也更复杂的方式。假设你要在php.ini中为你的扩展定义一个值，hello.greeting，它保存将在hello\_world()函数中用到的问候字符串。你需要向hello.c和php\_hello.h中增加一些代码，同时对hello\_module\_entry结构作一些关键性的改变。先在文件php\_hello.h中靠近用户空间函数的原型声明处增加如下原型：

PHP\_MINIT\_FUNCTION(hello);

PHP\_MSHUTDOWN\_FUNCTION(hello);

PHP\_FUNCTION(hello\_world);

PHP\_FUNCTION(hello\_long);

PHP\_FUNCTION(hello\_double);

PHP\_FUNCTION(hello\_bool);

PHP\_FUNCTION(hello\_null);

现在进入文件hello.c，去掉当前版本的hello\_module\_entry，用下面的列表替换它：

1.  zend\_module\_entry    hello\_module\_entry = \{  
2.      \#if ZEND\_MODULE\_API\_NO>= 20010901  
3.         STANDARD\_MODULE\_HEADER,  
4.      \#endif  
5.      PHP\_HELLO\_WORLD\_EXTNAME,  
6.      hello\_functions,  
7.      PHP\_MINIT(hello),  
8.      PHP\_MSHUTDOWN(hello),  
9.      NULL,  
10.     NULL,  
11.     NULL,  
12.     \#if ZEND\_MODULE\_API\_NO>= 20010901  
13.        PHP\_HELLO\_WORLD\_VERSION,  
14.     \#endif  
15.     STANDARD\_MODULE\_PROPERTIES  
16. \};  
17. PHP\_INI\_BEGIN()  
18. PHP\_INI\_ENTRY("hello.greeting","Hello World", PHP\_INI\_ALL, NULL)  
19. PHP\_INI\_END()  
20. PHP\_MINIT\_FUNCTION(hello)  
21. \{  
22.     REGISTER\_INI\_ENTRIES();  
23.     return SUCCESS;  
24. \}  
25. PHP\_MSHUTDOWN\_FUNCTION(hello)  
26. \{  
27.     UNREGISTER\_INI\_ENTRIES();  
28.     return SUCCESS;  
29. \}

现在，你只需要在文件hello.c顶部的那些\#include旁边增加一个\#include，这样可以获得正确的支持INI的头文件：

1.  \#ifdef HAVE\_CONFIG\_H  
2.  \#include"config.h"  
3.  \#endif  
4.  \#include "php.h"  
5.  \#include"php\_ini.h"  
6.  \#include"php\_hello.h"

最后，你可修改函数hello\_world让它使用INI的值：

PHP\_FUNCTION(hello\_world)

RETURN\_STRING(INI\_STR("hello.greeting"),1);

注意，你将要拷贝从INI\_STR()返回的值。这是因为，在进入PHP变量堆栈之前（as far as the PHP variable stack is concerned），它都是个静态字符串。实际上，如果你试图修改这个返回的字符串，PHP执行环境会变得不稳定，甚至崩溃。

本节中的第一处改变引入了两个你非常熟悉的函数：MINIT和MSHUTDOWN。正如稍早提到的，这些方法在SAPI初始启动和最终关闭期间被各自调用。它们不会在请求期间和请求之间被调用。本例中它们用来将你的扩展中定义的条目向php.ini注册。本系列后面的教程中，你也将看到如何使用MINIT和MSHUTDOWN函数注册资源、对象和流处理器。

函数hello\_world()中使用INI\_STR()取得hello.greeting条目的当前字符串值。也存在其他类似函数用于取得其他类型的值，长整型、双精度浮点型和布尔型，如下面表格中所示；同时也提供另外的ORIG版本，它们提供在php.ini文件中的INI（的原始）设定（在被 .htaccess或ini\_set()指令改变之前）（原文：provides the valueof the referenced INI setting as it was set in php.ini－译注）。

当前值 原始值 类型

INI\_STR(name)INI\_ORIG\_STR(name) char \* (NULL terminated)

INI\_INT(name)INI\_ORIG\_INT(name) signed long

INI\_FLT(name)INI\_ORIG\_FLT(name) signed double

INI\_BOOL(name)INI\_ORIG\_BOOL(name) zend\_bool

传入PHP\_INI\_ENTRY()的第一个参数含有在php.ini文件中用到的名字字符串。为了避免命名空间冲突，你应该使用同函数一样的约定，即是，将你的扩展的名字作为所有值的前缀，就像你对hello.greeting做的一样。仅仅是作为约定，一个句点被用来分隔扩展的名字和更具说明性的初始设定名字。

第二个参数是初始值（默认值？－译注），而且，不管它是不是数字值，都要使用char\*类型的字符串。这主要是依据如下事实：.ini文件中的原值就是文本－连同其他的一切作为一个文本文件存储。你在后面的脚本中所用到的INI\_INT()、INI\_FLT()或INI\_BOOL()会进行类型转换。

传入的第三个值是访问模式修饰符。这是个位掩码字段，它决定该INI值在何时和何处是可修改的。对于其中的一些，如register\_globals，它只是不允许在脚本中用ini\_set()改变该值，因为这个设定只在请求启动期间（在脚本能够运行之前）有意义。其他的，如allow\_url\_fopen，是管理（员才可进行的）设定，你不会希望共享主机环境的用户去修改它，不论是通过ini\_set()还是.htaccess的指令。该参数的典型值可能是PHP\_INI\_ALL，表明该值可在任何地方被修改。然后还有PHP\_INI\_SYSTEM|PHP\_INI\_PERDIR，表明该设定可在php.ini文件中修改，或者通过.htaccess文件中的Apache指令修改，但是不能用ini\_set()修改。或者，也可用PHP\_INI\_SYSTEM，表示该值只能在php.ini文件中修改，而不是任何其他地方。

我们现在忽略第四个参数，只是提一下，它允许在初始设定发生改变时－例如使用ini\_set()－触发一个方法回调。这使得当设定改变时，扩展可以执行更精确的控制，或是根据新的设定触发一个相关的行为。

## 1.8全局数值 ##

扩展经常需要在一个特定的请求中由始至终跟踪一个值，而且要把它与可能同时发生的其他请求分开。在非多线程的SAPI中很简单：只是在源文件中声明一个全局变量并在需要时访问它。问题是，由于PHP被设计为可在多线程web服务器（如Apache 2和IIS）中运行，它需要保持各线程使用的全局数值的独立。通过使用TSRM (Thread Safe Resource Management，线程安全的资源管理器) 抽象层－有时称为ZTS（Zend Thread Safety，Zend线程安全），PHP将其极大地简化了。实际上，此时你已经用到了部分TSRM，只是没有意识到。（不要探寻的太辛苦；随着本系列的进行，你将到处看到它的身影。）

如同任意的全局作用域，创建一个线程安全的作用域的第一步是声明它。鉴于本例的目标，你将会声明一个值为0的long型全局数值。每次hello\_long()被调用，都将该值增1并返回。在php\_hello.h文件中的\#define PHP\_HELLO\_H语句后面加入下面的代码段：

\#ifdef ZTS

\#include "TSRM.h"

\#endif

ZEND\_BEGIN\_MODULE\_GLOBALS(hello)

long counter;

ZEND\_END\_MODULE\_GLOBALS(hello)

\#ifdef ZTS

\#define HELLO\_G(v)TSRMG(hello\_globals\_id, zend\_hello\_globals \*, v)

\#else

\#define HELLO\_G(v)(hello\_globals.v)

\#endif

这次也会使用RINIT方法，所以你需要在头文件中声明它的原型：

PHP\_MINIT\_FUNCTION(hello);

PHP\_MSHUTDOWN\_FUNCTION(hello);

PHP\_RINIT\_FUNCTION(hello);

现在我们回到文件hello.c中并紧接着包含代码块后面加入下面的代码：

\#ifdef HAVE\_CONFIG\_H

\#include"config.h"

\#endif

\#include "php.h"

\#include"php\_ini.h"

\#include"php\_hello.h"

ZEND\_DECLARE\_MODULE\_GLOBALS(hello)

改变hello\_module\_entry，加入PHP\_RINIT(hello)：

zend\_module\_entryhello\_module\_entry = \{

\#if ZEND\_MODULE\_API\_NO>= 20010901

STANDARD\_MODULE\_HEADER,

\#endif

PHP\_HELLO\_WORLD\_EXTNAME,

hello\_functions,

PHP\_MINIT(hello),

PHP\_MSHUTDOWN(hello),

PHP\_RINIT(hello),

NULL,

\#if ZEND\_MODULE\_API\_NO>= 20010901

PHP\_HELLO\_WORLD\_VERSION,

\#endif

STANDARD\_MODULE\_PROPERTIES

\};

而且修改你的MINIT函数，附带着另外两个函数，它们在请求启动时执行初始化：

static voidphp\_hello\_init\_globals(zend\_hello\_globals \*hello\_globals)

PHP\_RINIT\_FUNCTION(hello)

HELLO\_G(counter) = 0;

return SUCCESS;

PHP\_MINIT\_FUNCTION(hello)

ZEND\_INIT\_MODULE\_GLOBALS(hello,php\_hello\_init\_globals, NULL);

return SUCCESS;

最后，你可修改hello\_long()函数使用这个值：

PHP\_FUNCTION(hello\_long)

HELLO\_G(counter)++;

RETURN\_LONG(HELLO\_G(counter));

在你加入php\_hello.h的代码中，你用到了两个宏－ZEND\_BEGIN\_MODULE\_GLOBALS()和ZEND\_END\_MODULE\_GLOBALS()－用来创建一个名为zend\_hello\_globals的结构，它包含一个long型的变量。然后有条件地将HELLO\_G()定义为从线程池中取得数值，或者从全局作用域中得到－如果你编译的目标是非多线程环境。

在hello.c中，你用ZEND\_DECLARE\_MODULE\_GLOBALS()宏来例示zend\_hello\_globals结构，或者是真的全局（如果此次构建是非线程安全的），或者是本线程的资源池的一个成员。作为扩展作者，我们不需要担心它们的区别，因为Zend引擎为我们打理好这个事情。最后，你在 MINIT中用ZEND\_INIT\_MODULE\_GLOBALS()分配一个线程安全的资源id－现在还不用考虑它是什么。

你可能已经注意到了，php\_hello\_init\_globals()实际上什么也没做，却得多声明个RINIT将变量counter初始化为0。为什么？

关键在于这两个函数何时被调用。php\_hello\_init\_globals()只在开始一个新的进程或线程时被调用；然而， 每个进程都能处理多个请求，所以用这个函数将变量counter初始化为0将只在第一个页面请求时运行。向同一进程发出的后续页面请求将仍会得到以前存储在这儿的counter变量的值，因此不会从0开始计数。要为每个页面请求把counter变量初始化为0，我们实现RINIT函数， 正如之前看到的，它在每个页面请求之前被调用。此时我们包含php\_hello\_init\_globals()函数是因为稍后你将会用到它，而且在ZEND\_INIT\_MODULE\_GLOBALS()中为这个初始化函数传入NULL将导致在非多线程的平台产生段错误。

## 1.9初始设置（INI）作为全局数值 ##

回想一下，一个用PHP\_INI\_ENTRY()声明的php.ini值会作为字符串被解析，并按需用INI\_INT()、INI\_FLT()和INI\_BOOL()转为其他格式。对于某些设定，那么做使得在脚本的执行过程中，当读取这些值时反复做大量不需要的重复工作。幸运的是，可以让ZE将INI值存储为特定的数据类型，并只在它的值被改变时执行类型转换。我们通过声明另一个INI值来尝试下，这次是个布尔值，用来指示变量counter是递增还是递减。开始吧，先把php\_hello.h中的MODULE\_GLOBALS块改成下面的代码：

ZEND\_BEGIN\_MODULE\_GLOBALS(hello)

long counter;

zend\_bool direction;

ZEND\_END\_MODULE\_GLOBALS(hello)

接下来，修改PHP\_INI\_BEGIN()块，声明INI值，像这样：

PHP\_INI\_BEGIN()

PHP\_INI\_ENTRY("hello.greeting","Hello World", PHP\_INI\_ALL, NULL)

STD\_PHP\_INI\_ENTRY("hello.direction","1", PHP\_INI\_ALL, OnUpdateBool, direction, zend\_hello\_globals,hello\_globals)

PHP\_INI\_END()

现在用下面的代码初始化init\_globals方法中的设定：

static void php\_hello\_init\_globals(zend\_hello\_globals\*hello\_globals)

hello\_globals->direction= 1;

并且最后，在hello\_long()中应用这个初始设定来决定是递增还是递减：

PHP\_FUNCTION(hello\_long)

if (HELLO\_G(direction)) \{

HELLO\_G(counter)++;

\} else \{

HELLO\_G(counter)--;

RETURN\_LONG(HELLO\_G(counter));

就是这些。在INI\_ENTRY部分指定的OnUpdateBool方法会自动地把php.ini、.htaccess或者脚本中通过ini\_set()提供的值转换为适当的TRUE/FALSE值，这样你就可以在脚本中直接访问它们。STD\_PHP\_INI\_ENTRY的最后三个参数告诉PHP去改变哪个全局变量，我们的扩展的全局（作用域）的结构是什么样子，以及持有这些变量的全局作用域的名字是什么。

## 1.10核对（代码）完整性 ##

迄今为止，我们的三个文件应该类似于下面的列表。（为了可读性，一些项目被移动和重新组织了。）

###        config.m4 ###

PHP\_ARG\_ENABLE(hello,whether to enable Hello World support,

\[ --enable-hello  Enable Hello World support\])

if test"$PHP\_HELLO" = "yes"; then

AC\_DEFINE(HAVE\_HELLO,1, \[Whether you have Hello World\])

PHP\_NEW\_EXTENSION(hello,hello.c, $ext\_shared)

###        php\_hello.h ###

\#ifndef PHP\_HELLO\_H

\#define PHP\_HELLO\_H 1

\#ifdef ZTS

\#include "TSRM.h"

\#endif

ZEND\_BEGIN\_MODULE\_GLOBALS(hello)

long counter;

zend\_bool direction;

ZEND\_END\_MODULE\_GLOBALS(hello)

\#ifdef ZTS

\#define HELLO\_G(v)TSRMG(hello\_globals\_id, zend\_hello\_globals \*, v)

\#else

\#define HELLO\_G(v)(hello\_globals.v)

\#endif

\#definePHP\_HELLO\_WORLD\_VERSION "1.0"

\#definePHP\_HELLO\_WORLD\_EXTNAME "hello"

PHP\_MINIT\_FUNCTION(hello);

PHP\_MSHUTDOWN\_FUNCTION(hello);

PHP\_RINIT\_FUNCTION(hello);

PHP\_FUNCTION(hello\_world);

PHP\_FUNCTION(hello\_long);

PHP\_FUNCTION(hello\_double);

PHP\_FUNCTION(hello\_bool);

PHP\_FUNCTION(hello\_null);

extern zend\_module\_entryhello\_module\_entry;

\#define phpext\_hello\_ptr&hello\_module\_entry

\#endif

### hello.c ###

\#ifdef HAVE\_CONFIG\_H

\#include"config.h"

\#endif

\#include "php.h"

\#include"php\_ini.h"

\#include"php\_hello.h"

ZEND\_DECLARE\_MODULE\_GLOBALS(hello)

static function\_entryhello\_functions\[\] = \{

PHP\_FE(hello\_world, NULL)

PHP\_FE(hello\_long, NULL)

PHP\_FE(hello\_double, NULL)

PHP\_FE(hello\_bool, NULL)

PHP\_FE(hello\_null, NULL)

\{NULL, NULL, NULL\}

\};

zend\_module\_entryhello\_module\_entry = \{

\#if ZEND\_MODULE\_API\_NO>= 20010901

STANDARD\_MODULE\_HEADER,

\#endif

PHP\_HELLO\_WORLD\_EXTNAME,

hello\_functions,

PHP\_MINIT(hello),

PHP\_MSHUTDOWN(hello),

PHP\_RINIT(hello),

NULL,

\#if ZEND\_MODULE\_API\_NO>= 20010901

PHP\_HELLO\_WORLD\_VERSION,

\#endif

STANDARD\_MODULE\_PROPERTIES

\};

\#ifdef COMPILE\_DL\_HELLO

ZEND\_GET\_MODULE(hello)

\#endif

PHP\_INI\_BEGIN()

PHP\_INI\_ENTRY("hello.greeting","Hello World", PHP\_INI\_ALL, NULL)

STD\_PHP\_INI\_ENTRY("hello.direction","1", PHP\_INI\_ALL, OnUpdateBool, direction, zend\_hello\_globals,hello\_globals)

PHP\_INI\_END()

static voidphp\_hello\_init\_globals(zend\_hello\_globals \*hello\_globals)

hello\_globals->direction= 1;

PHP\_RINIT\_FUNCTION(hello)

HELLO\_G(counter) = 0;

return SUCCESS;

PHP\_MINIT\_FUNCTION(hello)

ZEND\_INIT\_MODULE\_GLOBALS(hello,php\_hello\_init\_globals, NULL);

return SUCCESS;

PHP\_MSHUTDOWN\_FUNCTION(hello)

UNREGISTER\_INI\_ENTRIES();

return SUCCESS;

PHP\_FUNCTION(hello\_world)

RETURN\_STRING("HelloWorld", 1);

PHP\_FUNCTION(hello\_long)

if (HELLO\_G(direction)) \{

HELLO\_G(counter)++;

\} else \{

HELLO\_G(counter)--;

RETURN\_LONG(HELLO\_G(counter));

PHP\_FUNCTION(hello\_double)

RETURN\_DOUBLE(3.1415926535);

PHP\_FUNCTION(hello\_bool)

RETURN\_BOOL(1);

PHP\_FUNCTION(hello\_null)

RETURN\_NULL();

##             下一步是什么？ ##

本教程探究了一个简单PHP扩展的结构，包括导出函数、返回值、声明初始设置（INI）以及在（客户端）请求期间跟踪其内部状态。

下一部分，我们将探究PHP变量的内部结构，以及在脚本环境中如何存储、跟踪和维护它们。在函数被调用时，我们将使用zend\_parse\_parameters接收来自于程序的参数，以及探究如何返回更加复杂的结果，包括数组、对象和本教程提到的资源等类型。

[e835a466aebe5682d31840c8293dfe41-0.png]: /images/20220109/f5bd00f9ab6a4776a2cfc3175d8a3737.png
[f5d36566378a6b92b88b3aa2c6194f65-2.png]: /images/20220109/64b427ae39a44da385e806279d541599.png
[7c9023e1323d734267a06d193a1a1676-5.png]: /images/20220109/74a35fa89ee2420394807dd3b83d36b6.png
[39c161b10256a517c153aa320712f3f0-7.png]: /images/20220109/92e7934272d2440ca48bf92e612833fc.png
[php_ _ I_PHP_Zend]: https://www.cnblogs.com/ghjbk/p/6953576.html
[PHP]: http://lib.csdn.net/base/php
[0_133230415132n5.gif]: /images/20220109/a1797ac0bea442eda2e13702eb49af2a.png
[php_php]: http://blog.csdn.net/hguisu/article/details/7377520
[.NET]: http://lib.csdn.net/base/dotnet
[http_www.php.net_manual_zh_internals2.buildsys.configunix.php]: http://www.php.net/manual/zh/internals2.buildsys.configunix.php
[Link 1]: http://lib.csdn.net/base/softwaretest