设为首页收藏本站|繁體中文
开启辅助访问

Project1

 找回密码
 注册会员
新版主页
搜索
Project1»广场 › 技术讨论 › RPG Maker XP 讨论区 › RGSS103J全部函数
返回列表 发新帖
查看: 2274|回复: 0
打印 上一主题 下一主题

[讨论] RGSS103J全部函数

 关闭 [复制链接]
Goldencolor

Lv1.梦旅人

梦石
0
星屑
220
在线时间
10 小时
注册时间
2009-7-25
帖子
656
跳转到指定楼层
1楼
发表于 2009-12-14 09:26:03 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式

加入我们，或者，欢迎回来。

您需要 登录 才可以下载或查看，没有帐号？注册会员

x
=begin
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_EncDefaultCharEncoding(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[0 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("EncDefaultCharEncoding")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[0 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSAddRTPPath(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[1 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSAddRTPPath")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[1 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSAudioFinalize(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[2 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSAudioFinalize")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[2 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSAudioInitialize(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[3 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSAudioInitialize")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[3 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSClearRTPPath(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[4 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSClearRTPPath")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[4 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSErrorMessage(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[5 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSErrorMessage")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[5 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSErrorType(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[6 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSErrorType")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[6 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSEval(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[7 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSEval")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[7 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSFinalize(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[8 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSFinalize")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[8 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSGC(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[9 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSGC")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[9 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSGameMain(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[10 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSGameMain")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[10 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSGetBool(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[11 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSGetBool")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[11 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSGetDouble(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[12 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSGetDouble")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[12 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSGetInt(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[13 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSGetInt")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[13 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSGetPathWithRTP(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[14 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSGetPathWithRTP")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[14 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSGetRTPPath(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[15 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSGetRTPPath")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[15 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSGetStringACP(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[16 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSGetStringACP")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[16 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSGetStringUTF8(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[17 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSGetStringUTF8")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[17 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSGetTable(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[18 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSGetTable")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[18 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSInitialize(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[19 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSInitialize")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[19 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSSetString(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[20 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSSetString")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[20 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSSetStringACP(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[21 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSSetStringACP")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[21 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSSetStringUTF8(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[22 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSSetStringUTF8")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[22 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RGSSSetupRTP(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[23 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RGSSSetupRTP")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[23 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RegDefaultSyntax(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[24 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RegDefaultSyntax")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[24 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RegEncodingASCII(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[25 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RegEncodingASCII")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[25 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RegEncodingEUC_JP(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[26 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RegEncodingEUC_JP")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[26 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RegEncodingSJIS(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[27 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RegEncodingSJIS")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[27 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RegEncodingUTF8(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[28 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RegEncodingUTF8")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[28 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_RegSyntaxRuby(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[29 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("RegSyntaxRuby")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[29 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_enc_get_left_adjust_char_head(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[30 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("enc_get_left_adjust_char_head")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[30 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_enc_get_prev_char_head(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[31 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("enc_get_prev_char_head")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[31 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_enc_get_right_adjust_char_head(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[32 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("enc_get_right_adjust_char_head")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[32 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_re_alloc_pattern(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[33 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("re_alloc_pattern")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[33 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_end(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[34 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_end")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[34 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_error_code_to_str(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[35 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_error_code_to_str")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[35 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_foreach_name(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[36 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_foreach_name")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[36 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_free(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[37 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_free")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[37 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_get_encoding(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[38 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_get_encoding")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[38 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_get_options(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[39 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_get_options")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[39 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_get_syntax(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[40 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_get_syntax")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[40 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_init(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[41 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_init")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[41 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_match(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[42 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_match")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[42 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_name_to_backref_number(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[43 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_name_to_backref_number")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[43 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_name_to_group_numbers(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[44 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_name_to_group_numbers")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[44 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_new(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[45 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_new")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[45 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_number_of_names(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[46 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_number_of_names")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[46 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_recompile(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[47 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_recompile")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[47 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_region_clear(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[48 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_region_clear")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[48 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_region_copy(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[49 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_region_copy")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[49 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_region_free(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[50 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_region_free")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[50 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_region_new(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[51 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_region_new")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[51 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_region_resize(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[52 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_region_resize")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[52 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_search(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[53 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_search")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[53 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_set_verb_warn_func(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[54 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_set_verb_warn_func")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[54 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_set_warn_func(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[55 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_set_warn_func")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[55 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_regex_version(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[56 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("regex_version")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[56 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_ruby_re_adjust_startpos(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[57 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("ruby_re_adjust_startpos")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[57 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_ruby_re_compile_pattern(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[58 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("ruby_re_compile_pattern")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[58 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_ruby_re_free_pattern(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[59 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("ruby_re_free_pattern")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[59 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_ruby_re_free_registers(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[60 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("ruby_re_free_registers")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[60 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_ruby_re_match(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[61 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("ruby_re_match")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[61 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_ruby_re_mbcinit(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[62 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("ruby_re_mbcinit")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[62 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_ruby_re_recompile_pattern(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[63 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("ruby_re_recompile_pattern")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[63 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_ruby_re_search(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[64 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("ruby_re_search")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[64 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 导出函数
ALCDECL AheadLib_ruby_re_set_casetable(void)
{
        // 保存返回地址到 TLS
        __asm PUSH m_dwReturn[65 * TYPE long];
        __asm CALL DWORD PTR [TlsSetValue];

        // 调用原始函数
        GetAddress("ruby_re_set_casetable")();

        // 获取返回地址并返回
        __asm PUSH EAX;
        __asm PUSH m_dwReturn[65 * TYPE long];
        __asm CALL DWORD PTR [TlsGetValue];
        __asm XCHG EAX, [ESP];
        __asm RET;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
=end
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册会员

本版积分规则

拿上你的纸笔，建造一个属于你的梦想世界，加入吧。
 注册会员
找回密码

站长信箱：[email protected]|手机版|小黑屋|无图版|Project1游戏制作

GMT+8, 2025-11-4 16:49

Powered by Discuz! X3.1

© 2001-2013 Comsenz Inc.

快速回复 返回顶部 返回列表