修改源代码，让Lua支持中文,中英混合变量名收藏

最新推荐文章于 2024-03-15 19:13:47 发布
最新推荐文章于 2024-03-15 19:13:47 发布
阅读量1.4k 收藏
点赞数
分类专栏： 学习 文章标签： lua token string buffer warnings concatenation

http://blog.csdn.net/suxiaojack/archive/2006/05/24/753323.aspx

/*
** 作者：苏晓  时间：2006年5月24日
** 若有转载请注明出处，谢谢！
*/

Lua脚本的执行效率是相当高的，源文件用纯C写成相当小巧，其可扩展性相当强，前途一片光明。
其源文件写得不复杂，相当值得一读。
作为中国人，在编程语言的使用上如果能够使用中文作为变量名是非常好的一件事。但是标准的Lua并不支持中文变量名。虽然可以在字符串中处理中文。
其实只要修改少量代码就可以让Lua支持中文变量名。

打开lua的源文件文件夹（包）可以从文件名知道，llex.h,llex.c是用来做文件语法分析的。
备份llex.c为llex_old.c
打开llex.c进行修改如下：

/*
 ** $Id: llex.c,v 1.119 2003/03/24 12:39:34 roberto Exp $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */


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

#define llex_c

#include "lua.h"

#include "ldo.h"
#include "llex.h"
#include "lobject.h"
#include "lparser.h"
#include "lstate.h"
#include "lstring.h"
#include "lzio.h"



#define next(LS) (LS->current = zgetc(LS->z))



/* ORDER RESERVED */
static const char *const token2string[] =
{
  "and", "break", "do", "else", "elseif", "end", "false", "for", "function",
    "if", "in", "local", "nil", "not", "or", "repeat", "return", "then", "true",
    "until", "while", "*name", "..", "...", "==", ">=", "<=", "~=", "*number",
    "*string", "<eof>"
};


void luaX_init(lua_State *L)
{
  int i;
  for (i = 0; i < NUM_RESERVED; i++)
  {
    TString *ts = luaS_new(L, token2string[i]);
    luaS_fix(ts); /* reserved words are never collected */
    lua_assert(strlen(token2string[i]) + 1 <= TOKEN_LEN);
    ts->tsv.reserved = cast(lu_byte, i + 1); /* reserved word */
  }
}


#define MAXSRC          80


void luaX_checklimit(LexState *ls, int val, int limit, const char *msg)
{
  if (val > limit)
  {
    msg = luaO_pushfstring(ls->L, "too many %s (limit=%d)", msg, limit);
    luaX_syntaxerror(ls, msg);
  }
}


void luaX_errorline(LexState *ls, const char *s, const char *token, int line)
{
  lua_State *L = ls->L;
  char buff[MAXSRC];
  luaO_chunkid(buff, getstr(ls->source), MAXSRC);
  luaO_pushfstring(L, "%s:%d: %s near `%s'", buff, line, s, token);
  luaD_throw(L, LUA_ERRSYNTAX);
}


static void luaX_error(LexState *ls, const char *s, const char *token)
{
  luaX_errorline(ls, s, token, ls->linenumber);
}


void luaX_syntaxerror(LexState *ls, const char *msg)
{
  const char *lasttoken;
  switch (ls->t.token)
  {
    case TK_NAME:
      lasttoken = getstr(ls->t.seminfo.ts);
      break;
    case TK_STRING:
    case TK_NUMBER:
      lasttoken = luaZ_buffer(ls->buff);
      break;
    default:
      lasttoken = luaX_token2str(ls, ls->t.token);
      break;
  }
  luaX_error(ls, msg, lasttoken);
}


const char *luaX_token2str(LexState *ls, int token)
{
  if (token < FIRST_RESERVED)
  {
    lua_assert(token == (unsigned char)token);
    return luaO_pushfstring(ls->L, "%c", token);
  }
  else
    return token2string[token - FIRST_RESERVED];
}


static void luaX_lexerror(LexState *ls, const char *s, int token)
{
  if (token == TK_EOS)
    luaX_error(ls, s, luaX_token2str(ls, token));
  else
    luaX_error(ls, s, luaZ_buffer(ls->buff));
}


static void inclinenumber(LexState *LS)
{
  next(LS); /* skip `/n' */
  ++LS->linenumber;
  luaX_checklimit(LS, LS->linenumber, MAX_INT, "lines in a chunk");
}


void luaX_setinput(lua_State *L, LexState *LS, ZIO *z, TString *source)
{
  LS->L = L;
  LS->lookahead.token = TK_EOS; /* no look-ahead token */
  LS->z = z;
  LS->fs = NULL;
  LS->linenumber = 1;
  LS->lastline = 1;
  LS->source = source;
  next(LS); /* read first char */
  if (LS->current == '#')
  {
    do
    {
       /* skip first line */
      next(LS);
    }
    while (LS->current != '/n' && LS->current != EOZ);
  }
}



/*
 ** =======================================================
 ** LEXICAL ANALYZER
 ** =======================================================
 */


/* use buffer to store names, literal strings and numbers */

/* extra space to allocate when growing buffer */
#define EXTRABUFF	32

/* maximum number of chars that can be read without checking buffer size */
#define MAXNOCHECK	5

#define checkbuffer(LS, len)	/
if (((len)+MAXNOCHECK)*sizeof(char) > luaZ_sizebuffer((LS)->buff)) /
luaZ_openspace((LS)->L, (LS)->buff, (len)+EXTRABUFF)

#define save(LS, c, l) /
(luaZ_buffer((LS)->buff)[l++] = cast(char, c))
#define save_and_next(LS, l)  (save(LS, LS->current, l), next(LS))

/*readname 是原来用来读入变量名称的。可以注释掉*/
static size_t readname(LexState *LS)
{
  size_t l = 0;
  checkbuffer(LS, l);
  do
  {
    checkbuffer(LS, l);
    save_and_next(LS, l);
  }
  while (isalnum(LS->current) || LS->current == '_');
  save(LS, '/0', l)
    ;
  return l - 1;
}

/*开始添加支持中英文变量名*/
/*因为LS->current是int类型!*/

static int isChineseCode(int charint)
{
  return (charint > 0x80);
};
/*如果要求速度用(LS->current>0x80)替换掉isChineseCode函数调用更好*/
static size_t readChinesename(LexState *LS)
{
  size_t l = 0;
  checkbuffer(LS, l);
  do
  {
    if (isChineseCode(LS->current))
    {
      checkbuffer(LS, l);
      save_and_next(LS, l);
      checkbuffer(LS, l);
      save_and_next(LS, l); //处理了一个中文字符
    }
    else
    {
      checkbuffer(LS, l);
      save_and_next(LS, l); //处理英文字符或者下划线
    };
  }
  while (isChineseCode(LS->current) || LS->current == '_' || isalnum(LS
    ->current));
  save(LS, '/0', l)
    ;
  return l - 1;
};


/* LUA_NUMBER */
static void read_numeral(LexState *LS, int comma, SemInfo *seminfo)
{
  size_t l = 0;
  checkbuffer(LS, l);
  if (comma)
    save(LS, '.', l);
  while (isdigit(LS->current))
  {
    checkbuffer(LS, l);
    save_and_next(LS, l);
  }
  if (LS->current == '.')
  {
    save_and_next(LS, l);
    if (LS->current == '.')
    {
      save_and_next(LS, l);
      save(LS, '/0', l);
      luaX_lexerror(LS,
        "ambiguous syntax (decimal point x string concatenation)", TK_NUMBER);
    }
  }
  while (isdigit(LS->current))
  {
    checkbuffer(LS, l);
    save_and_next(LS, l);
  }
  if (LS->current == 'e' || LS->current == 'E')
  {
    save_and_next(LS, l); /* read `E' */
    if (LS->current == '+' || LS->current == '-')
      save_and_next(LS, l);
     /* optional exponent sign */
    while (isdigit(LS->current))
    {
      checkbuffer(LS, l);
      save_and_next(LS, l);
    }
  }
  save(LS, '/0', l);
  if (!luaO_str2d(luaZ_buffer(LS->buff), &seminfo->r))
    luaX_lexerror(LS, "malformed number", TK_NUMBER);
}


static void read_long_string(LexState *LS, SemInfo *seminfo)
{
  int cont = 0;
  size_t l = 0;
  checkbuffer(LS, l);
  save(LS, '[', l); /* save first `[' */
  save_and_next(LS, l); /* pass the second `[' */
  if (LS->current == '/n')
   /* string starts with a newline? */
    inclinenumber(LS);
   /* skip it */
  for (;;)
  {
    checkbuffer(LS, l);
    switch (LS->current)
    {
      case EOZ:
        save(LS, '/0', l);
        luaX_lexerror(LS, (seminfo) ? "unfinished long string" :
          "unfinished long comment", TK_EOS);
        break; /* to avoid warnings */
      case '[':
        save_and_next(LS, l);
        if (LS->current == '[')
        {
          cont++;
          save_and_next(LS, l);
        }
        continue;
      case ']':
        save_and_next(LS, l);
        if (LS->current == ']')
        {
          if (cont == 0)
            goto endloop;
          cont--;
          save_and_next(LS, l);
        }
        continue;
      case '/n':
        save(LS, '/n', l);
        inclinenumber(LS);
        if (!seminfo)
          l = 0;
         /* reset buffer to avoid wasting space */
        continue;
      default:
        save_and_next(LS, l);
    }
  }
  endloop: save_and_next(LS, l); /* skip the second `]' */
  save(LS, '/0', l);
  if (seminfo)
    seminfo->ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff) + 2, l - 5);
}


static void read_string(LexState *LS, int del, SemInfo *seminfo)
{
  size_t l = 0;
  checkbuffer(LS, l);
  save_and_next(LS, l);
  while (LS->current != del)
  {
    checkbuffer(LS, l);
    switch (LS->current)
    {
      case EOZ:
        save(LS, '/0', l);
        luaX_lexerror(LS, "unfinished string", TK_EOS);
        break; /* to avoid warnings */
      case '/n':
        save(LS, '/0', l);
        luaX_lexerror(LS, "unfinished string", TK_STRING);
        break; /* to avoid warnings */
      case '//':
        next(LS); /* do not save the `/' */
        switch (LS->current)
        {
        case 'a':
          save(LS, '/a', l);
          next(LS);
          break;
        case 'b':
          save(LS, '/b', l);
          next(LS);
          break;
        case 'f':
          save(LS, '/f', l);
          next(LS);
          break;
        case 'n':
          save(LS, '/n', l);
          next(LS);
          break;
        case 'r':
          save(LS, '/r', l);
          next(LS);
          break;
        case 't':
          save(LS, '/t', l);
          next(LS);
          break;
        case 'v':
          save(LS, '/v', l);
          next(LS);
          break;
        case '/n':
          save(LS, '/n', l);
          inclinenumber(LS);
          break;
        case EOZ:
          break; /* will raise an error next loop */
        default:
          {
            if (!isdigit(LS->current))
              save_and_next(LS, l);
             /* handles //, /", /', and /? */
            else
            {
               /* /xxx */
              int c = 0;
              int i = 0;
              do
              {
                c = 10 * c + (LS->current - '0');
                next(LS);
              }
              while (++i < 3 && isdigit(LS->current));
              if (c > UCHAR_MAX)
              {
                save(LS, '/0', l);
                luaX_lexerror(LS, "escape sequence too large", TK_STRING);
              }
              save(LS, c, l);
            }
          }
        }
        break;
      default:
        save_and_next(LS, l);
    }
  }
  save_and_next(LS, l); /* skip delimiter */
  save(LS, '/0', l);
  seminfo->ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff) + 1, l - 3);
}


int luaX_lex(LexState *LS, SemInfo *seminfo)
{
  for (;;)
  {
    switch (LS->current)
    {

      case '/n':
        {
          inclinenumber(LS);
          continue;
        }
      case '-':
        {
          next(LS);
          if (LS->current != '-')
            return '-';
          /* else is a comment */
          next(LS);
          if (LS->current == '[' && (next(LS), LS->current == '['))
            read_long_string(LS, NULL);
           /* long comment */
          else
           /* short comment */
            while (LS->current != '/n' && LS->current != EOZ)
              next(LS);
          continue;
        }
      case '[':
        {
          next(LS);
          if (LS->current != '[')
            return '[';
          else
          {
            read_long_string(LS, seminfo);
            return TK_STRING;
          }
        }
      case '=':
        {
          next(LS);
          if (LS->current != '=')
            return '=';
          else
          {
            next(LS);
            return TK_EQ;
          }
        }
      case '<':
        {
          next(LS);
          if (LS->current != '=')
            return '<';
          else
          {
            next(LS);
            return TK_LE;
          }
        }
      case '>':
        {
          next(LS);
          if (LS->current != '=')
            return '>';
          else
          {
            next(LS);
            return TK_GE;
          }
        }
      case '~':
        {
          next(LS);
          if (LS->current != '=')
            return '~';
          else
          {
            next(LS);
            return TK_NE;
          }
        }
      case '"':
      case '/'':
        {
          read_string(LS, LS->current, seminfo);
          return TK_STRING;
        }
      case '.':
        {
          next(LS);
          if (LS->current == '.')
          {
            next(LS);
            if (LS->current == '.')
            {
              next(LS);
              return TK_DOTS; /* ... */
            }
            else
              return TK_CONCAT;
             /* .. */
          }
          else if (!isdigit(LS->current))
            return '.';
          else
          {
            read_numeral(LS, 1, seminfo);
            return TK_NUMBER;
          }
        }
      case EOZ:
        {
          return TK_EOS;
        }
      default:
        {
          if (isspace(LS->current))
          {
            next(LS);
            continue;
          }
          else if (isdigit(LS->current))
          {
            read_numeral(LS, 0, seminfo);
            return TK_NUMBER;
          }
          /*修改这里支持中英文变量名*/
          else if (isalpha(LS->current) || LS->current == '_' || isChineseCode
            (LS->current))
          {
            /* identifier or reserved word */
            size_t l = readChinesename(LS);
            TString *ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff), l);
            if (ts->tsv.reserved > 0)
             /* reserved word? */
              return ts->tsv.reserved - 1+FIRST_RESERVED;
            seminfo->ts = ts;
            return TK_NAME;
          }
          else
          {
            int c = LS->current;
            if (iscntrl(c))
              luaX_error(LS, "invalid control char", luaO_pushfstring(LS->L,
                "char(%d)", c));
            next(LS);
            return c; /* single-char tokens (+ - / ...) */
          }
        }
    }
  }
}

#undef next

找到处理变量名的地方，共两处，一处是当一些关键符号处理完毕怎么开始处理变量名，就是luaX_lex函数末尾的地方；一处是如何处理变量名，原本使用函数readname处理。
分别改为自定义的代码。好了就这样。
重新编译，生成的Lua.exe或者其他的东西，都可以支持中文变量名了。
随便写一个：test.lua
我=1
你=2
他=3
all我们haha=4
object={};
object.人="人类";
function 显示(some)
print("一切正常！"..some)
end
print(object.人);
print(你..我..他..all我们haha);
显示(我);
执行lua test.lua就知道好用了。
gddsky
关注
专栏目录
修改源代码，让Lua支持中文,中英混合变量名
suxiaojack的专栏
05-24 8851
/*** 作者：苏晓  时间：2006年5月24日** 若有转载请注明出处，谢谢！*/Lua脚本的执行效率是相当高的，源文件用纯C写成相当小巧，其可扩展性相当强，前途一片光明。其源文件写得不复杂，相当值得一读。作为中国人，在编程语言的使用上如果能够使用中文作为变量名是非常好的一件事。但是标准的Lua并不支持中文变量名。虽然可以在字符串中处理中文。其实只要修改少量代码就可以让Lua支持中文变量名。
修改 Lua支持中文变量名
weixin_34247299的博客
02-12 398
1. 找到 LuaPlus 工程下的 Lua Source Files 下的 llex.c； 2. 在该文件中找到下面所列函数； static int llex (LexState *ls, SemInfo *seminfo) 3. 这是 Lua 的语法分析模块的关键函数，它由一长段 switch 构成，在一串 case 后找到 default 分支 4. 在...
Lua中文语言编程源码-第三节，更改lualib.h Lua标准库, 使Lua支持中文关键词（与所有的基础库相关）
最新发布
funsion的专栏
03-15 632
Lua标准库一共有有个10个库，base, 基本用不着改，所以没加中文名称。 另外的9个库分别是：协程，表，端口，系统，字，UTF-8，数，调试，包。
lua-5.3.4_x86_x64(支持中文变量)
04-12
运行库 多线程/MT编译! x86和x64版本的DLL和Lib都已经编译好的! 已经改好中文变量
C# lua库 支持中文函数名中文变量
12-05
总结，C#结合lua 5.1库，通过LuaInterface实现的中文函数名和变量名支持，使得C#与Lua的交互更加直观和方便，尤其适用于中文开发环境。在实际应用中，应充分理解这一特性的优势，同时注意解决可能出现的编码问题，以...
lua5.1:lua 5.1源代码-lua source code
03-25
在本文中，我们将深入探讨Lua 5.1的源代码，解析其设计思想、核心结构以及实现机制。 首先，我们要了解Lua的核心特性：简洁、高效和可扩展性。Lua 5.1的源代码结构清晰，易于阅读和理解，这使得开发者能够快速掌握...
bstree:Lua 源代码混淆器
06-09
bstree是 Lua 源代码混淆器。 它分析源代码中的 Lua 文件并输出编码器和解码器。 BS 代表 Bit Stream 或 Bull Shit，取决于你的心情。 用法 $ lua bstree.lua <input.lua>+ 此命令将分析所有给定的 Lua 文件...
lua学习笔记（2）让lua解释器支持中文变量和函数名 以及 重新让 解释器接受中文的关键字
jeason的博客
12-12 3326
今天再看lua 的解释器，突然想到我们的FAE 一直说要支持 脚本里面直接输入中文，于是我就去搜索了一下相关的实现流程，并且去简单的进行了一下操作。 代码位置 https://gitee.com/jeasonb/lua5.4.3_cn.git 0 获得 lua的源码 wget http://www.lua.org/ftp/lua-5.4.3.tar.gz root@jeason:~/lua/lua_cn# wget http://www.lua.org/ftp/lua-5.4.3.tar.gz --20
支持中文函数和变量的Lua 5. 3. 2源码
11-17
支持中文函数和变量的Lua 5. 3. 2源码，直接可以用VS编译成静态或动态库~~~
lua支持中文变量名，
11-25
Lua 是一个小巧的脚本语言。作者是巴西人。该语言的设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。 版本：5.1.4 内有 1、修改源文件的方法 2、Delphi的一个封装类 3、编译方法 4、编译好的Dll
支持中文变量的lua
12-24
大名鼎鼎的lua，魔兽世界等各种网游广泛使用的脚本语言，这个压缩包是我修改好的支持中文变量名的版本，因为vs2008里面的代码，偶尔会用到中文的变量名，所以有了这个版本，兼容性会更好，省得大批量的修改以往的代码。
Lua5.3.5支持库(支持中文)-易语言
06-13
封装lua脚本，实现程序和脚本交互。 操作系统支持： Windows 1、支持中文（中文函数名等） 2、全部回调函数改成了stdcall，也就是易语言 使用的调用协yi。 3、命令全部也是中文（这点我不知道好不好） 原帖地址：https://bbs.125.la/thread-14232713-1-1.html
LUA5.4动态链接库，支持中文函数，适用于Nlua
11-22
LUA5.4动态链接库，支持中文函数，适用于Nlua,亲测可行。lua5.4相对于之前的版本，有了重大的改进，资源包括x86 x64两个版本，自行选择使用
lua 5.2.4 支持中文变量的修改
weixin_54887961的博客
03-10 817
本文的环境是建立在 Windows 环境下的 vs2017 中的，安装完成之后的 lua 是不支持中文变量，如果想修改成支持中文变量的，得修改源码。 修改之前的代码： default: { if (lislalpha(ls->current) ) { /* identifier or reserved word? *///支持中文 TString *ts; do { save_and...
lua支持中文变量名
qq_34995813的博客
10-30 1110
默认的LUA不支持中文变量名. 少量修改源代码即可 修改如下:   在lua\src\llex.c中 修改420行-432行内容   原内容     1 else if (isalpha(ls->current) || ls->current == '_') { 2 /* identifier or reserved word *
lua支持中文--改法修正
kugoo11v12的专栏
09-16 2344
看到网上各种转载修改源码使lua支持中文的，结果试了下发现测试出来有问题，如： >function 为而的() end stdin:1: '(' expected near ')' 这里就会报错，只好改下，就没问题了，如下改后的源码（改动之处已标明）。 #pragma once #include //////////////////////////
LUA5.3.3如何支持中文函数？？
01-19 2850
方法一. /*中文支持 llex.c static int llex (LexState *ls, SemInfo *seminfo) 修改如下： */ default: { if (lislalpha(ls-&gt;current) || ls-&gt;current == '_' || ls-&gt;current &gt; 0x80) { /* identi...
【小技巧】如何修改 Lua 5.1 的引擎，让Lua支持中文变量名、混合变量名
chrisxie的专栏
09-29 6576
最近在倒腾 Lua 脚本引擎。Lua 现在广泛用于各种游戏、PSP中，速度极快，与 C++ 宿主代码“相处”能力强，还有第三方增强工程如 LuaPlus， LuaBind 等的支持，笔者正是在使用 LuaPlus 这个不错的 Lua C++ 封装，内置 Lua 5.1 引擎。Lua 本身不能支持中文变量名或函数名，作为想尽善尽美的支持脚本的软件来说，当然不爽啦。从网上搜到了一些代码，能够修改老版本
Lua源代码分析指南
"Lua源代码分析顺序" 在深入学习Lua源代码时，有一个推荐的阅读顺序可以帮助你更好地理解和掌握这个轻量级的脚本语言。以下是对这些关键文件的详细解释： 1. `lmathlib.c` 和 `lstrlib.c`: 这两个文件包含了Lua的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值