if "value1".equals(jedis.get("key1") { //@1
  jedis.del("key1")                  //@2
}

if redis.call("get",KEYS[1]) == ARGV[1]
then
    return redis.call("del",KEYS[1])
else
    return 0
end

eval "return redis.call('set',KEYS[1],'bar')" 1 foo

function 方法名(参数1，参数2)
  return 结果
end

function f_7c6f28e03fe1da50a15a7396fd66d0927ee4f350() redis.call('get','aaa') end

int lua_load (lua_State *L,
              lua_Reader reader,
              void *data,
              const char *chunkname);
Loads a Lua chunk. If there are no errors, lua_load pushes the compiled chunk as a Lua function on top of the stack. Otherwise, it pushes an error message. The return values of lua_load are:

lua_load automatically detects whether the chunk is text or binary, and loads it accordingly (see program luac).

The lua_load function uses a user-supplied reader function to read the chunk (see lua_Reader). The data argument is an opaque value passed to the reader function.

The chunkname argument gives a name to the chunk, which is used for error messages and in debug information (see §3.8).

void lua_call (lua_State *L, int nargs, int nresults);

lua_load

lua_getglobal(luaState, funcname);

lua_pushnil、lua_pushnumber、lua_pushstring等

lua_call(luaState, 2, 1);//调用函数，该函数接收两个参数，最终一个返回值  

lua_tostring(luaState, -1)//以字符串形式返回栈顶元素，也就是返回值

#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>



int main(void){
  //定义一段lua函数
  char lua_func[] = "function hello(v) return v end";
  //创建luaState
  lua_State* L = luaL_newstate();
  
  //加载lua_func中内容为一个lua函数
  if (luaL_loadbuffer(L, lua_func, strlen(lua_func), "@user_script")){
    printf(lua_tostring(L, -1));
    return -1;
  }
  lua_pcall(L, 0, LUA_MULTRET, 0);

  //hello函数入栈
  lua_getglobal(L, "hello");
  //hello函数所需参数入栈
  lua_pushstring(L, "world");
  //使用lua_pcall调用hello函数，告诉它需要一个参数一个返回值
  if (lua_pcall(L, 1, 1, 0)){
    //如果调用失败输出错误信息，错误信息在栈的顶部，所以用lua_tostring(L,-1)
    printf(lua_tostring(L, -1));
    getchar();
    return -1;
  }

  //没有错误，输出hello函数返回值，返回值在栈的顶部
  printf(lua_tostring(L, -1));
  
  //这个是为了让命令行不要退出
  getchar();
  return 0;
}

eval "return redis.call('set',KEYS[1],'bar')" 1 foo

void scriptingInit(void) {
    //1.初始化luaState
    lua_State *lua = lua_open();

    //2.加载一些lua库
    luaLoadLibraries(lua);
    luaRemoveUnsupportedFunctions(lua);

    //3.初始化一个空的lua table，并入栈s，这时table在栈顶，对应的index=-1
    lua_newtable(lua);

    //4.压字符串"call"入栈，这时"call"在栈顶，index=-1，前一步的table在栈底
    //对应的index=-2
    lua_pushstring(lua,"call");

    //5.压c函数luaRedisCallCommand入栈，这时"luaRedisCallCommand"在栈顶，index=-1，
    //前两步压入栈的table和"call"在栈中的index分别为-3，-2
    lua_pushcfunction(lua,luaRedisCallCommand);

    //6.为table赋值，table处在-3位置，依次从栈中弹出两个元素作为table的
    //value和key，执行table[key] = value，赋值以后的table类似于这样的结构
    //{"call":luaRedisCallCommand}
    //lua_settable以后栈中只剩table
    lua_settable(lua,-3);

    //7.从栈顶弹出一个元素设置为全局变量，并命名为redis，因为目前栈中只剩
    //table，所以redis就是table
    lua_setglobal(lua,"redis");
  }

void lua_pushcfunction (lua_State *L, lua_CFunction f);

void lua_setglobal (lua_State *L, const char *name);

redis.call('set',KEYS[1],'bar')

lua_pushxxx(luaState,结果);//结果压栈
return 1;//返回结果的个数

int luaRedisGenericCommand(lua_State *lua, int raise_error) {
    //获取函数个数
    int j, argc = lua_gettop(lua);
    struct redisCommand *cmd;
    robj **argv;
    redisClient *c = server.lua_client;
    sds reply;

    /* Build the arguments vector */
    argv = zmalloc(sizeof(robj*)*argc);

    //从栈中依次获取各参数的值
    for (j = 0; j < argc; j++) {
        if (!lua_isstring(lua,j+1)) break;
        argv[j] = createStringObject((char*)lua_tostring(lua,j+1),
                                     lua_strlen(lua,j+1));
    }
   
    /* Setup our fake client for command execution */
    //将参数个数和参数值告诉redis client，这里比较有意思，为什么叫
    //fake client呢？正常情况下redis client都是真实的应用程序，但是这里是
    //redis server伪造的一个redis client
    c->argv = argv;
    c->argc = argc;

    /* Command lookup */
    //根据redis命令查找对应的c函数，argv[0]就是redis命令
    cmd = lookupCommand(argv[0]->ptr);
    if (!cmd || ((cmd->arity > 0 && cmd->arity != argc) ||
                   (argc < -cmd->arity)))
    {
        if (cmd)
            luaPushError(lua,
                "Wrong number of args calling Redis command From Lua script");
        else
            luaPushError(lua,"Unknown Redis command called from Lua script");
        goto cleanup;
    }

    /* There are commands that are not allowed inside scripts. */
    if (cmd->flags & REDIS_CMD_NOSCRIPT) {
        luaPushError(lua, "This Redis command is not allowed from scripts");
        goto cleanup;
    }

    /* Write commands are forbidden against read-only slaves, or if a
     * command marked as non-deterministic was already called in the context
     * of this script. */
    if (cmd->flags & REDIS_CMD_WRITE) {
        if (server.lua_random_dirty) {
            luaPushError(lua,
                "Write commands not allowed after non deterministic commands");
            goto cleanup;
        } else if (server.masterhost && server.repl_slave_ro &&
                   !server.loading &&
                   !(server.lua_caller->flags & REDIS_MASTER))
        {
            luaPushError(lua, shared.roslaveerr->ptr);
            goto cleanup;
        } else if (server.stop_writes_on_bgsave_err &&
                   server.saveparamslen > 0 &&
                   server.lastbgsave_status == REDIS_ERR)
        {
            luaPushError(lua, shared.bgsaveerr->ptr);
            goto cleanup;
        }
    }

    if (cmd->flags & REDIS_CMD_RANDOM) server.lua_random_dirty = 1;
    if (cmd->flags & REDIS_CMD_WRITE) server.lua_write_dirty = 1;

    /* Run the command */
    c->cmd = cmd;
    //调用具体的C函数
    call(c,REDIS_CALL_SLOWLOG | REDIS_CALL_STATS);

    /* Convert the result of the Redis command into a suitable Lua type.
     * The first thing we need is to create a single string from the client
     * output buffers. */

    //解析响应结果
    reply = sdsempty();
    if (c->bufpos) {
        reply = sdscatlen(reply,c->buf,c->bufpos);
        c->bufpos = 0;
    }
    while(listLength(c->reply)) {
        robj *o = listNodeValue(listFirst(c->reply));

        reply = sdscatlen(reply,o->ptr,sdslen(o->ptr));
        listDelNode(c->reply,listFirst(c->reply));
    }
    if (raise_error && reply[0] != '-') raise_error = 0;

    //根据不同的响应将返回值压入栈
    redisProtocolToLuaType(lua,reply);
    /* Sort the output array if needed, assuming it is a non-null multi bulk
     * reply as expected. */
    if ((cmd->flags & REDIS_CMD_SORT_FOR_SCRIPT) &&
        (reply[0] == '*' && reply[1] != '-')) {
            luaSortArray(lua);
    }
    sdsfree(reply);
    c->reply_bytes = 0;

cleanup:
    /* Clean up. Command code may have changed argv/argc so we use the
     * argv/argc of the client instead of the local variables. */
    for (j = 0; j < c->argc; j++)
        decrRefCount(c->argv[j]);
    zfree(c->argv);

    if (raise_error) {
        /* If we are here we should have an error in the stack, in the
         * form of a table with an "err" field. Extract the string to
         * return the plain error. */
        lua_pushstring(lua,"err");
        lua_gettable(lua,-2);
        return lua_error(lua);
    }

    //返回结果的数量
    return 1;
}