Lua 源码试读

@echo off

set curdir=%~dp0
pushd %curdir%

set CFN=%1

REM remove the last build
(del /q %CFN%.dll) 2>nul

REM get file name except extension
if "%CFN:~-2%" == ".c" set CFN=%CFN:~0,-2%

gcc -shared -o %CFN%.dll %CFN%.c -B %curdir% -llua5.1

popd
echo on

/*
    Time     ：2015-04-07 09:13:23
    Function ：Lua 的正则匹配试读 （ 截取自 Lua 源码 ）
    Creater     ：Lazy_Pupa
*/
/*
    输出说明 ：_Fun_i_Step_k : Output Message  -- i:功能代号， k:第几步。
    1:    str_find_aux; 2:    posrelat; 3:    match; 4:    start_capture; 5:    end_capture; 
    6:    capture_to_close; 7:    matchbalance; 8:    classend; 9:     matchbracketclass; 
    10:    match_capture; 11:    singlematch; 12:    max_expand; 13:    min_expand; 14:    push_captures; 
    15:    push_onecapture; 16:    match_class; 17:    check_capture; 18:    ; 19:     ; 20:    ;
*/

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

#include "lua.h"

#include "lauxlib.h"
#include "lualib.h"

#define uchar(c) ((unsigned char)(c))

#define CAP_UNFINISHED (-1)
#define CAP_POSITION (-2)

#define L_ESC ‘%‘
#define SPECIALS "^$*+?.([%-"

int Step = 0;

typedef struct MatchState{
    const char *str_init;
    const char *str_end;
    lua_State *L;
    int level;
    struct {
        const char *init;
        ptrdiff_t len;
    }capture[LUA_MAXCAPTURES];
}MatchState;

/*
    function: calculate relate position
    parameters: (pos, len)
    return: (-4, 2) -> 0; (-3, 2) -> 0; (-2, 2) -> 1; (-1, 2) -> 2; 
            (0, 2) -> 0; (1, 2) -> 1; (2, 2) -> 2; (3, 2) -> 3;
*/
static ptrdiff_t posrelat(ptrdiff_t pos, size_t len) {
    printf("_Fun_%02d_Step_%3d : parameters %d, %d\n", 2, ++Step, pos, len);
    if(pos < 0) pos += (ptrdiff_t)len + 1;
    printf("_Fun_%02d_Step_%3d :return %d ? %d : 0\n", 2, ++Step, (pos >= 0), pos);
    return (pos >= 0) ? pos : 0;
}

static const char *classend(MatchState *ms, const char *p) {    // find the %f[match] pattern ‘]‘
    // ms: 查找状态; *p: 匹配字符串
    printf("_Fun_%02d_Step_%3d : parameters ‘%s‘\n", 8, ++Step, p);
    switch(*p++){
        case L_ESC:{
            if (*p == ‘\0‘)
                luaL_error(ms->L, "malformed pattern (end with " LUA_QL("%%") ")");
            printf("_Fun_%02d_Step_%3d :case L_ESC return ‘%s‘\n", 8, ++Step, p + 1);
            return p + 1;
        }
        case ‘[‘:{
            if(*p == ‘^‘) p++;
            do{
                if(*p == ‘\0‘)
                    luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")");
                if(*(p++) == L_ESC && *p != ‘\0‘)
                    p++;
            }while(*p != ‘]‘);
            printf("_Fun_%02d_Step_%3d :case ‘[‘ return ‘%s‘\n", 8, ++Step, p + 1);
            return p + 1;
        }
        default:{
            printf("_Fun_%02d_Step_%3d :default return ‘%s‘\n", 8, ++Step, p);
            return p;
        }
    }
}

static int match_class(int c, int cl) {
    printf("_Fun_%02d_Step_%3d : parameters %d, %d\n", 16, ++Step, c, cl);
    int res;
    switch (tolower(cl)){
        case ‘a‘: res = isalpha(c); break;
        case ‘c‘: res = iscntrl(c); break;
        case ‘d‘: res = isdigit(c); break;
        case ‘l‘: res = islower(c); break;
        case ‘p‘: res = ispunct(c); break;
        case ‘s‘: res = isspace(c); break;
        case ‘u‘: res = isupper(c); break;
        case ‘w‘: res = isalnum(c); break;
        case ‘x‘: res = isxdigit(c); break;
        case ‘z‘: res = (c == 0); break;
        default: return (cl == c);
    }
    printf("_Fun_%02d_Step_%3d :return (%d ? %d : %d)\n", 16, ++Step, islower(cl), res, !res);
    return (islower(cl) ? res : !res);
}

static int matchbracketclass(int c, const char *p, const char *ec) { // 匹配模版类。
    // c: ; *p: 匹配字符串; *ec: 匹配结束位置。
    printf("_Fun_%02d_Step_%3d : parameters %c, ‘%s‘, ‘%s‘\n", 9, ++Step, c, p, ec);
    int sig = 1;
    if (*(p+1) == ‘^‘) {
        sig = 0;
        p++;
    }
    while (++p < ec) {
        if (*p == L_ESC) {
            p++;
            if (match_class(c, uchar(*p)))
            {
                printf("_Fun_%02d_Step_%3d :if return %d\n", 9, ++Step, sig);
                return sig;
            }
        }
        else if ((*(p+1) == ‘-‘) && (p+2 < ec)) {
            p += 2;
            if (uchar(*(p-2)) <= c && c <= uchar(*p))
            {
                printf("_Fun_%02d_Step_%3d :else if return %d\n", 9, ++Step, sig);
                return sig;
            }
        }
        else if (uchar(*p) == c)
        {
                printf("_Fun_%02d_Step_%3d :else if 2 return %d\n", 9, ++Step, sig);
                return sig;
        }
    }
    printf("_Fun_%02d_Step_%3d :return %d\n", 9, ++Step, !sig);
    return !sig;
}

static int singlematch(int c, const char *p, const char *ep) {
    // c: source char; *p: pattern string; *ep: pattern end
    printf("_Fun_%02d_Step_%3d : parameters %d, ‘%s‘, ‘%s‘\n", 11, ++Step, c, p, ep);
    switch(*p){
        case ‘.‘: 
            printf("_Fun_%02d_Step_%3d :return 1;\n", 11, ++Step);
            return 1;
        case L_ESC: 
            printf("_Fun_%02d_Step_%3d :return match_class(c, uchar(*(p+1)));\n", 11, ++Step);
            return match_class(c, uchar(*(p+1)));
        case ‘[‘: 
            printf("_Fun_%02d_Step_%3d :return matchbracketclass(c, p, ep-1);\n", 11, ++Step);
            return matchbracketclass(c, p, ep-1);
        default: 
            printf("_Fun_%02d_Step_%3d :default return %d\n", 11, ++Step, (uchar(*p) == c));
            return (uchar(*p) == c);
    }
}

static const char *match(MatchState *ms, const char *s, const char *p);

static const char *matchbalance(MatchState *ms, const char *s, const char *p) {
    // ms: 查找状态;  *s: 源字符串; *p: 匹配字符串
    // printf("ms->str_end = ‘%s‘, *s = ‘%s‘, *p = ‘%s‘\n", ms->str_end, s, p);
    printf("_Fun_%02d_Step_%3d : parameters ‘%s‘, ‘%s‘\n", 7, ++Step, s, p);
    if(*p == 0 || *(p+1) == 0)    // *p 以 %b"结尾。
        luaL_error(ms->L, "unbalanced pattern");
    if (*s != *p) 
    {
        printf("_Fun_%02d_Step_%3d :if return NULL\n", 7, ++Step);
        return NULL;
    }
    else {
        int b = *p;        // 开始
        int e = *(p+1);    // 结束
        int cont = 1;    // 
        while (++s < ms->str_end) {
            // printf("*s = %d, b = %d, e = %d, cont = %d\n*s = ‘%s‘\n", *s, b, e, cont, s);
            if (*s == e) {
                if (--cont == 0)
                {
                    printf("_Fun_%02d_Step_%3d :return ‘%s‘\n", 7, ++Step, s+1);
                    return s+1;
                }
            }else if (*s == b) cont++;    // 支持嵌套
        }
    }
    printf("_Fun_%02d_Step_%3d :return NULL\n", 7, ++Step);
    return NULL;
}

static const char *max_expand(MatchState *ms, const char *s, const char *p, const char *ep) {
    // ms: 查找状态; *s: 源字符串; *p: 匹配字符串; *ep: 匹配字符串结尾
    printf("_Fun_%02d_Step_%3d : parameters ‘%s‘, ‘%s‘, ‘%s‘\n", 12, ++Step, s, p, ep);
    ptrdiff_t i = 0;
    while((s+i) < ms->str_end && singlematch(uchar(*(s+i)), p, ep))    // anchor the match tail
        i++;
    while (i >= 0) {
        const char *res = match(ms, (s+i), ep+1);    // 
        if (res) 
        {
            printf("_Fun_%02d_Step_%3d :return ‘%s‘\n", 12, ++Step, res);
            return res;
        }
        i--;
    }
    printf("_Fun_%02d_Step_%3d :return NULL\n", 12, ++Step);
    return NULL;
}

static const char *min_expand(MatchState *ms, const char *s, const char *p, const char *ep) {
    printf("_Fun_%02d_Step_%3d : parameters ‘%s‘, ‘%s‘, ‘%s‘\n", 13, ++Step, s, p, ep);
    for(;;) {
        const char *res = match(ms, s, ep+1);
        if (res != NULL)
        {
            printf("_Fun_%02d_Step_%3d : return ‘%s‘\n", 13, ++Step, res);
            return res;
        }
        else if (s<ms->str_end && singlematch(uchar(*s), p, ep))
            s++;
        else
        {
            printf("_Fun_%02d_Step_%3d : return NULL\n", 13, ++Step);
            return NULL;
        }
    }
}

static const char *start_capture(MatchState *ms, const char *s, const char *p, int what) {
    // ms: 查找状态; *s: 源字符串; *p: 匹配字符串; what: 标记捕获是否结束
    printf("_Fun_%02d_Step_%3d : parameters %d, ‘%s‘, ‘%s‘, %d\n", 4, ++Step, ms->level, s, p, what);
    const char *res;
    int level = ms->level;    // 捕获个数
    if (level > LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures");
    ms->capture[level].init = s;
    ms->capture[level].len = what;    // 捕获状态
    ms->level = level + 1;    // 捕获加一。
    if ((res=match(ms, s, p)) == NULL)
        ms->level--;
    printf("_Fun_%02d_Step_%3d :return ‘%s‘\n", 4, ++Step, res);
    return res;
}

// 嵌套捕获结束 如：src = "Lua Test String!"; matchString = "((%a+) %a+)"; return "Lua Test", "Lua";
static int capture_to_close(MatchState *ms) {
    // ms: 查找状态
    printf("_Fun_%02d_Step_%3d : parameters %d\n", 6, ++Step, ms->level);
    int level = ms->level;    // 查找深度
    for(level--; level>=0; level--)    // 查找该捕获的起始深度
        if(ms->capture[level].len == CAP_UNFINISHED)
        {
            printf("_Fun_%02d_Step_%3d :return %d\n", 6, ++Step, level);
            return level;
        }
    printf("_Fun_%02d_Step_%3d :return error\n", 6, ++Step);
    return luaL_error(ms->L, "invalid pattern capture");
}

static const char *end_capture(MatchState *ms, const char *s, const char *p) {
    // ms: 查找状态; *s: 源字符串; *p: 捕获之后的字符串
    printf("_Fun_%02d_Step_%3d : parameters ‘%s‘, ‘%s‘\n", 5, ++Step, s, p);
    int l = capture_to_close(ms);    // 匹配的左括号。
    printf("_Fun_%02d_Step_%3d : parameters ‘%s‘, ‘%s‘, ‘%s‘, %d\n", 5, ++Step, ms->capture[l].init, s, p, s - ms->capture[l].init);
    const char *res;
    ms->capture[l].len = s - ms->capture[l].init;    // 记录捕获长度。
    if((res = match(ms, s, p)) == NULL)        // 捕获结束，开始后续匹配。
        ms->capture[l].len = CAP_UNFINISHED;    // UNKNOW... Um, just mark capture unfinished.
    printf("_Fun_%02d_Step_%3d :return ‘%s‘\n", 5, ++Step, res);
    return res;
}

static int check_capture(MatchState *ms, int l) {
    // ms : 查找状态; l : 匹配字符。 
    printf("_Fun_%02d_Step_%3d : parameters %d, %d, %d\n", 17, ++Step, ms->level, ms->capture[l].len, l);
    l -= ‘1‘;
    if (l<0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
        return luaL_error(ms->L, "invalid capture index");
    printf("_Fun_%02d_Step_%3d : parameters %d\n", 17, ++Step, l);
    return l;
}

static const char *match_capture(MatchState *ms, const char *s, int l) {
    // ms : 查找状态; *s : 查找源字符串; l : 匹配字符。 
    printf("_Fun_%02d_Step_%3d : parameters ‘%s‘, %d\n", 10, ++Step, s, l);
    size_t len;
    l = check_capture(ms, l);
    printf("_Fun_%02d_Step_%3d : parameters ‘%s‘, ‘%s‘, %d\n", 10, ++Step, ms->capture[l].init, s, l);
    len = ms->capture[l].len;
    printf("_Fun_%02d_Step_%3d : parameters ‘%s‘, ‘%s‘, %d, %d\n", 10, ++Step, ms->capture[l].init, s, l, s+len);
    if ((size_t)(s+len) >= len && memcmp(ms->capture[l].init, s, len) == 0)
    {
        printf("_Fun_%02d_Step_%3d :return ‘%s‘\n", 10, ++Step, s+len);
        return s+len;
    }
    else
    {
        printf("_Fun_%02d_Step_%3d :return NULL\n", 10, ++Step);
        return NULL;
    }
}

static const char *match(MatchState *ms, const char *s, const char *p) {
    // ms : 查找状态; *s : 查找源字符串; *p : 匹配字符串。 
    init:
    printf("_Fun_%02d_Step_%3d : parameters *ms, ‘%s‘, ‘%s‘\n", 3, ++Step, s, p);
    switch(*p) {
        case ‘(‘:{
            if (*(p+1) == ‘)‘)    // 空捕获返回捕获的起始位置。如 find(‘Lua‘, ‘()‘) -> 1, 0, 1;  find(‘Lua‘, ‘%a()‘) -> 1, 1, 2; 
            {
                printf("_Fun_%02d_Step_%3d :return start_capture(ms, s, p+2, CAP_POSITION)\n", 3, ++Step);
                return start_capture(ms, s, p+2, CAP_POSITION);
            }
            else
            {
                printf("_Fun_%02d_Step_%3d :return start_capture(ms, s, p+1, CAP_UNFINISHED)\n", 3, ++Step);
                return start_capture(ms, s, p+1, CAP_UNFINISHED);
            }
        }
        case ‘)‘:{
            printf("_Fun_%02d_Step_%3d :return end_capture(ms, s, p+1)\n", 3, ++Step);
            return end_capture(ms, s, p+1);
        }
        case L_ESC:{    // translate meaning char
            switch(*(p+1)) {
                case ‘b‘:{
                    s = matchbalance(ms, s, p+2);    // 
                    if (s == NULL)
                    {
                        printf("_Fun_%02d_Step_%3d :case ‘b‘ return NULL\n", 3, ++Step);
                        return NULL;
                    }
                    p += 4;
                    printf("_Fun_%02d_Step_%3d :case ‘b‘ goto init\n", 3, ++Step);
                    goto init;
                }
                case ‘f‘:{    // {LuaStr.find("Lua Test String!", "(%f[%a+])") -> 1    0} 没懂这是干嘛的。。。。
                    const char *ep;
                    char previous;
                    p += 2;
                    if (*p != ‘[‘)
                        luaL_error(ms->L, "missing" LUA_QL("[") " after " LUA_QL("%%f") " in pattern");
                    ep = classend(ms, p);    // anchor the %f[] end.
                    previous = (s == ms->str_init) ? ‘\0‘ : *(s-1);
                    if (matchbracketclass(uchar(previous), p, ep-1) || !matchbracketclass(uchar(*s), p, ep-1))
                    {
                        printf("_Fun_%02d_Step_%3d :case ‘f‘ return NULL\n", 3, ++Step);
                        return NULL;
                    }
                    p = ep;
                    printf("_Fun_%02d_Step_%3d :case ‘f‘ goto init\n", 3, ++Step);
                    goto init;
                }
                default: {
                    if (isdigit(uchar(*(p+1)))) {
                        s = match_capture(ms, s, uchar(*(p+1)));    // 源自符指针后移，至下一个匹配开始。
                        if (s == NULL)
                        {
                            printf("_Fun_%02d_Step_%3d :case L_ESC return NULL\n", 3, ++Step);
                            return NULL;
                        }
                        p += 2;
                        printf("_Fun_%02d_Step_%3d :default goto init\n", 3, ++Step);
                        goto init;
                    }
                    printf("_Fun_%02d_Step_%3d :case L_ESC goto dflt\n", 3, ++Step);
                    goto dflt;
                }
            }
        }
        case ‘\0‘:{
            printf("_Fun_%02d_Step_%3d :case ‘\\0‘ return ‘%s‘\n", 3, ++Step, s);
            return s;
        }
        case ‘$‘:{
            if (*(p+1) == ‘\0‘)    // 是否匹配结束位置。
            {
                printf("_Fun_%02d_Step_%3d :case ‘$‘ return %d ? s : NULL\n", 3, ++Step, (s == ms->str_end));
                return (s == ms->str_end) ? s : NULL;
            }
            else
            {
                printf("_Fun_%02d_Step_%3d :case ‘\0‘ goto dflt\n", 3, ++Step);                
                goto dflt;
            }
        }
        default: dflt: {
            const char *ep = classend(ms, p);    // check single match, if true jump to ‘[match string]‘ end ,( ep: end of *p)
            int m = s<ms->str_end && singlematch(uchar(*s), p, ep);    // 简单匹配标识。
            switch(*ep) {
                case ‘?‘:{    // 匹配 0 次或 1 次。
                    const char *res;
                    if (m && ((res = match(ms, s+1, ep+1)) != NULL))    // UNKNOW ... Um, like match a result.
                    {
                        printf("_Fun_%02d_Step_%3d :case ‘?‘ return ‘%s‘\n", 3, ++Step, res);
                        return res;
                    }
                    p=ep+1;    // Don‘t match any result.
                    printf("_Fun_%02d_Step_%3d :case ‘?‘ goto init\n", 3, ++Step);    
                    goto init;
                }
                case ‘*‘:{    // 匹配 0 次或多次。
                    printf("_Fun_%02d_Step_%3d :return max_expand(ms, s, p, ep)\n", 3, ++Step);
                    return max_expand(ms, s, p, ep);
                }
                case ‘+‘:{    // 匹配 1 次或多次。
                    printf("_Fun_%02d_Step_%3d :return (m ? max_expand(ms, s+1, p, ep) : NULL)\n", 3, ++Step);
                    return (m ? max_expand(ms, s+1, p, ep) : NULL);
                }
                case ‘-‘:{    // 匹配 0 次或多次。
                    printf("_Fun_%02d_Step_%3d :return min_expand(ms, s, p, ep)\n", 3, ++Step);
                    return min_expand(ms, s, p, ep);
                }
                default: {
                    if (!m)
                    {
                        printf("_Fun_%02d_Step_%3d :default: dflt: return NULL\n", 3, ++Step);
                        return NULL;
                    }
                    s++;
                    p=ep;
                    printf("_Fun_%02d_Step_%3d :default: dflt goto init\n", 3, ++Step);    
                    goto init;
                }
            }
        }
    }
}

static const char * lmemfind(const char *s1, size_t l1, const char *s2, size_t l2) {
    return NULL;
}

static void push_onecapture(MatchState *ms, int i, const char *s, const char *e) {
    printf("_Fun_%02d_Step_%3d : parameters %d, ‘%s‘, ‘%s‘\n", 15, ++Step, i, s, e);
    if (i>=ms->level) {
        if (i == 0)
            lua_pushlstring(ms->L, s, e - s);
        else
            luaL_error(ms->L, "invalid capture index!");
    }
    else {
        ptrdiff_t l = ms->capture[i].len;
        if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture");
        if (l == CAP_POSITION)
            lua_pushinteger(ms->L, ms->capture[i].init - ms->str_init +1);
        else
            lua_pushlstring(ms->L, ms->capture[i].init, l);
    }
}

static int push_captures(MatchState *ms, const char *s, const char *e) {
    printf("_Fun_%02d_Step_%3d : parameters %d, ‘%s‘, ‘%s‘\n", 14, ++Step, ms->level, s, e);
    int i;
    int nlevels = (ms->level == 0 && s) ? 1 : ms->level;
    luaL_checkstack(ms->L, nlevels, "too many captures");
    for(i=0; i<nlevels; i++)
        push_onecapture(ms, i, s, e);
    printf("_Fun_%02d_Step_%3d :return %d\n", 14, ++Step, nlevels);
    return nlevels;
}

static int str_find_aux(lua_State *L, int find) {
    printf("_Fun_%02d_Step_%3d : parameters find = %d\n", 1, ++Step, find);
    size_t srcStrLen, matchStrLen;
    const char *srcStr = luaL_checklstring(L, 1, &srcStrLen);
    const char *matchStr = luaL_checklstring(L, 2, &matchStrLen);
    ptrdiff_t startFindPostion = posrelat(luaL_optinteger(L, 3, 1), srcStrLen) - 1;
    if(startFindPostion < 0) startFindPostion = 0;
    else if ((size_t)(startFindPostion) > srcStrLen) startFindPostion = (ptrdiff_t)srcStrLen;
    if (find && (lua_toboolean(L, 4) || strpbrk(matchStr, SPECIALS) == NULL)) {
        const char *s2 = lmemfind(srcStr+startFindPostion, srcStrLen-startFindPostion, matchStr, matchStrLen);    // 常规匹配查找
        if (s2) {
            lua_pushinteger(L, s2-srcStr+1);
            lua_pushinteger(L, s2-srcStr+matchStrLen);
            printf("_Fun_%02d_Step_%3d :return 2.\n", 1, ++Step);
            return 2;
        }
    }
    else { // 正则匹配查找
        MatchState ms;
        int anchor = (*matchStr == ‘^‘) ? (matchStr++, 1) : 0; // 是否定位头部
        const char *s1 = srcStr + startFindPostion;    // 待查找的字符串
        ms.L = L;                // 保存脚本上下文
        ms.str_init = srcStr;    // 保存待查找的字符串
        ms.str_end = srcStr + srcStrLen; // 保存字符串结束位置
        do {
            const char *res;
            ms.level = 0;    // 设置默认捕获的数量
            if ((res=match(&ms, s1, matchStr)) != NULL) {    // 匹配主体部分
                if (find) { // 返回查找结果
                    lua_pushinteger(L, s1-srcStr+1);
                    lua_pushinteger(L, res-srcStr);
                    printf("_Fun_%02d_Step_%3d :return push_captures(&ms, NULL, 0) + 2\n", 1, ++Step);
                    return push_captures(&ms, NULL, 0) + 2;
                }else        // 返回匹配结果
                {
                    printf("_Fun_%02d_Step_%3d :return push_captures(&ms, s1, res)\n", 1, ++Step);
                    return push_captures(&ms, s1, res);
                }
            }
        }while (s1++ < ms.str_end && !anchor);    // 一次匹配不成功且非从头部开始定位则继续。
    }
    lua_pushnil(L);        // 查找失败。
    printf("_Fun_%02d_Step_%3d :return 1.\n", 1, ++Step);
    return 1;
}

static int str_find(lua_State *L) {
    printf(
    "=================================== Lua Find Test ===================================\n"
    " 1: str_find_aux    ;  4: start_capture  ;  5: end_capture;  2: posrelat; 3: match;\n"
    " 6: capture_to_close;  7: matchbalance   ;  8: classend   ;  9: matchbracketclass;\n"
    "10: match_capture   ; 11: singlematch    ; 12: max_expand ; 13: min_expand;\n"
    "14: push_captures   ; 15: push_onecapture; 16: match_class; 17: check_capture;\n"
    "=================================== Lua Find Test ===================================\n");
    return str_find_aux(L, 1);
}

static const luaL_Reg strlib[] = {
    {"find", str_find},
    {NULL, NULL}
};


// Open String Library
extern int luaopen_LuaStr(lua_State *L) {
    const char *libraryName = "LuaStr";
    luaL_register(L, libraryName, strlib);
    return 1;
}

=================================== Lua Find Test ===================================
 1: str_find_aux    ;  4: start_capture  ;  5: end_capture;  2: posrelat; 3: match;
 6: capture_to_close;  7: matchbalance   ;  8: classend   ;  9: matchbracketclass;
10: match_capture   ; 11: singlematch    ; 12: max_expand ; 13: min_expand;
14: push_captures   ; 15: push_onecapture; 16: match_class; 17: check_capture;
=================================== Lua Find Test ===================================
_Fun_01_Step_  1 : parameters find = 1
_Fun_02_Step_  2 : parameters 1, 16
_Fun_02_Step_  3 :return 1 ? 1 : 0
_Fun_03_Step_  4 : parameters *ms, ‘Lua Test String!‘, ‘(%f[%a+])‘
_Fun_03_Step_  5 :return start_capture(ms, s, p+1, CAP_UNFINISHED)
_Fun_04_Step_  6 : parameters 0, ‘Lua Test String!‘, ‘%f[%a+])‘, -1
_Fun_03_Step_  7 : parameters *ms, ‘Lua Test String!‘, ‘%f[%a+])‘
_Fun_08_Step_  8 : parameters ‘[%a+])‘
_Fun_08_Step_  9 :case ‘[‘ return ‘)‘
_Fun_09_Step_ 10 : parameters  , ‘[%a+])‘, ‘])‘
_Fun_16_Step_ 11 : parameters 0, 97
_Fun_16_Step_ 12 :return (2 ? 0 : 1)
_Fun_09_Step_ 13 :return 0
_Fun_09_Step_ 14 : parameters L, ‘[%a+])‘, ‘])‘
_Fun_16_Step_ 15 : parameters 76, 97
_Fun_16_Step_ 16 :return (2 ? 1 : 0)
_Fun_09_Step_ 17 :if return 1
_Fun_03_Step_ 18 :case ‘f‘ goto init
_Fun_03_Step_ 19 : parameters *ms, ‘Lua Test String!‘, ‘)‘
_Fun_03_Step_ 20 :return end_capture(ms, s, p+1)
_Fun_05_Step_ 21 : parameters ‘Lua Test String!‘, ‘‘
_Fun_06_Step_ 22 : parameters 1
_Fun_06_Step_ 23 :return 0
_Fun_05_Step_ 24 : parameters ‘Lua Test String!‘, ‘Lua Test String!‘, ‘‘, 0
_Fun_03_Step_ 25 : parameters *ms, ‘Lua Test String!‘, ‘‘
_Fun_03_Step_ 26 :case ‘\0‘ return ‘Lua Test String!‘
_Fun_05_Step_ 27 :return ‘Lua Test String!‘
_Fun_04_Step_ 28 :return ‘Lua Test String!‘
_Fun_01_Step_ 29 :return push_captures(&ms, NULL, 0) + 2
_Fun_14_Step_ 30 : parameters 1, ‘(null)‘, ‘(null)‘
_Fun_15_Step_ 31 : parameters 0, ‘(null)‘, ‘(null)‘
_Fun_14_Step_ 32 :return 1
1    0