FilesExpand file tree

master

/

lparser.h

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

197 lines (167 loc) · 6.95 KB

master

/

lparser.h

Copy path

Top

File metadata and controls

• Code
• Blame

197 lines (167 loc) · 6.95 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

/*

** $Id: lparser.h $

** Lua Parser

** See Copyright Notice in lua.h

*/

#ifndef lparser_h

#define lparser_h

#include "llimits.h"

#include "lobject.h"

#include "lzio.h"

/*

** Expression and variable descriptor.

** Code generation for variables and expressions can be delayed to allow

** optimizations; An 'expdesc' structure describes a potentially-delayed

** variable/expression. It has a description of its "main" value plus a

** list of conditional jumps that can also produce its value (generated

** by short-circuit operators 'and'/'or').

*/

/* kinds of variables/expressions */

typedef enum {

VVOID, /* when 'expdesc' describes the last expression of a list,

this kind means an empty list (so, no expression) */

VNIL, /* constant nil */

VTRUE, /* constant true */

VFALSE, /* constant false */

VK, /* constant in 'k'; info = index of constant in 'k' */

VKFLT, /* floating constant; nval = numerical float value */

VKINT, /* integer constant; ival = numerical integer value */

VKSTR, /* string constant; strval = TString address;

(string is fixed by the scanner) */

VNONRELOC, /* expression has its value in a fixed register;

info = result register */

VLOCAL, /* local variable; var.ridx = register index;

var.vidx = relative index in 'actvar.arr' */

VVARGVAR, /* vararg parameter; var.ridx = register index;

var.vidx = relative index in 'actvar.arr' */

VGLOBAL, /* global variable;

info = relative index in 'actvar.arr' (or -1 for

implicit declaration) */

VUPVAL, /* upvalue variable; info = index of upvalue in 'upvalues' */

VCONST, /* compile-time <const> variable;

info = absolute index in 'actvar.arr' */

VINDEXED, /* indexed variable;

ind.t = table register;

ind.idx = key's R index;

ind.ro = true if it represents a read-only global;

ind.keystr = if key is a string, index in 'k' of that string;

-1 if key is not a string */

VVARGIND, /* indexed vararg parameter;

ind.* as in VINDEXED */

VINDEXUP, /* indexed upvalue;

ind.idx = key's K index;

ind.* as in VINDEXED */

VINDEXI, /* indexed variable with constant integer;

ind.t = table register;

ind.idx = key's value */

VINDEXSTR, /* indexed variable with literal string;

ind.idx = key's K index;

ind.* as in VINDEXED */

VJMP, /* expression is a test/comparison;

info = pc of corresponding jump instruction */

VRELOC, /* expression can put result in any register;

info = instruction pc */

VCALL, /* expression is a function call; info = instruction pc */

VVARARG /* vararg expression; info = instruction pc */

} expkind;

#define vkisvar(k) (VLOCAL <= (k) && (k) <= VINDEXSTR)

#define vkisindexed(k) (VINDEXED <= (k) && (k) <= VINDEXSTR)

typedef struct expdesc {

expkind k;

union {

lua_Integer ival; /* for VKINT */

lua_Number nval; /* for VKFLT */

TString *strval; /* for VKSTR */

int info; /* for generic use */

struct { /* for indexed variables */

short idx; /* index (R or "long" K) */

lu_byte t; /* table (register or upvalue) */

lu_byte ro; /* true if variable is read-only */

int keystr; /* index in 'k' of string key, or -1 if not a string */

} ind;

struct { /* for local variables */

lu_byte ridx; /* register holding the variable */

short vidx; /* index in 'actvar.arr' */

} var;

} u;

int t; /* patch list of 'exit when true' */

int f; /* patch list of 'exit when false' */

} expdesc;

/* kinds of variables */

#define VDKREG 0 /* regular local */

#define RDKCONST 1 /* local constant */

#define RDKVAVAR 2 /* vararg parameter */

#define RDKTOCLOSE 3 /* to-be-closed */

#define RDKCTC 4 /* local compile-time constant */

#define GDKREG 5 /* regular global */

#define GDKCONST 6 /* global constant */

/* variables that live in registers */

#define varinreg(v) ((v)->vd.kind <= RDKTOCLOSE)

/* test for global variables */

#define varglobal(v) ((v)->vd.kind >= GDKREG)

/* description of an active variable */

typedef union Vardesc {

struct {

TValuefields; /* constant value (if it is a compile-time constant) */

lu_byte kind;

lu_byte ridx; /* register holding the variable */

short pidx; /* index of the variable in the Proto's 'locvars' array */

TString *name; /* variable name */

} vd;

TValue k; /* constant value (if any) */

} Vardesc;

/* description of pending goto statements and label statements */

typedef struct Labeldesc {

TString *name; /* label identifier */

int pc; /* position in code */

int line; /* line where it appeared */

short nactvar; /* number of active variables in that position */

lu_byte close; /* true for goto that escapes upvalues */

} Labeldesc;

/* list of labels or gotos */

typedef struct Labellist {

Labeldesc *arr; /* array */

int n; /* number of entries in use */

int size; /* array size */

} Labellist;

/* dynamic structures used by the parser */

typedef struct Dyndata {

struct { /* list of all active local variables */

Vardesc *arr;

int n;

int size;

} actvar;

Labellist gt; /* list of pending gotos */

Labellist label; /* list of active labels */

} Dyndata;

/* control of blocks */

struct BlockCnt; /* defined in lparser.c */

/* state needed to generate code for a given function */

typedef struct FuncState {

Proto *f; /* current function header */

struct FuncState *prev; /* enclosing function */

struct LexState *ls; /* lexical state */

struct BlockCnt *bl; /* chain of current blocks */

Table *kcache; /* cache for reusing constants */

int pc; /* next position to code (equivalent to 'ncode') */

int lasttarget; /* 'label' of last 'jump label' */

int previousline; /* last line that was saved in 'lineinfo' */

int nk; /* number of elements in 'k' */

int np; /* number of elements in 'p' */

int nabslineinfo; /* number of elements in 'abslineinfo' */

int firstlocal; /* index of first local var (in Dyndata array) */

int firstlabel; /* index of first label (in 'dyd->label->arr') */

short ndebugvars; /* number of elements in 'f->locvars' */

short nactvar; /* number of active variable declarations */

lu_byte nups; /* number of upvalues */

lu_byte freereg; /* first free register */

lu_byte iwthabs; /* instructions issued since last absolute line info */

lu_byte needclose; /* function needs to close upvalues when returning */

} FuncState;

LUAI_FUNC lu_byte luaY_nvarstack (FuncState *fs);

LUAI_FUNC void luaY_checklimit (FuncState *fs, int v, int l,

const char *what);

LUAI_FUNC LClosure *luaY_parser (lua_State *L, ZIO *z, Table *anchor,

Mbuffer *buff, Dyndata *dyd,

const char *name, int firstchar);

#endif