当前位置:  互联网>综合

[1]C/C++中用Lua函数

1.简介
　　偶们这次主要说说怎么由Lua定义函数, 然后在C或者C++中调用. 这里偶们
　　暂不涉及C++的对象问题, 只讨论调用函数的参数, 返回值和全局变量的使用.
　　
　　2.程序
　　这里偶们在e12.lua里先定义一个简单的add(), x,y为加法的两个参数,
　　return 直接返回相加后的结果.
　　
　　例e12.lua
　　-- add two numbers
　　function add ( x, y )
　　return x + y
　　end
　　
　　在前一次里, 偶们说到 lua_dofile() 可以直接在C中执行lua文件. 因为偶们
　　这个程序里只定义了一个add()函数, 所以程序执行后并不直接结果, 效果相当
　　于在C中定义了一个函数一样.
　　
　　Lua的函数可以有多个参数, 也可以有多个返回值, 这都是由栈(stack)实现的.
　　需要调用一个函数时, 就把这个函数压入栈, 然后顺序压入所有参数, 然后用
　　lua_call()调用这个函数. 函数返回后, 返回值也是存放在栈中. 这个过程和
　　汇编执行函数调用的过程是一样的.
　　
　　例e13.cpp 是一个调用上面的Lua函数的例子
　　#include
　　
　　extern "C" { // 这是个C++程序, 所以要extern "C",
　　　　 // 因为lua的头文件都是C格式的
　　#include "lua.h"
　　#include "lualib.h"
　　#include "lauxlib.h"
　　}
　　
　　/* the Lua interpreter */
　　lua_State* L;
　　
　　int luaadd ( int x, int y )
　　{
　　int sum;
　　
　　/* the function name */
　　lua_getglobal(L, "add");
　　
　　/* the first argument */
　　lua_pushnumber(L, x);
　　
　　/* the second argument */
　　lua_pushnumber(L, y);
　　
　　/* call the function with 2
　　　 arguments, return 1 result */
　　lua_call(L, 2, 1);
　　
　　/* get the result */
　　sum = (int)lua_tonumber(L, -1);
　　lua_pop(L, 1);
　　
　　return sum;
　　}
　　
　　int main ( int argc, char *argv[] )
　　{
　　int sum;
　　
　　/* initialize Lua */
　　L = lua_open();
　　
　　/* load Lua base libraries */
　　lua_baselibopen(L);
　　
　　/* load the script */
　　lua_dofile(L, "e12.lua");
　　
　　/* call the add function */
　　sum = luaadd( 10, 15 );
　　
　　/* print the result */
　　printf( "The sum is %d/n", sum );
　　
　　/* cleanup Lua */
　　lua_close(L);
　　
　　return 0;
　　}
　　
　　程序说明:
　　main中过程偶们上次已经说过了, 所以这次只说说luaadd的过程
　　* 首先用lua_getglobal()把add函数压栈
　　* 然后用lua_pushnumber()依次把x,y压栈
　　* 然后调用lua_call(), 并且告诉程序偶们有两个参数一个返回值
　　* 接着偶们从栈顶取回返回值, 用lua_tonumber()
　　* 最后偶们用lua_pop()把返回值清掉
　　
　　运行结果:
　　The sum is 25
　　
　　编译方法
　　Linux下把程序存成e13.cpp
　　g++ e13.cpp -llua -llualib -o e13
　　./e13
　　
　　VC下编译方法
　　* 首先建立一个空的Win32 Console Application Project
　　* 把e13.cpp加入工程中
　　* 点project setting,然后设置link选项, 再加上lua.lib lualib.lib两个额外的库
　　* 最后编译
　　
　　建立好的project可以在这里下载
　　VC http://tonyandpaige.com/tutorials/luaadd.zip
　　Linux http://tonyandpaige.com/tutorials/luaadd.tar.gz
　　
　　3.全局变量
　　上面偶们用到了lua_getglobal()但并没有详细讲, 这里偶们再举两个小例子来说下全局变量
　　lua_getglobal()的作用就是把lua中全局变量的值压入栈
　　lua_getglobal(L, "z");
　　z = (int)lua_tonumber(L, 1);
　　lua_pop(L, 1);
　　假设Lua程序中定义了一个全局变量z, 这段小程序就是把z的值取出放入C的变量z中.
　　
　　另外Lua中还有一个对应的函数lua_setglobal(), 作用是用栈顶的值填充指定的全局变量
　　lua_pushnumber(L, 10);
　　lua_setglobal(L, "z");
　　例如这段小程序就是把lua中的全局变量z设为10, 如果lua中未定义z的话, 就会自动创建一个
　　全局变量z并设为10.
　　

[2]Nginx配置文件处理过程

本文总结这段时间阅读Nginx处理配置文件的代码。其中很多参考网上的资料，主要时淘宝的那一份。现在，算是有个大体的了解了。先记录下来，以后有加深的认识，再继续补上。加油！

1. 配置文件处理的主要步骤和过程 nginx.c文件main函数

    ngx_max_module = 0;
    for (i = 0; ngx_modules[i]; i++) {
        ngx_modules[i]->index = ngx_max_module++;
    }

初始化所有模块的索引顺序ngx_modules[i]->index，和ngx_max_module。

调用ngx_init_cycle(&init_cycle)。

ngx_init_cycle

1.创建conf_ctx存放所有配置结构体

    cycle->conf_ctx = ngx_pcalloc(pool, ngx_max_module * sizeof(void *));

2.NGX_CORE_MODULE模块配置结构体初始化，并存放于cycle->conf_ctx数组中。

    for (i = 0; ngx_modules[i]; i++) {
        if (ngx_modules[i]->type != NGX_CORE_MODULE) {
            continue;
        }

        module = ngx_modules[i]->ctx;

        if (module->create_conf) {
            rv = module->create_conf(cycle);  
            if (rv == NULL) {
                ngx_destroy_pool(pool);
                return NULL;
            }
            cycle->conf_ctx[ngx_modules[i]->index] = rv;
        }
    }

3.调用ngx_conf_param()和ngx_conf_parse()解析配置文件。具体看下一个章节。

conf.ctx = cycle->conf_ctx;
if (ngx_conf_param(&conf) != NGX_CONF_OK) {
        environ = senv;
        ngx_destroy_cycle_pools(&conf);
        return NULL;
    }
    if (ngx_conf_parse(&conf, &cycle->conf_file) != NGX_CONF_OK) {
        environ = senv;
        ngx_destroy_cycle_pools(&conf);
        return NULL;
    }

4.调用NGX_CORE_MODULE模块的init_conf函数。

   for (i = 0; ngx_modules[i]; i++) {
        if (ngx_modules[i]->type != NGX_CORE_MODULE) {
            continue;
        }

        module = ngx_modules[i]->ctx;

        if (module->init_conf) {
            if (module->init_conf(cycle, cycle->conf_ctx[ngx_modules[i]->index])
                == NGX_CONF_ERROR)
            {
                environ = senv;
                ngx_destroy_cycle_pools(&conf);
                return NULL;
            }
        }
    }

ngx_conf_parse()函数

截取主要代码部分。读取一个配置指令，交给ngx_conf_handler进行处理，如果返回NGX_ERROR则出错结束。

for ( ;; ) {
        rc = ngx_conf_read_token(cf);
        rc = ngx_conf_handler(cf, rc);

        if (rc == NGX_ERROR) {
            goto failed;
        }
    }

ngx_conf_handler函数

1. 遍历所有模块的cmd数组，比较token是否和cmd的指令名称相同。当找到一个相同的之后，进入下一步。

先看以下ngx_command_s结构体的定义。

struct ngx_command_s {
    ngx_str_t             name;   /* 指令的名称 */
    ngx_uint_t            type;   
    char               *(*set)(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
    ngx_uint_t            conf;
    ngx_uint_t            offset;
    void                 *post;
};

type：指令的属性集合，由多个常量值取与，主要设置指令参数 个数，指令值类型，指令出现的位置。

指令参数个数：NGX_CONF_NOARGS(不接收参数)，NGX_CONF_TAKE1(一个参数），NGX_CONF_TAKE12（一个或两个参数)。

指令值类型：NGX_CONF_BLOCK(配置信息块)，NGX_CONF_FLAG(接收“on"或"off")

指令出现位置：NGX_DIRECT_CONF(配置文件中最外层，如daemon，master_process等)，NGX_MAIN_CONF(http, mail, events, error_log等)，NGX_HTTP_MAIN_CONF(http配置指令里)，NGX_HTTP_SRV_CONF(http配置指令里的server配置指令里)，NGX_HTTP_LOC_CONF(http配置指令里的server配置指令里的location配置指令里)，还有其他的。

set：是在解析配置文件时，遇到这个指令时被调用的函数。

conf：指定配置信息存储的内存位置。NGX_HTTP_MAIN_CONF_OFFSET, NGX_HTTP_SRV_CONF_OFFSET, NGX_HTTP_LOC_CONF_OFFSET。（这个值在获取指令对应的conf时会被用到）。

offset：定义指令将配置的结构体的哪个成员。（后面说明如何被调用）

2. 检查当前指令是否出现在合法的位置。配置文件是嵌套解析的，当进入http的部分时，cf->cmd_type会被设置为NGX_HTTP_MAIN_CONF。所以只有那些cmd->type包含这个值的才会被处理，否则会被跳过。

            if (!(cmd->type & cf->cmd_type)) {
                continue;
            }

3.检查指令参数个数是否合理。

4.获取指令对应的conf（配置结构体，用于存放指令的设置值）。

            if (cmd->type & NGX_DIRECT_CONF) {
                conf = ((void **) cf->ctx)[ngx_modules[i]->index];
            } else if (cmd->type & NGX_MAIN_CONF) {
                conf = &(((void **) cf->ctx)[ngx_modules[i]->index]);
            } else if (cf->ctx) {
                confp = *(void **) ((char *) cf->ctx + cmd->conf);
                if (confp) {
                    conf = confp[ngx_modules[i]->ctx_index];
                }
            }

对于HTTP模块，会执行第三种情况。这时cf->ctx对应的是http的配置结构体ngx_http_conf_ctx_t，包含三个数组main_conf, srv_conf, loc_conf。使用cmd->conf等到对应的数组。再通过ngx_modules[i]->ctx_index获得模块对应的conf结构体（在http指令被解析到的时候，已经通过调用模块的create_main_conf, create_srv_conf, create_loc_conf创建，并存储在对应的数组中）。

5.调用指令定义时留下的set函数。

rv = cmd->set(cf, cmd, conf);

ngx_http.c文件

    for (m = 0; ngx_modules[m]; m++) {
        if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }

        ngx_modules[m]->ctx_index = ngx_http_max_module++;
    }

2.创建三个数组main_conf, srv_conf, loc_conf用于存放所有HTTP模块将产生的配置结构体指针。调用每个模块的create_main_conf, create_srv_conf, create_loc_conf，并将返回的配置结构体指针放在对应的数组当中。

    ctx->main_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);

    ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);

    ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);

    for (m = 0; ngx_modules[m]; m++) {
        if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }

        module = ngx_modules[m]->ctx;
        mi = ngx_modules[m]->ctx_index;

        if (module->create_main_conf) {
            ctx->main_conf[mi] = module->create_main_conf(cf);
            if (ctx->main_conf[mi] == NULL) {
                return NGX_CONF_ERROR;
            }
        }

        if (module->create_srv_conf) {
            ctx->srv_conf[mi] = module->create_srv_conf(cf);
            if (ctx->srv_conf[mi] == NULL) {
                return NGX_CONF_ERROR;
            }
        }

        if (module->create_loc_conf) {
            ctx->loc_conf[mi] = module->create_loc_conf(cf);
            if (ctx->loc_conf[mi] == NULL) {
                return NGX_CONF_ERROR;
            }
        }
    }

3. 调用每个模块的preconfiguration函数进行预处理。

    for (m = 0; ngx_modules[m]; m++) {
        if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }

        module = ngx_modules[m]->ctx;

        if (module->preconfiguration) {
            if (module->preconfiguration(cf) != NGX_OK) {
                return NGX_CONF_ERROR;
            }
        }
    }

4. 进入http配置指令的内部指令解析过程，包括server配置指令结构，location配置指令结构等。

    pcf = *cf;   /* pcf保存原配置信息 */
    cf->ctx = ctx;

    cf->module_type = NGX_HTTP_MODULE;   
    cf->cmd_type = NGX_HTTP_MAIN_CONF;   /* 改变配置文件解析位置信息 */
    rv = ngx_conf_parse(cf, NULL);

    *cf = pcf; /* 最后在返回前，恢复 */

5. init http{} main_conf's, merge the server{}s' srv_conf's and its location{}s' loc_conf's 和create location trees。这部分还没看懂。

6.init_phases

7.调用HTTP模块的postconfiguration函数，做后期处理。例如，默认值处理可以放在这里执行。

[3]WordPress使用记录