lua5.1.4编译器相关

最近要写段代码把lua相关代码编译为.luac,最初使用ShellExecute()调用命令行luac -o ,后来,自己先加上了C++可以调用脚本的接口,于是就在lua脚本里写了编译相关的代码,大概这样

os.excute("luac -o" .. file .."c " file )

不过还是使用系统调用,效率太低,好吧,看看luac怎么实现的,然后自己封装个接口,直接调用接口编译。
luac.c就是lua编译器相关接口,先简单分析一下

代码写的比较简洁的,这也是经过一次次封装之后的结果,如果看过之前版本的luac.c就能看出变化,并且目前最新版本的5.3.2又进行了进一步封装(5.3.2的大概看了一下,还没仔细分析)
主函数比较短,代码如下

int main(int argc, char* argv[])
{
 lua_State* L;
 struct Smain s;
 int i=doargs(argc,argv);
 argc-=i; argv+=i;
 if (argc<=0) usage("no input files given");
 L=lua_open();
 if (L==NULL) fatal("not enough memory for state");
 s.argc=argc;
 s.argv=argv;
 if (lua_cpcall(L,pmain,&s)!=0) fatal(lua_tostring(L,-1));
 lua_close(L);
 return EXIT_SUCCESS;
}

主函数首先调用int i=doargs(argc,argv);处理相关参数,然后调用pmain,先说static int doargs(int argc, char* argv[]),也就是平时编译时用的luac [-o|-p|-l] 等等,具体参数的意义,可以在另一个函数static void usage(const char* message)中看到,

#define    IS(s)    (strcmp(argv[i],s)==0)

static int doargs(int argc, char* argv[])
{
 int i;
 int version=0;
 if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0];
 for (i=1; i<argc; i++)
 {
  if (*argv[i]!='-')            /* end of options; keep it */
   break;
  else if (IS("--"))            /* end of options; skip it */
  {
   ++i;
   if (version) ++version;
   break;
  }
  else if (IS("-"))            /* end of options; use stdin */
   break;
  else if (IS("-l"))            /* list */
   ++listing;
  else if (IS("-o"))            /* output file */
  {
   output=argv[++i];
   if (output==NULL || *output==0) usage(LUA_QL("-o") " needs argument");
   if (IS("-")) output=NULL;
  }
  else if (IS("-p"))            /* parse only */
   dumping=0;
  else if (IS("-s"))            /* strip debug information */
   stripping=1;
  else if (IS("-v"))            /* show version */
   ++version;
  else                    /* unknown option */
   usage(argv[i]);
 }
 if (i==argc && (listing || !dumping))
 {
  dumping=0;
  argv[--i]=Output;
 }
 if (version)
 {
  printf("%s  %s\n",LUA_RELEASE,LUA_COPYRIGHT);
  if (version==argc-1) exit(EXIT_SUCCESS);
 }
 return i;
}
各个参数的具体含义,其中progname即是要编译出的二进制名字,默认定义为luac.out
static void usage(const char* message)
{
 if (*message=='-')
  fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message);
 else
  fprintf(stderr,"%s: %s\n",progname,message);
 fprintf(stderr,
 "usage: %s [options] [filenames].\n"
 "Available options are:\n"
 "  -        process stdin\n"
 "  -l       list\n"
 "  -o name  output to file " LUA_QL("name") " (default is \"%s\")\n"
 "  -p       parse only\n"
 "  -s       strip debug information\n"
 "  -v       show version information\n"
 "  --       stop handling options\n",
 progname,Output);
 exit(EXIT_FAILURE);
}
具体执行编译的函数
static int pmain(lua_State* L)
{
 struct Smain* s = (struct Smain*)lua_touserdata(L, 1);
 int argc=s->argc;
 char** argv=s->argv;
 const Proto* f;
 int i;
 if (!lua_checkstack(L,argc)) fatal("too many input files");
 for (i=0; i<argc; i++)
 {
  const char* filename=IS("-") ? NULL : argv[i];
  if (luaL_loadfile(L,filename)!=0) fatal(lua_tostring(L,-1));
 }
 f=combine(L,argc);
 if (listing) luaU_print(f,listing>1);
 if (dumping)
 {
  FILE* D= (output==NULL) ? stdout : fopen(output,"wb");
  if (D==NULL) cannot("open");
  lua_lock(L);
  luaU_dump(L,f,writer,D,stripping);
  lua_unlock(L);
  if (ferror(D)) cannot("write");
  if (fclose(D)) cannot("close");
 }
 return 0;
}

先检查参数是否合法,然后for循环逐个处理文件,调用luaL_loadfile编译文件,并捕获错误,然后f = combine(L,argc);将会combine所有的Proto,并将每个lua文件保存为一个Proto,

static const Proto* combine(lua_State* L, int n)
{
 if (n==1)
  return toproto(L,-1);
 else
 {
  int i,pc;
  Proto* f=luaF_newproto(L);
  setptvalue2s(L,L->top,f); incr_top(L);
  f->source=luaS_newliteral(L,"=(" PROGNAME ")");
  f->maxstacksize=1;
  pc=2*n+1;
  f->code=luaM_newvector(L,pc,Instruction);
  f->sizecode=pc;
  f->p=luaM_newvector(L,n,Proto*);
  f->sizep=n;
  pc=0;
  for (i=0; i<n; i++)
  {
   f->p[i]=toproto(L,i-n-1);
   f->code[pc++]=CREATE_ABx(OP_CLOSURE,0,i);
   f->code[pc++]=CREATE_ABC(OP_CALL,0,1,1);
  }
  f->code[pc++]=CREATE_ABC(OP_RETURN,0,1,0);
  return f;
 }
}

最后pmain检查是否需要listing和dumping(保存输出字节码), 如果需要dumping,则调用writer,保存字节码

static int writer(lua_State* L, const void* p, size_t size, void* u)
{
 UNUSED(L);
 return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0);
}
还有一些宏定义和简单的错误处理函数
#define PROGNAME    "luac"        /* default program name */
#define    OUTPUT        PROGNAME ".out"    /* default output file */

static int listing=0;            /* list bytecodes? */
static int dumping=1;            /* dump bytecodes? */
static int stripping=0;            /* strip debug information? */
static char Output[]={ OUTPUT };    /* default output file name */
static const char* output=Output;    /* actual output file name */
static const char* progname=PROGNAME;    /* actual program name */

static void fatal(const char* message)
{
 fprintf(stderr,"%s: %s\n",progname,message);
 exit(EXIT_FAILURE);
}

static void cannot(const char* what)
{
 fprintf(stderr,"%s: cannot %s %s: %s\n",progname,what,output,strerror(errno));
 exit(EXIT_FAILURE);
}

先写到这里吧,对了,还有自己根据这个简单修改的的直接编译文件的接口,其实就是简单改了一下代码

static std::string compile_lua(char const* filename,char const *outfilename=NULL)
{
 lua_State* L;
 std::string errer_msg = "";
 L = lua_open();
 if(outfilename) output = outname;
 if(L == NULL)
 {
     return ERROR_MSG;
 }
 if(luaL_loadfile(L,filename)!= 0)
 {
     return lua_tostring(L,-1);
 }
 const Proto* f = toproto(L, -1);
 FILE* D= (output==NULL) 
 if(D == NULL) 
 {
     error_msg += strerror(errno);
    return error_msg;
 }
 lua_lock(L);
 luaU_dump(L,f,writer,D,stripping);
 lua_unlock(L);
 if (ferror(D)) return ERROR_MSG;
 if (fclose(D)) return ERROR_MSG;
 lua_close(L);
 return msg;
}

上面函数用到了ERROR_MSG,是自己定义的一个错误字符,可以使用strerror(errno)具体错误信息,至于为什么要返回std::string 是因为,这个函数是本来用来注册给lua脚本的,需要在脚本里处理错误信息,就先这么写了。

先这样,等以后想起来再补充吧