CHDK_DE Vorschauversion  Trunk Rev. 6014
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
Datenstrukturen | Makrodefinitionen | Funktionen
lundump.c-Dateireferenz
#include <string.h>
#include "lua.h"
#include "ldebug.h"
#include "ldo.h"
#include "lfunc.h"
#include "lmem.h"
#include "lobject.h"
#include "lstring.h"
#include "lundump.h"
#include "lzio.h"
+ Include-Abhängigkeitsdiagramm für lundump.c:

gehe zum Quellcode dieser Datei

Datenstrukturen

struct  LoadState
 

Makrodefinitionen

#define lundump_c
 
#define LUA_CORE
 
#define IF(c, s)   if (c) error(S,s)
 
#define LoadMem(S, b, n, size)   LoadBlock(S,b,(n)*(size))
 
#define LoadByte(S)   (lu_byte)LoadChar(S)
 
#define LoadVar(S, x)   LoadMem(S,&x,1,sizeof(x))
 
#define LoadVector(S, b, n, size)   LoadMem(S,b,n,size)
 

Funktionen

static void error (LoadState *S, const char *why)
 
static void LoadBlock (LoadState *S, void *b, size_t size)
 
static int LoadChar (LoadState *S)
 
static int LoadInt (LoadState *S)
 
static lua_Number LoadNumber (LoadState *S)
 
static TString * LoadString (LoadState *S)
 
static void LoadCode (LoadState *S, Proto *f)
 
static Proto * LoadFunction (LoadState *S, TString *p)
 
static void LoadConstants (LoadState *S, Proto *f)
 
static void LoadDebug (LoadState *S, Proto *f)
 
static void LoadHeader (LoadState *S)
 
LUAI_FUNC Proto * luaU_undump (lua_State *L, ZIO *Z, Mbuffer *buff, const char *name)
 
LUAI_FUNC void luaU_header (char *h)
 

Makro-Dokumentation

#define IF (   c,
  s 
)    if (c) error(S,s)

Definiert in Zeile 34 der Datei lundump.c.

#define LoadByte (   S)    (lu_byte)LoadChar(S)

Definiert in Zeile 44 der Datei lundump.c.

#define LoadMem (   S,
  b,
  n,
  size 
)    LoadBlock(S,b,(n)*(size))

Definiert in Zeile 43 der Datei lundump.c.

#define LoadVar (   S,
  x 
)    LoadMem(S,&x,1,sizeof(x))

Definiert in Zeile 45 der Datei lundump.c.

#define LoadVector (   S,
  b,
  n,
  size 
)    LoadMem(S,b,n,size)

Definiert in Zeile 46 der Datei lundump.c.

#define LUA_CORE

Definiert in Zeile 10 der Datei lundump.c.

#define lundump_c

Definiert in Zeile 9 der Datei lundump.c.

Dokumentation der Funktionen

static void error ( LoadState *  S,
const char *  why 
)
static

Definiert in Zeile 36 der Datei lundump.c.

37 {
38  luaO_pushfstring(S->L,"%s: %s in precompiled chunk",S->name,why);
39  luaD_throw(S->L,LUA_ERRSYNTAX);
40 }
static void LoadBlock ( LoadState *  S,
void *  b,
size_t  size 
)
static

Definiert in Zeile 48 der Datei lundump.c.

49 {
50  size_t r=luaZ_read(S->Z,b,size);
51  IF (r!=0, "unexpected end");
52 }
static int LoadChar ( LoadState *  S)
static

Definiert in Zeile 54 der Datei lundump.c.

55 {
56  char x;
57  LoadVar(S,x);
58  return x;
59 }
static void LoadCode ( LoadState *  S,
Proto *  f 
)
static

Definiert in Zeile 90 der Datei lundump.c.

91 {
92  int n=LoadInt(S);
93  f->code=luaM_newvector(S->L,n,Instruction);
94  f->sizecode=n;
95  LoadVector(S,f->code,n,sizeof(Instruction));
96 }
static void LoadConstants ( LoadState *  S,
Proto *  f 
)
static

Definiert in Zeile 100 der Datei lundump.c.

101 {
102  int i,n;
103  n=LoadInt(S);
104  f->k=luaM_newvector(S->L,n,TValue);
105  f->sizek=n;
106  for (i=0; i<n; i++) setnilvalue(&f->k[i]);
107  for (i=0; i<n; i++)
108  {
109  TValue* o=&f->k[i];
110  int t=LoadChar(S);
111  switch (t)
112  {
113  case LUA_TNIL:
114  setnilvalue(o);
115  break;
116  case LUA_TBOOLEAN:
117  setbvalue(o,LoadChar(S)!=0);
118  break;
119  case LUA_TNUMBER:
120  setnvalue(o,LoadNumber(S));
121  break;
122  case LUA_TSTRING:
123  setsvalue2n(S->L,o,LoadString(S));
124  break;
125  default:
126  error(S,"bad constant");
127  break;
128  }
129  }
130  n=LoadInt(S);
131  f->p=luaM_newvector(S->L,n,Proto*);
132  f->sizep=n;
133  for (i=0; i<n; i++) f->p[i]=NULL;
134  for (i=0; i<n; i++) f->p[i]=LoadFunction(S,f->source);
135 }
static void LoadDebug ( LoadState *  S,
Proto *  f 
)
static

Definiert in Zeile 137 der Datei lundump.c.

138 {
139  int i,n;
140  n=LoadInt(S);
141  f->lineinfo=luaM_newvector(S->L,n,int);
142  f->sizelineinfo=n;
143  LoadVector(S,f->lineinfo,n,sizeof(int));
144  n=LoadInt(S);
145  f->locvars=luaM_newvector(S->L,n,LocVar);
146  f->sizelocvars=n;
147  for (i=0; i<n; i++) f->locvars[i].varname=NULL;
148  for (i=0; i<n; i++)
149  {
150  f->locvars[i].varname=LoadString(S);
151  f->locvars[i].startpc=LoadInt(S);
152  f->locvars[i].endpc=LoadInt(S);
153  }
154  n=LoadInt(S);
155  f->upvalues=luaM_newvector(S->L,n,TString*);
156  f->sizeupvalues=n;
157  for (i=0; i<n; i++) f->upvalues[i]=NULL;
158  for (i=0; i<n; i++) f->upvalues[i]=LoadString(S);
159 }
static Proto * LoadFunction ( LoadState *  S,
TString *  p 
)
static

Definiert in Zeile 161 der Datei lundump.c.

162 {
163  Proto* f;
164  if (++S->L->nCcalls > LUAI_MAXCCALLS) error(S,"code too deep");
165  f=luaF_newproto(S->L);
166  setptvalue2s(S->L,S->L->top,f); incr_top(S->L);
167  f->source=LoadString(S); if (f->source==NULL) f->source=p;
168  f->linedefined=LoadInt(S);
169  f->lastlinedefined=LoadInt(S);
170  f->nups=LoadByte(S);
171  f->numparams=LoadByte(S);
172  f->is_vararg=LoadByte(S);
173  f->maxstacksize=LoadByte(S);
174  LoadCode(S,f);
175  LoadConstants(S,f);
176  LoadDebug(S,f);
177  IF (!luaG_checkcode(f), "bad code");
178  S->L->top--;
179  S->L->nCcalls--;
180  return f;
181 }
static void LoadHeader ( LoadState *  S)
static

Definiert in Zeile 183 der Datei lundump.c.

184 {
185  char h[LUAC_HEADERSIZE];
186  char s[LUAC_HEADERSIZE];
187  luaU_header(h);
188  LoadBlock(S,s,LUAC_HEADERSIZE);
189  IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
190 }
static int LoadInt ( LoadState *  S)
static

Definiert in Zeile 61 der Datei lundump.c.

62 {
63  int x;
64  LoadVar(S,x);
65  IF (x<0, "bad integer");
66  return x;
67 }
static lua_Number LoadNumber ( LoadState *  S)
static

Definiert in Zeile 69 der Datei lundump.c.

70 {
71  lua_Number x;
72  LoadVar(S,x);
73  return x;
74 }
static TString* LoadString ( LoadState *  S)
static

Definiert in Zeile 76 der Datei lundump.c.

77 {
78  size_t size;
79  LoadVar(S,size);
80  if (size==0)
81  return NULL;
82  else
83  {
84  char* s=luaZ_openspace(S->L,S->b,size);
85  LoadBlock(S,s,size);
86  return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */
87  }
88 }
LUAI_FUNC void luaU_header ( char *  h)

Definiert in Zeile 214 der Datei lundump.c.

215 {
216  int x=1;
217  memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-1);
218  h+=sizeof(LUA_SIGNATURE)-1;
219  *h++=(char)LUAC_VERSION;
220  *h++=(char)LUAC_FORMAT;
221  *h++=(char)*(char*)&x; /* endianness */
222  *h++=(char)sizeof(int);
223  *h++=(char)sizeof(size_t);
224  *h++=(char)sizeof(Instruction);
225  *h++=(char)sizeof(lua_Number);
226  *h++=(char)(((lua_Number)0.5)==0); /* is lua_Number integral? */
227 }
LUAI_FUNC Proto* luaU_undump ( lua_State *  L,
ZIO *  Z,
Mbuffer *  buff,
const char *  name 
)

Definiert in Zeile 195 der Datei lundump.c.

196 {
197  LoadState S;
198  if (*name=='@' || *name=='=')
199  S.name=name+1;
200  else if (*name==LUA_SIGNATURE[0])
201  S.name="binary string";
202  else
203  S.name=name;
204  S.L=L;
205  S.Z=Z;
206  S.b=buff;
207  LoadHeader(&S);
208  return LoadFunction(&S,luaS_newliteral(L,"=?"));
209 }