下面我们来定义 lisp.h 头文件

 1#ifndef LISP_H_OTE1HWPK
 2#define LISP_H_OTE1HWPK
 3
 4#include <stdio.h>
 5#include <stdlib.h>
 6
 7#define define(ret, name, args, block) \
 8    ret name args { return block; }
 9
10#define if(expr, block1, block2) \
11    expr ? block1 : block2
12
13#define eq(a, b) \
14    a == b
15
16#define neq(a, b) \
17    a != b
18
19#define sub(a, b) \
20    a - b
21
22#define mul(a, b) \
23    a * b
24
25#define add(a, b) \
26    a + b
27
28#define div(a, b) \
29    a / b
30
31#endif /* end of include guard: LISP_H_OTE1HWPK */

然后来用类似于 lisp 的语法编写一段求阶乘的代码：

1define(int, factorial, (int n),
2       if(eq(n, 0),
3          1,
4          mul(n, factorial(sub(n, 1)))))
5
6define(int, main, (void),
7       (printf("10! = %d\n", factorial(10)), EXIT_SUCCESS))

编写 Makefile:

1CFLAGS = -Wall -include "lisp.h"
2
3TARGET=factorial
4
5all:
6	gcc -o $(TARGET) $(TARGET).c $(CFLAGS)
7
8clean:
9	rm -f $(TARGET)

编译并运行：

1liubang@venux-dev:~$ make
2gcc -o factorial factorial.c -Wall -include "lisp.h"
3liubang@venux-dev:~$ ./factorial
410! = 3628800

 1// random.c
 2#include <stdio.h>
 3#include <stdlib.h>
 4#include <time.h>
 5
 6int main() {
 7    srand(time(NULL));
 8    int i = 10;
 9    while (i--) printf("%d\n", rand() % 100);
10    return 0;
11}

编译运行：

 1liubang@venux-dev:~$ gcc random.c -o random
 2liubang@venux-dev:~$ ./random
 344
 446
 597
 651
 762
 876
 992
1076
1138
1210

这个程序每次运行的结果都是不一样的，现在我们希望我们能够在不修改源码的情况下，控制程序的输出结果，例如我希望这段程序运行的结果是 每次都能输出 10 个 10。由于不能修改源码，或者我们根本没有源码，面对这样一个编译后的可执行二进制文件，想要修改程序的运行结果，可能显 得有些困难。然而，如果能够善用动态连接器的话，这都不是问题。

这篇文章主要是为了帮助大家熟悉 POSIX 线程库以及在实际开发中使用它的特性。我们会具体讲解如何利用这个线程库定义的不同工具 来解决编程中的问题。当然这里隐含了一个假设，就是读者已经了解过并行编程（或者多进程）的相关概念，如果没有这些背景知识 的话，读者可能会感觉到很难理解。不过也没关系，我的另一篇教程里边有专门为只具备线性编程思维的读者提供了对并行编程理论 和相关术语的讲解。

同样的，我假设聪明的你已经熟悉了异步编程模型，那些经常使用桌面环境的人会更容易去接受多线程编程的理念。

当我们谈到 POSIX 线程的时候，肯定会有人心生疑惑：“我们应该使用哪个标准下的 POSIX 线程？”。由于 POSIX 线程标准已经修订了好 多年，人们会发现，依据不同标准的实现有不同的函数集，不同的默认值和不同的细微差别。所以在此说明的是，本教程使用的是 v0.5 版的 Linux 内核中的线程库，使用其他操作系统和使用其他版本的读者，需要阅读一下你们对应的系统文档来同本文中的实例进行对应。同时，有些示例代码中使用到了阻塞式的系统调用，它们不能再用户级的线程库中很好的工作（参考另一篇文章：parallel programming theory tutorial 来获取详细信息）。好了，说了那么多，主要是为了能保证文章中的示例代码能够在其他系统中正常使用，从而提高跨平台性。

什么是线程？为什么要使用线程？

线程是一个迷你版的进程，它们拥有自己的栈，能够执行给定的一段代码。但是不同于进程的是，线程通常与其他线程共享记忆体（而 每个进程都拥有一个独立的记忆体区域）。一个线程组就是一个执行相同代码的线程的集合，他们共用记忆体，可以访问相同的全局变 量，拥有同样的文件描述符等等，他们以并行的方式执行（可能是时间片的方式，或者对于多核心系统，他们会真正平行执行）。

使用线程组而不是普通顺序执行程序的好处是多个操作可以同时进行，当一些事件产生的时候，他们能立马被处理（例如：如果我们有 一个线程处理用户接口，另一个线程处理数据库查询，那么我们可以在处理很多用户查询的同时，依然能够响应用户的输入）。

使用线程组而不是进程组的好处是线程间的上下文切换要比进程间的上下文切换要快很多（上下文切换是指系统从一个正在运行的线程或进程切换到去执行另一个线程或进程）。此外，线程间的通信也远远比进程间通信要高效很多。

线程编程有利也有弊，由于线程组共享记忆体，如果一个线程破坏了记忆体，那么其他线程也要受到牵连。但是进程就不同了，操作系 统会将进程之间隔离开，如果一个进程破坏了它的记忆体，那么其他进程不会受到影响。使用进程的另一个好处是，不同的进程可以运 行在不同的机器上，但是线程必须运行在同一台机器上（至少通常情况下是这样的）。

创建和销毁线程

当一个多线程程序启动执行到main()函数的时候，就会有一个线程运行，这是一个全程线程（full-fledged thread，或者叫主线程），如果想创建一个新的线程，程序中需要使用pthread_create()函数

 1#include <stdio.h>
 2#include <pthread.h>
 3
 4void *do_loop(void *data)
 5{
 6    int i; // counter, to print numbers
 7    int j; // counter, for delay
 8    int me = *((int *)data);
 9    for (i = 0; i < 10; i++) {
10        for (j = 0; j < 50000; j++) // delay loop
11            ;
12        printf("'%d' - Got '%d'\n", me, i);
13    }
14
15    // terminate the thread
16    pthread_exit(NULL);
17}
18
19int main(int argc, char *argv[])
20{
21    int       thr_id;    // thread ID for the newly created thread
22    pthread_t p_thread;  // thread's structure
23    int a = 1;           // thread 1 identifying number
24    int b = 2;           // thread 2 identifying number
25
26    // create a new thread that will execute 'do_loop()'
27    thr_id = pthread_create(&p_thread, NULL, do_loop, (void *)&a);
28
29    // run 'do_loop' in the main thread as well
30    do_loop((void *)&b);
31
32    return 0;
33}

上述这段代码需要特殊说明的是：

写这篇文章的目的是基于 php7，阐述 Zend Virtual Machine 的内部实现。这不是一篇综合描述，我将尽可能地覆盖到所有重要的部分和细节。

本文的描述对象是 php7.2 版本，但是几乎所有的特性都已经应用在了 php7.0/7.1 中了。然而，它们同 php5.x 系列 VM 的不同之处同样也很重要，我会很有耐心的同步描述。

这篇文章主要是从指令的角度来阐述，只有在末尾花了少量篇幅描述了 C 语言实现 VM 的细节。但是在文章开始之前，我想先提供一些实现 VM 的主要代码文件：

• zend_vm_def.h: VM 定义文件
• zend_vm_execute.h: 生成的 VM
• zend_vm_gen.php: VM 生成脚本
• zend_execute.c: 大多数直接支持的代码

Opcodes

首先我们来聊聊 opcode。“Opcode"是用来表示整个 VM 指令集（包括操作数）的，但是也可能仅仅就是指“真实的”操作码，这些操作码是一个很小的整数用来区分不同的指令类型。其具体的含义需要结合代码的上下文才能清楚。在程式码中，指令通常被称作"oplines”。

下面是zend_op的结构

 1struct _zend_op {
 2    const void *handler;
 3    znode_op op1;
 4    znode_op op2;
 5    znode_op result;
 6    uint32_t extended_value;
 7    uint32_t lineno;
 8    zend_uchar opcode;
 9    zend_uchar op1_type;
10    zend_uchar op2_type;
11    zend_uchar result_type;
12};

由此看来，opcodes 本质上就是一个“三地址码”格式的指令。有一个opcode代表指令的类型，有两个输入操作数op1和op2和一个输出操作数result。

前言

PHP 和线程，单凭这简短的几个字，就足以写一本书。像往常一样，我们不会这么做，但是会给出一定程度上跟这个话题相关的信息与细节。让我们从一些人在谈论这个话题时通常感到的困惑开始，PHP 不是一种线程语言， PHP 的内核没有使用线程，而且 PHP 天生也不允许用户层代码通过任何方式使用多线程作为并发机制。

因此 PHP 跟其他一些技术有很大的区别，例如 Java。Java 不仅自身使用了大量的线程，它还允许用户通过编程来是用线程。然而，PHP 不适用线程是有它的原因的。

PHP 内核没有使用线程，主要是为了简化开发。当你读到下一节的时候，你就会了解到线程并不是一个能使任何程序都能更快运行的魔法技术。是不是听起来很像是在推销不是吗？但是我们不是推销，而是谈论技术，而且 我们很清楚我们在说什么。因此 PHP 引擎目前没有使用多线程，也许将来会使用。但是使用多线程在编程上会引发很多问题，例如程序运行结果不是你所期待的等等。主要的困难是跨平坦的多线程编程，其次就是资源共享和 锁的管理，再次就是并不是所有的程序都能够被转化成多线程程序。PHP 的设计主要在 2000 前后，在那个时候，多线程编程并不是很广泛和成熟，PHP 引擎开发工程师决定创造一个完全没有线程的单片机引擎（当然他们也没有 足够的能力去驾驭一个稳定的跨平台的多线程引擎）。

PHP 用户层代码也不允许使用线程，因为那不是 PHP 期待你的代码运行的方式。PHP 是一个"发送并忘记(fire-and-forget)“型的语言，你应该尽可能快的处理完请求，然后释放，然后接着处理下一个请求。PHP 被设计作为一种 胶水语言：你不用处理可能使用到线程的复杂任务，而是访问快速而且已经准备好的资源，将它们粘合到一起，然后再返回给用户。通过 PHP，无论什么可能花费比通常时间多的时间的任务，都不能用 PHP 来处理。这就是为什么 在 PHP 中我们通常使用基于消息队列的系统(Gearman, AMQP, ActiveMQ 等等)来异步处理一些耗时任务。正如 Unix 看待事物的方式：“开发小而完备的工具，然后将他们连接在一起”。因此 PHP 的设计不是允许大规模的并行，而是 其他专门的技术–是用正确的工具来解决特定的问题。

线程的简介

让我们来快速的介绍下线程。注意，我们不会阐述太多细节的东西，对于你想深入了解关于线程的任何细节，都可以在相关书籍和站点上找到。

线程是进程中的轻量的事务处理单元，注意，一个进程可以产生多个线程，一个线程必须有且只能属于一个进程。进程是操作系统中的基本工作处理单元。在多 CPU 的机器上，不同的 CPU 将会平行工作，这样对于计算能力的提升会 有很大的好处。如果进程 A 和 B 都准备被执行，而且两个 CPU（或者两个 CPU 核心）也都有空闲的负载，那么进程 A 和 B 将会同时被执行。因此，计算机将能高效的在一个单位时间内同时进行多个运算，我们称之为“并行”(parallelism)。

从“中的一个例子说起

1(*(void(*)())0)()

下面我们来一步步分析：

我们知道变量的声明方式为：

1int a;

函数的声明方式为：

1int fn();

指针的声明方式为：

1int *a = 10;

函数指针的声明方式为：

1int (*fn)(); //fn 是一个指向返回int型的函数的指针

函数指针的调用方式：

 1typedef int (*fn_type)();
 2
 3int fn() {
 4    return 0;
 5}
 6
 7fn_type a = fn;
 8
 9printf("%d\n", a());
10//或者
11printf("%d\n", (*)a());

最简单的类型转换：

在之前的文章中，我们已经实现了一些 object handlers 来将我们的 ArrayBuffer 整合到 php 中。但是美中不足的是，我们的 ArrayBufferView 并不支持迭代器操作。也就是它不能像 php 中的数组那样使用foreach来遍历。 那么，我们接下来就来看看迭代器在内核中是如何实现的，并且给我们的 ArrayBufferView 也增加一个迭代器。

get_iterator handler

内核中的迭代器跟用户端的IteratorAggregate接口功能是一样的。一个具有迭代功能的类都有一个get_iterator处理器，它会返回一个zend_object_iterator *类型的结构，该结构定义如下（位于 phpsrc/Zend/zend_iterators.h 中）：

1struct _zend_object_iterator {
2    void *data;
3    zend_object_iterator_funcs *funcs;
4    ulong index; /* private to fe_reset/fe_fetch opcodes */
5};

其中的index成员就是内核中用以实现foreach的，它的值会在每次迭代后增加。funcs成员包含了不同的迭代操作：

 1typedef struct _zend_object_iterator_funcs {
 2    /* release all resources associated with this iterator instance */
 3    void (*dtor)(zend_object_iterator *iter TSRMLS_DC);
 4
 5    /* check for end of iteration (FAILURE or SUCCESS if data is valid) */
 6    int (*valid)(zend_object_iterator *iter TSRMLS_DC);
 7
 8    /* fetch the item data for the current element */
 9    void (*get_current_data)(zend_object_iterator *iter, zval ***data TSRMLS_DC);
10
11    /* fetch the key for the current element (optional, may be NULL). The key
12     * should be written into the provided zval* using the ZVAL_* macros. If
13     * this handler is not provided auto-incrementing integer keys will be
14     * used. */
15    void (*get_current_key)(zend_object_iterator *iter, zval *key TSRMLS_DC);
16
17    /* step forwards to next element */
18    void (*move_forward)(zend_object_iterator *iter TSRMLS_DC);
19
20    /* rewind to start of data (optional, may be NULL) */
21    void (*rewind)(zend_object_iterator *iter TSRMLS_DC);
22
23    /* invalidate current value/key (optional, may be NULL) */
24    void (*invalidate_current)(zend_object_iterator *iter TSRMLS_DC);
25} zend_object_iterator_funcs;

这些处理器跟Iterator接口中的抽象方法类似，只不过名字不同罢了。唯一没有对应用户端接口的是invalidate_current，它可以被用来销毁当前的key/value。 然而这个操作几乎不会被用到，通常foreach也不会取调用它。

在前面的博文中，已经介绍过一些 object handlers 了，也特别介绍了如何通过指定 handlers 来创建一个自定义的结构和使用clone_obj来对自定义的结构进行克隆操作。 然而，这只是开始：在 php 中，几乎所有的对象操作，都可以通过 object handlers 来实现，而且所有的魔术方法和魔术接口在内核中都是实现了对应的 object handler。此外， 一些 handlers 并没有开放给用户端的 php，例如，内部类可以自定义类的比较操作，而使用 php 代码是无法实现的。

由于 php 中有很多不同的 object handlers，这里只挑几个来讨论，其它的只给出简单的说明。

概述

下面列举出 php 中主要的 26 个(php5.6 中为 28 个)object handlers（位于 phpsrc/Zend/zend_object_handlers.h），并给出简要的说明。

1zval *read_property(zval *object, zval *member, int type, const struct _zend_literal *key TSRMLS_DC)
2void write_property(zval *object, zval *member, zval *value, const struct _zend_literal *key TSRMLS_DC)
3int has_property(zval *object, zval *member, int has_set_exists, const struct _zend_literal *key TSRMLS_DC)
4void unset_property(zval *object, zval *member, const struct _zend_literal *key TSRMLS_DC)
5zval **get_property_ptr_ptr(zval *object, zval *member, const struct _zend_literal *key TSRMLS_DC)

上述 handlers 分别表示__get，__set，__isset，__unset方法。get_property_ptr_ptr等同于__get返回一个引用类型。zend_literal *key作为这些函数的参数 起到优化作用，例如它包含了一些将属性名进行 hash 计算的结果。

1zval *read_dimension(zval *object, zval *offset, int type TSRMLS_DC)
2void write_dimension(zval *object, zval *offset, zval *value TSRMLS_DC)
3int has_dimension(zval *object, zval *member, int check_empty TSRMLS_DC)
4void unset_dimension(zval *object, zval *offset TSRMLS_DC)

上述了几个 handlers 就是内核用以实现ArrayAccess接口的。

ArrayBuffer 又叫二进制数组，是一个用来表示通用的，固定长度的二进制数据缓冲区。你不能直接操纵 ArrayBuffer 的内容， 而是创建一个表示特定格式的 buffer 的类型化数组对象（也叫做数据视图对象）来对 buffer 的内容进行读写操作。

我最早了解 ArrayBuffer 是从 JavaScript 开始的，具体的用法和 api 可以参考JavaScript 标准库－－ArrayBuffer

那么接下来，我们就给 PHP 扩展一个简单的 ArrayBuffer，顺便巩固一下php 扩展开发之自定义对象的存储。

定义 ArrayBuffer 的数据结构和相关 handlers

ArrayBuffer是一个非常简单的对象，它只需要申明并存储一个buffer和它的长度即可：

1typedef struct _buffer_object {
2    zend_object std;
3    void *buffer;
4    size_t length;
5} buffer_object;

接下来我们来实现它的create和free handlers，有了前面的基础，这个实现也是及其简单的：

 1static void linger_array_buffer_free_object_storage(buffer_object *intern TSRMLS_DC)
 2{
 3	zend_object_std_dtor(&intern->std TSRMLS_CC);
 4	linger_efree(intern->buffer);
 5}
 6
 7zend_object_value linger_array_buffer_create_object(zend_class_entry *class_type TSRMLS_DC)
 8{
 9	zend_object_value retval;
10	buffer_object *intern = emalloc(sizeof(buffer_object));
11	memset(intern, 0, sizeof(buffer_object));
12
13	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
14	object_properties_init(&intern->std, class_type);
15
16	retval.handle = zend_objects_store_put(
17			intern,
18			(zend_objects_store_dtor_t) zend_objects_destroy_object,
19			(zend_objects_free_object_storage_t) linger_array_buffer_free_object_storage,
20			NULL
21			TSRMLS_CC
22			);
23
24	retval.handlers = &linger_array_buffer_handlers;
25	return retval;
26}

从上面的代码中可以看到，我们并没有在create_object中申请buffer的空间，而这步操作将会在__construct中来实现，因为buffer的长度会作为构造函数的参数传递过来。

对于 php 扩展开发，很多人可能已经不那么陌生了，zend 引擎为了们提供了非常丰富了函数和 macro，来帮助我们很快速的创建一个标准的 php 类，然而，当我们在使用自定义的数据结构(struct)， 并想把我们自己定义的数据结构封装成 php 的类的时候可能就会有些困惑，因为我们都知道 php 中的所有变量都是通过 zval 来存储的，而我们自定义的数据结构要怎样才能和 zval 实现完美的对接呢？ 以前我通常采用的一种方式就是使用 zend 引擎提供的资源类型，因为资源类型的封装中包含了通用的数据类型，而且有很丰富的函数来操作资源，所以使用起来很简单也很方便。然而，强大的 zend 引擎真的没有其他方式扩展数据结构了吗？当然不是！下面就来介绍一个更加优雅的方式。要弄明白，首要要搞清 php 内核是如何创建对象的。

如何创建一个对象

我们首先来探讨下如何创建一个 PHP 对象。为此我们将会用到object_and_properties_init之类的一些宏。

 1// 创建一个SomeClass类型的对象，并且把properties_hashtable中的变量作为其属性值
 2zval *obj;
 3MAKE_STD_ZVAL(obj);
 4object_and_properties_init(obj, class_entry_of_SomeClass, properties_hashtable);
 5
 6// 创建一个没有属性的对象
 7zval *obj;
 8MAKE_STD_ZVAL(obj);
 9object_init_ex(obj, class_entry_of_SomeClass);
10// = object_and_properties_init(obj, class_entry_of_SomeClass, NULL)
11
12// 创建一个stdClass的对象
13zval *obj;
14MAKE_STD_ZVAL(obj);
15object_init(obj);
16// = object_init_ex(obj, NULL) = object_and_properties_init(obj, NULL, NULL);

在上面的例子中，最后一种情况下，当你创建一个stdClass的对象后，通常将会给它添加属性。这时如果使用 zend_update_property之类的函数，是不起作用的，取而代之的是add_property宏函数：

在 c 语言中，结构体(struct)是一种复合数据类型，用来将一系列相同或不同类型的变量聚集在同一个内存区间内并赋予同一个名字，使得通过一个指针就能访问集合中的所有成员。结构体中可以包含许多简单或符合数据类型，因此从内存分配上看，有点类似数组，而从变量组织上看，又类似于面向对象编程语言中的类。

定义 struct

定义一个 struct 非常简单，使用struct关键字即可。

1struct student {
2    char *name;
3    int age;
4};

struct 的初始化

通常有四种常用的 struct 初始化方式。

１．定义并初始化

1struct {
2    char *ext;
3    char *filetype;
4} extensions[] = {
5    {"gif", "image/gif"},
6    {"jpg", "image/jpg"}
7};

２．按照成员声明的顺序初始化

1 简介

malloc是干什么的？如果你连这个名字都没听过，那么你应该先去了解 Unix 环境下的 c 语言开发，然后再来阅读。对一个程序员而言，malloc是一个在 c 语言中用来分配内存的函数，但是大多数人并不知道它背后真正的原理，甚至有些人认为malloc是 c 语言的关键字或者认为它是系统调用。事实上，malloc是一个再简单不过的函数而已，而且只需要很少的操作系统相关知识就可以让我们彻底理解它的原理。

下面来一步步的实现一个简单的malloc函数，从而帮助我们理解其背后运作的原理。因为仅仅作为说明原理之用，所以这里实现的malloc不会太高效，但是足以说明原理。

什么是 malloc

malloc(3)是一个用来分配内存块的标准的 c 语言库函数。它遵循以下规则：

• malloc至少分配所需字节数的内存；
• malloc返回其所分配内存空间(程序可以成功读写的空间)的指针；
• 一块内存一旦被malloc分配，其他malloc调用不能再分配该内存块的任何部分，除非指向该内存块的指针被释放掉；
• malloc应该是可控的：他必须能够很快完成分配并返回；
• malloc同时应该提供重新分配内存块大小和释放内存的功能

malloc函数必须遵循以下原型：

1void *malloc(size_t size);

其中size是所需要的内存大小。如果失败（没有足够的内存空间可以分配），应该返回NULL。

2 堆，brk 和 sbrk 系统调用

在开始实现第一个malloc函数之前，需要了解内存在大多数多任务操作系统中是如何管理的。这里我们只是做出一个抽象的解释，从大体上去帮助理解，至于很多细节，它们都依赖操作系统原理和硬件相关的知识。

2.1 进程的内存

每个进程都有自己的虚拟地址空间被 MMU（Memory Management Unit, 内存管理单元）(和内核)动态的转换到物理内存地址空间。这部分空间被划分成了几个部分，我们需要了解的是至少有一部分空间存放代码，一个用来存放局部变量的栈，一部分用来存放常量和全局变量的空间，以及程序的无组织空间我们称之为堆。

堆是一个连续的（依据虚拟地址而言）内存空间，它有三个边界：一个起始点，一个最大限度边界（通过 sys/ressource.h 中的 getrlimit(2)函数和 setrlimit(2)函数来管理）和一个被称为break的结束点。break标记了隐射内存空间的结束，也就是说，虚拟地址空间部分对应着真实的内存空间。下图表示内存组织结构

要想实现一个malloc函数，我们需要知道堆的起始点和 break 的位置，然后我们来移动 break。要做到这些，就需要用到两个系统调用，brk和sbrk。

2.2 brk(2)和 sbrk(2)

我们可以在这些系统调用的文档中看到相关描述：

当今世道，各种高级语言百花齐放。然而会有人发出这样的疑问–计算机真的能够识别这么多语言吗？稍微有点常识的人都知道，这显然是不可能滴！在计算机的世界里，他们能够直接识别的只有机器语言。然而，由于机器语言对人类不够友好，所以人们才发明了汇编，c，Java…许许多多的人类易读的编程语言，所以我个人对编程语言的理解一直是其实他们就是机器语言的语法糖，而编程语言的创造过程，就是定义一种合理的，没有二义性的语法规则，然后就是通过直接或间接的方式实现该语法到机器语言的转换过程。既然是这样的话，那么我们就很容易想到，计算机语言是一个自我完善的过程：首先我们定了一种非常简单的 x1(这里只是用来举例说明，有没有 x 语言有待考证)语言，然后用机器语言实现了这个非常简单的 x1 语言的编译器，创造了 x1 语言，实现了非常简单的新特性，然后我们再用 x1 语言(相对于机器语言较高级)实现了另一些新的特性的 x2 语言的编译器，创造了 x2 语言，…，如此下去，人们创造了汇编语言，从而创造了 c 语言，接着创造了世界上最好的语言 PHP(不知道是不是真的，反正大家都习惯这么说)。 在各种高级语言越来越强大的今天，我们可能很难再会去接触最原始的东西，高度封装确实提高了生产力，降低了学习成本，但是也使得现代程序员将太多精力花在了各种说明书上，而不清楚其本质。 毕业一年多，工作了一年多，对于计算机编程有了自己的看法，不再像在大学的时候认识的那样肤浅，反而觉得大学中学习的知识才是真正的干货，不禁感叹曾经浪费掉了大好光阴。好在陶渊明有词云：“悟已往之不谏，知来者之可追”。 闲暇之余，扒开 PHP(这里之所以是 PHP 并不因为他是世界上最好的语言，只是因为我目前从事的是 PHP 开发的工作而已)源码，了解了其内部构造和实现原理，百看不一练。今天就初步学习 yacc/lex 了，记录在我的博客中，以便以后翻阅巩固。

过程简述

一般来说编程语言的解释执行过程如下：

ONE. 词法分析 将源代码拆分成若干 Token 的过程

TWO.语法分析 将 Token 构建成 Syntax Tree 的过程

THREE.生成执行码 生成可执行文件

yacc（Yet Another Compiler Compiler）

下面是 wikipedia 中对 yacc 的描述

Yacc is a computer program for the Unix operating system. It is a Look Ahead Left-to-Right (LALR) parser generator, generating a parser, the part of a compiler that tries to make syntactic sense of the source code, specifically a LALR parser, based on an analytic grammar written in a notation similar to Backus–Naur Form (BNF). Yacc itself used to be available as the default parser generator on most Unix systems, though it has since been supplanted as the default by more recent, largely compatible, programs.

]]>https://blog.liubang.cc/posts/php/2017-03-09-php%E6%89%A9%E5%B1%95%E5%BC%80%E5%8F%91%E4%B9%8Bcall-user-func%E5%8E%9F%E7%90%86%E5%92%8C%E5%9B%9E%E8%B0%83%E5%87%BD%E6%95%B0%E7%9A%84%E5%AE%9E%E7%8E%B0/Thu, 09 Mar 2017 00:00:00 +0000https://blog.liubang.cc/posts/php/2017-03-09-php%E6%89%A9%E5%B1%95%E5%BC%80%E5%8F%91%E4%B9%8Bcall-user-func%E5%8E%9F%E7%90%86%E5%92%8C%E5%9B%9E%E8%B0%83%E5%87%BD%E6%95%B0%E7%9A%84%E5%AE%9E%E7%8E%B0/函数调用

很多时候，我们需要通过函数名来调用函数，并传递参数，或者把匿名函数作为函数的参数传递，实现回调。当我们在遇到这样的需求的时候，用 php 代码实现起来肯定是非常容易和简单的。但是，当我们在用 c 语言编写 php 扩展的时候，如何来实现这样的功能呢？下面就一起来深入了解 php 内核，看看如何实现。

在 Zend 引擎中，给我们提供了zend_call_function,call_user_function以及call_user_function_ex函数来帮助我们实现函数调用。在zend_API.h文件中，我们可以看到如下函数原型的声明：

1ZEND_API int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TSRMLS_DC);
2ZEND_API int call_user_function(HashTable *function_table, zval **object_pp, zval *function_name, zval *retval_ptr, zend_uint param_count, zval *params[] TSRMLS_DC);
3ZEND_API int call_user_function_ex(HashTable *function_table, zval **object_pp, zval *function_name, zval **retval_ptr_ptr, zend_uint param_count, zval **params[], int no_separation, HashTable *symbol_table TSRMLS_DC);

从函数的参数上来看，显然zend_call_function需要的参数很少，而其他两个都需要一堆参数，所以，我们可能会想，达到相同的效果为什么参数上有如此大的区别，于是带着这个疑问我们来解刨zend_fcall_info结构体。同样在zend_API.h中会看到如下结构体的定义：

 1typedef struct _zend_fcall_info {
 2        size_t size;
 3        HashTable *function_table; //函数表
 4        zval *function_name;	   //函数，可以是函数名，也可以直接是匿名函数本身
 5        HashTable *symbol_table;   //符号表
 6        zval **retval_ptr_ptr;	   //返回值
 7        zend_uint param_count;     //参数个数
 8        zval ***params; 		   //参数，数组
 9        zval *object_ptr;		   //调用对象方法时候需要传调用的对象
10        zend_bool no_separation;
11} zend_fcall_info;

不难发现，原来是把相关字段封装到了结构体中了，所以显得参数数量少，实际上该有的都有。

]]>