LCOV - code coverage report
Current view: top level - src - luac.c Hit Total Coverage
Test: Lua 5.1.5 Lines: 49 93 52.7 %
Date: 2017-04-16 16:03:13
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             : ** $Id: luac.c,v 1.54 2006/06/02 17:37:11 lhf Exp $
       3             : ** Lua compiler (saves bytecodes to files; also list bytecodes)
       4             : ** See Copyright Notice in lua.h
       5             : */
       6             : 
       7             : #include <errno.h>
       8             : #include <stdio.h>
       9             : #include <stdlib.h>
      10             : #include <string.h>
      11             : 
      12             : #define luac_c
      13             : #define LUA_CORE
      14             : 
      15             : #include "lua.h"
      16             : #include "lauxlib.h"
      17             : 
      18             : #include "ldo.h"
      19             : #include "lfunc.h"
      20             : #include "lmem.h"
      21             : #include "lobject.h"
      22             : #include "lopcodes.h"
      23             : #include "lstring.h"
      24             : #include "lundump.h"
      25             : 
      26             : #define PROGNAME        "luac"                /* default program name */
      27             : #define OUTPUT          PROGNAME ".out"       /* default output file */
      28             : 
      29             : static int listing=0;                   /* list bytecodes? */
      30             : static int dumping=1;                   /* dump bytecodes? */
      31             : static int stripping=0;                 /* strip debug information? */
      32             : static char Output[]={ OUTPUT };        /* default output file name */
      33             : static const char* output=Output;       /* actual output file name */
      34             : static const char* progname=PROGNAME;   /* actual program name */
      35             : 
      36           0 : static void fatal(const char* message)
      37             : {
      38           0 :  fprintf(stderr,"%s: %s\n",progname,message);
      39           0 :  exit(EXIT_FAILURE);
      40             : }
      41             : 
      42           0 : static void cannot(const char* what)
      43             : {
      44           0 :  fprintf(stderr,"%s: cannot %s %s: %s\n",progname,what,output,strerror(errno));
      45           0 :  exit(EXIT_FAILURE);
      46             : }
      47             : 
      48           0 : static void usage(const char* message)
      49             : {
      50           0 :  if (*message=='-')
      51           0 :   fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message);
      52             :  else
      53           0 :   fprintf(stderr,"%s: %s\n",progname,message);
      54           0 :  fprintf(stderr,
      55             :  "usage: %s [options] [filenames].\n"
      56             :  "Available options are:\n"
      57             :  "  -        process stdin\n"
      58             :  "  -l       list\n"
      59             :  "  -o name  output to file " LUA_QL("name") " (default is \"%s\")\n"
      60             :  "  -p       parse only\n"
      61             :  "  -s       strip debug information\n"
      62             :  "  -v       show version information\n"
      63             :  "  --       stop handling options\n",
      64             :  progname,Output);
      65           0 :  exit(EXIT_FAILURE);
      66             : }
      67             : 
      68             : #define IS(s)   (strcmp(argv[i],s)==0)
      69             : 
      70           1 : static int doargs(int argc, char* argv[])
      71             : {
      72             :  int i;
      73           1 :  int version=0;
      74           1 :  if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0];
      75           2 :  for (i=1; i<argc; i++)
      76             :  {
      77           2 :   if (*argv[i]!='-')                    /* end of options; keep it */
      78           1 :    break;
      79           1 :   else if (IS("--"))                  /* end of options; skip it */
      80             :   {
      81           0 :    ++i;
      82           0 :    if (version) ++version;
      83           0 :    break;
      84             :   }
      85           1 :   else if (IS("-"))                   /* end of options; use stdin */
      86           0 :    break;
      87           1 :   else if (IS("-l"))                  /* list */
      88           0 :    ++listing;
      89           1 :   else if (IS("-o"))                  /* output file */
      90             :   {
      91           1 :    output=argv[++i];
      92           1 :    if (output==NULL || *output==0) usage(LUA_QL("-o") " needs argument");
      93           1 :    if (IS("-")) output=NULL;
      94             :   }
      95           0 :   else if (IS("-p"))                  /* parse only */
      96           0 :    dumping=0;
      97           0 :   else if (IS("-s"))                  /* strip debug information */
      98           0 :    stripping=1;
      99           0 :   else if (IS("-v"))                  /* show version */
     100           0 :    ++version;
     101             :   else                                  /* unknown option */
     102           0 :    usage(argv[i]);
     103             :  }
     104           1 :  if (i==argc && (listing || !dumping))
     105             :  {
     106           0 :   dumping=0;
     107           0 :   argv[--i]=Output;
     108             :  }
     109           1 :  if (version)
     110             :  {
     111           0 :   printf("%s  %s\n",LUA_RELEASE,LUA_COPYRIGHT);
     112           0 :   if (version==argc-1) exit(EXIT_SUCCESS);
     113             :  }
     114           1 :  return i;
     115             : }
     116             : 
     117             : #define toproto(L,i) (clvalue(L->top+(i))->l.p)
     118             : 
     119           1 : static const Proto* combine(lua_State* L, int n)
     120             : {
     121           1 :  if (n==1)
     122           1 :   return toproto(L,-1);
     123             :  else
     124             :  {
     125             :   int i,pc;
     126           0 :   Proto* f=luaF_newproto(L);
     127           0 :   setptvalue2s(L,L->top,f); incr_top(L);
     128           0 :   f->source=luaS_newliteral(L,"=(" PROGNAME ")");
     129           0 :   f->maxstacksize=1;
     130           0 :   pc=2*n+1;
     131           0 :   f->code=luaM_newvector(L,pc,Instruction);
     132           0 :   f->sizecode=pc;
     133           0 :   f->p=luaM_newvector(L,n,Proto*);
     134           0 :   f->sizep=n;
     135           0 :   pc=0;
     136           0 :   for (i=0; i<n; i++)
     137             :   {
     138           0 :    f->p[i]=toproto(L,i-n-1);
     139           0 :    f->code[pc++]=CREATE_ABx(OP_CLOSURE,0,i);
     140           0 :    f->code[pc++]=CREATE_ABC(OP_CALL,0,1,1);
     141             :   }
     142           0 :   f->code[pc++]=CREATE_ABC(OP_RETURN,0,1,0);
     143           0 :   return f;
     144             :  }
     145             : }
     146             : 
     147          23 : static int writer(lua_State* L, const void* p, size_t size, void* u)
     148             : {
     149             :  UNUSED(L);
     150          23 :  return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0);
     151             : }
     152             : 
     153             : struct Smain {
     154             :  int argc;
     155             :  char** argv;
     156             : };
     157             : 
     158           1 : static int pmain(lua_State* L)
     159             : {
     160           1 :  struct Smain* s = (struct Smain*)lua_touserdata(L, 1);
     161           1 :  int argc=s->argc;
     162           1 :  char** argv=s->argv;
     163             :  const Proto* f;
     164             :  int i;
     165           1 :  if (!lua_checkstack(L,argc)) fatal("too many input files");
     166           2 :  for (i=0; i<argc; i++)
     167             :  {
     168           1 :   const char* filename=IS("-") ? NULL : argv[i];
     169           1 :   if (luaL_loadfile(L,filename)!=0) fatal(lua_tostring(L,-1));
     170             :  }
     171           1 :  f=combine(L,argc);
     172           1 :  if (listing) luaU_print(f,listing>1);
     173           1 :  if (dumping)
     174             :  {
     175           1 :   FILE* D= (output==NULL) ? stdout : fopen(output,"wb");
     176           1 :   if (D==NULL) cannot("open");
     177             :   lua_lock(L);
     178           1 :   luaU_dump(L,f,writer,D,stripping);
     179             :   lua_unlock(L);
     180           1 :   if (ferror(D)) cannot("write");
     181           1 :   if (fclose(D)) cannot("close");
     182             :  }
     183           1 :  return 0;
     184             : }
     185             : 
     186           1 : int main(int argc, char* argv[])
     187             : {
     188             :  lua_State* L;
     189             :  struct Smain s;
     190           1 :  int i=doargs(argc,argv);
     191           1 :  argc-=i; argv+=i;
     192           1 :  if (argc<=0) usage("no input files given");
     193           1 :  L=lua_open();
     194           1 :  if (L==NULL) fatal("not enough memory for state");
     195           1 :  s.argc=argc;
     196           1 :  s.argv=argv;
     197           1 :  if (lua_cpcall(L,pmain,&s)!=0) fatal(lua_tostring(L,-1));
     198           1 :  lua_close(L);
     199           1 :  return EXIT_SUCCESS;
     200             : }

Generated by: LCOV version 1.13