aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3
diff options
context:
space:
mode:
Diffstat (limited to 'LuaSL/testLua/yueliang-0.4.1/nat-5.1.3')
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/README55
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/llex_mk2.lua314
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/lparser_mk2.lua1294
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_01.lua9
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_02.lua10
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_03.lua21
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_04.lua31
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_05.lua129
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_06.lua132
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_07.lua147
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_08.lua66
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_09.lua103
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_10.lua100
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_11.lua192
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_12.lua52
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_13.lua108
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_14.lua112
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_15.lua140
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_16.lua128
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_17.lua110
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_18.lua26
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_19.lua35
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_20.lua64
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_21.lua77
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_22.lua43
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_23.lua70
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_24.lua84
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_25.lua159
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_26.lua53
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_27.lua48
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_28.lua79
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_29.lua94
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_30.lua119
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_31.lua127
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/test_llex_mk2.lua566
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/test_lparser_mk2.lua329
-rw-r--r--LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/test_lparser_mk2_2.lua159
37 files changed, 0 insertions, 5385 deletions
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/README b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/README
deleted file mode 100644
index 215b555..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/README
+++ /dev/null
@@ -1,55 +0,0 @@
1nat-5.1.3
2
3This directory contains versions of front end files that are rewritten
4to be more "native" to Lua. These files should be considered as
5exercises in exploring ways to write the front end, for example, to
6write a front end that is optimized for size, etc. See also file size
7data further below.
8
9The following are the different versions available (mk2 == "mark 2",
10this is commonly used in the UK, e.g. for aeroplanes during WWII):
11
12Lexers
13------
14
15NOTE: These lexers should behave mostly identically to the original C
16lexer. Locale support for non-standard decimal points is missing. Also,
17all strings and long strings have line endings normalized to LF.
18
19llex_mk2 Rewritten from original ported code to become more
20 Lua-like. Needs input to be entered as a single string.
21 Unless an application's need is very unusual, this
22 should not be a problem. It will not work for per-line
23 interaction, though. This version is also somewhat
24 optimized for size; its stripped binary chunk size is
25 3716 bytes.
26
27 Status: TESTED
28
29Parsers
30-------
31
32lparser_mk2 Written for the simplified lexer interface of llex_mk2.
33 This is a lexer skeleton, stripped of codegen code. Has
34 a minimum of variable management code added, and tracks
35 the is_vararg flag of a function. See the comments in
36 the source code for more information. Without logging
37 messages and comments, it should be under 600 LOC. A
38 binary chunk of lparser_mk2 (stripped) is 15783 bytes.
39
40 Sample output of the parser message logger can be found
41 in the test/parser_log subdirectory.
42
43 Tested with test_parser-5.1.lua, the Lua 5.1.x parser test
44 cases in the test_lua/ directory, appears to be fine.
45
46 Compared to the 5.0.x parser skeleton, the main changes
47 are: (a) 'arg' not implemented, so it appears as a global,
48 and (b) '...' recognized as the last function parameter.
49
50 Status: SNIPPETS APPEAR TO WORK
51
52Other notes:
53------------
54
55None.
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/llex_mk2.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/llex_mk2.lua
deleted file mode 100644
index dae57f1..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/llex_mk2.lua
+++ /dev/null
@@ -1,314 +0,0 @@
1--[[--------------------------------------------------------------------
2
3 llex.lua
4 Lua 5.1 lexical analyzer in Lua
5 This file is part of Yueliang.
6
7 Copyright (c) 2008 Kein-Hong Man <khman@users.sf.net>
8 The COPYRIGHT file describes the conditions
9 under which this software may be distributed.
10
11 See the ChangeLog for more information.
12
13----------------------------------------------------------------------]]
14
15--[[--------------------------------------------------------------------
16-- Notes:
17-- * takes in the entire source at once
18-- * greatly simplified chunkid, error handling
19-- * NO shbang handling (it's done elsewhere in Lua 5.1)
20-- * NO localized decimal point replacement magic
21-- * NO limit to number of lines (MAX_INT = 2147483645)
22-- * NO support for compatible long strings (LUA_COMPAT_LSTR)
23-- * NO next(), lookahead() because I want next() to set tok and
24-- seminfo that are locals, and that can only be done easily in
25-- lparser, not llex. lastline would be handled in lparser too.
26--
27-- Usage example:
28-- local llex = require("llex_mk2")
29-- llex.init(source_code, source_code_name)
30-- repeat
31-- local token, seminfo = llex.llex()
32-- until token == "<eof>"
33--
34----------------------------------------------------------------------]]
35
36local base = _G
37local string = require "string"
38module "llex"
39
40----------------------------------------------------------------------
41-- initialize keyword list
42----------------------------------------------------------------------
43local kw = {}
44for v in string.gmatch([[
45and break do else elseif end false for function if in
46local nil not or repeat return then true until while]], "%S+") do
47 kw[v] = true
48end
49
50----------------------------------------------------------------------
51-- initialize lexer for given source _z and source name _sourceid
52----------------------------------------------------------------------
53local z, sourceid, I
54local find = string.find
55local match = string.match
56local sub = string.sub
57
58function init(_z, _sourceid)
59 z = _z -- source
60 sourceid = _sourceid -- name of source
61 I = 1 -- lexer's position in source
62 ln = 1 -- line number
63end
64
65----------------------------------------------------------------------
66-- returns a chunk name or id, no truncation for long names
67----------------------------------------------------------------------
68function chunkid()
69 if sourceid and match(sourceid, "^[=@]") then
70 return sub(sourceid, 2) -- remove first char
71 end
72 return "[string]"
73end
74
75----------------------------------------------------------------------
76-- formats error message and throws error
77-- * a simplified version, does not report what token was responsible
78----------------------------------------------------------------------
79function errorline(s, line)
80 base.error(string.format("%s:%d: %s", chunkid(), line or ln, s))
81end
82
83----------------------------------------------------------------------
84-- handles line number incrementation and end-of-line characters
85----------------------------------------------------------------------
86
87local function inclinenumber(i)
88 local sub = sub
89 local old = sub(z, i, i)
90 i = i + 1 -- skip '\n' or '\r'
91 local c = sub(z, i, i)
92 if (c == "\n" or c == "\r") and (c ~= old) then
93 i = i + 1 -- skip '\n\r' or '\r\n'
94 end
95 ln = ln + 1
96 I = i
97 return i
98end
99
100------------------------------------------------------------------------
101-- count separators ("=") in a long string delimiter
102------------------------------------------------------------------------
103local function skip_sep(i)
104 local sub = sub
105 local s = sub(z, i, i)
106 i = i + 1
107 local count = #match(z, "=*", i) -- note, take the length
108 i = i + count
109 I = i
110 return (sub(z, i, i) == s) and count or (-count) - 1
111end
112
113----------------------------------------------------------------------
114-- reads a long string or long comment
115----------------------------------------------------------------------
116
117local function read_long_string(is_str, sep)
118 local i = I + 1 -- skip 2nd '['
119 local sub = sub
120 local buff = ""
121 local c = sub(z, i, i)
122 if c == "\r" or c == "\n" then -- string starts with a newline?
123 i = inclinenumber(i) -- skip it
124 end
125 local j = i
126 while true do
127 local p, q, r = find(z, "([\r\n%]])", i) -- (long range)
128 if not p then
129 errorline(is_str and "unfinished long string" or
130 "unfinished long comment")
131 end
132 if is_str then
133 buff = buff..sub(z, i, p - 1) -- save string portions
134 end
135 i = p
136 if r == "]" then -- delimiter test
137 if skip_sep(i) == sep then
138 i = I + 1 -- skip 2nd ']'
139 break
140 end
141 buff = buff..sub(z, i, I - 1)
142 i = I
143 else -- newline
144 buff = buff.."\n"
145 i = inclinenumber(i)
146 end
147 end--while
148 I = i
149 return buff
150end
151
152----------------------------------------------------------------------
153-- reads a string
154----------------------------------------------------------------------
155local function read_string(del)
156 local i = I
157 local find = find
158 local sub = sub
159 local buff = ""
160 while true do
161 local p, q, r = find(z, "([\n\r\\\"\'])", i) -- (long range)
162 if p then
163 if r == "\n" or r == "\r" then
164 errorline("unfinished string")
165 end
166 buff = buff..sub(z, i, p - 1) -- normal portions
167 i = p
168 if r == "\\" then -- handle escapes
169 i = i + 1
170 r = sub(z, i, i)
171 if r == "" then break end -- (EOZ error)
172 p = find("abfnrtv\n\r", r, 1, true)
173 ------------------------------------------------------
174 if p then -- special escapes
175 if p > 7 then
176 r = "\n"
177 i = inclinenumber(i)
178 else
179 r = sub("\a\b\f\n\r\t\v", p, p)
180 i = i + 1
181 end
182 ------------------------------------------------------
183 elseif find(r, "%D") then -- other non-digits
184 i = i + 1
185 ------------------------------------------------------
186 else -- \xxx sequence
187 local p, q, s = find(z, "^(%d%d?%d?)", i)
188 i = q + 1
189 if s + 1 > 256 then -- UCHAR_MAX
190 errorline("escape sequence too large")
191 end
192 r = string.char(s)
193 ------------------------------------------------------
194 end--if p
195 else
196 i = i + 1
197 if r == del then -- ending delimiter
198 I = i; return buff -- return string
199 end
200 end--if r
201 buff = buff..r -- handled escapes falls through to here
202 else
203 break -- (error)
204 end--if p
205 end--while
206 errorline("unfinished string")
207end
208
209------------------------------------------------------------------------
210-- main lexer function
211------------------------------------------------------------------------
212function llex()
213 local find = find
214 local match = match
215 while true do--outer
216 local i = I
217 -- inner loop allows break to be used to nicely section tests
218 while true do--inner
219 ----------------------------------------------------------------
220 local p, _, r = find(z, "^([_%a][_%w]*)", i)
221 if p then
222 I = i + #r
223 if kw[r] then return r end -- reserved word (keyword)
224 return "<name>", r -- identifier
225 end
226 ----------------------------------------------------------------
227 local p, _, r = find(z, "^(%.?)%d", i)
228 if p then -- numeral
229 if r == "." then i = i + 1 end
230 local _, q, r = find(z, "^%d*[%.%d]*([eE]?)", i)
231 i = q + 1
232 if #r == 1 then -- optional exponent
233 if match(z, "^[%+%-]", i) then -- optional sign
234 i = i + 1
235 end
236 end
237 local _, q = find(z, "^[_%w]*", i)
238 I = q + 1
239 local v = base.tonumber(sub(z, p, q)) -- handles hex also
240 if not v then errorline("malformed number") end
241 return "<number>", v
242 end
243 ----------------------------------------------------------------
244 local p, q, r = find(z, "^(%s)[ \t]*", i)
245 if p then
246 if r == "\n" or r == "\r" then -- newline
247 inclinenumber(i)
248 else
249 I = q + 1 -- whitespace
250 end
251 break -- (continue)
252 end
253 ----------------------------------------------------------------
254 local r = match(z, "^%p", i)
255 if r then
256 local p = find("-[\"\'.=<>~", r, 1, true)
257 if p then
258 -- two-level if block for punctuation/symbols
259 --------------------------------------------------------
260 if p <= 2 then
261 if p == 1 then -- minus
262 local c = match(z, "^%-%-(%[?)", i)
263 if c then
264 i = i + 2
265 local sep = -1
266 if c == "[" then
267 sep = skip_sep(i)
268 end
269 if sep >= 0 then -- long comment
270 read_long_string(false, sep)
271 else -- short comment
272 I = find(z, "[\n\r]", i) or (#z + 1)
273 end
274 break -- (continue)
275 end
276 -- (fall through for "-")
277 else -- [ or long string
278 local sep = skip_sep(i)
279 if sep >= 0 then
280 return "<string>", read_long_string(true, sep)
281 elseif sep == -1 then
282 return "["
283 else
284 errorline("invalid long string delimiter")
285 end
286 end
287 --------------------------------------------------------
288 elseif p <= 5 then
289 if p < 5 then -- strings
290 I = i + 1
291 return "<string>", read_string(r)
292 end
293 r = match(z, "^%.%.?%.?", i) -- .|..|... dots
294 -- (fall through)
295 --------------------------------------------------------
296 else -- relational
297 r = match(z, "^%p=?", i)
298 -- (fall through)
299 end
300 end
301 I = i + #r; return r -- for other symbols, fall through
302 end
303 ----------------------------------------------------------------
304 local r = sub(z, i, i)
305 if r ~= "" then
306 I = i + 1; return r -- other single-char tokens
307 end
308 return "<eof>" -- end of stream
309 ----------------------------------------------------------------
310 end--while inner
311 end--while outer
312end
313
314return base.getfenv()
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/lparser_mk2.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/lparser_mk2.lua
deleted file mode 100644
index f94fb84..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/lparser_mk2.lua
+++ /dev/null
@@ -1,1294 +0,0 @@
1--[[--------------------------------------------------------------------
2
3 lparser.lua
4 Lua 5.1 parser in Lua
5 This file is part of Yueliang.
6
7 Copyright (c) 2008 Kein-Hong Man <khman@users.sf.net>
8 The COPYRIGHT file describes the conditions
9 under which this software may be distributed.
10
11 See the ChangeLog for more information.
12
13----------------------------------------------------------------------]]
14
15--[[--------------------------------------------------------------------
16-- Notes:
17-- * this is a Lua 5.1.x parser skeleton, for the llex_mk2.lua lexer
18-- * builds some data, performs logging for educational purposes
19-- * target is to have relatively efficient and clear code
20-- * NO parsing limitations, since it is only a parser skeleton. Some
21-- limits set in the default sources (in luaconf.h) are:
22-- LUAI_MAXVARS = 200
23-- LUAI_MAXUPVALUES = 60
24-- LUAI_MAXCCALLS = 200
25-- * NO support for 'arg' vararg functions (LUA_COMPAT_VARARG)
26-- * init(llex) needs one parameter, a lexer module that implements:
27-- llex.lex() - returns appropriate [token, semantic info] pairs
28-- llex.ln - current line number
29-- llex.errorline(s, [line]) - dies with error message
30--
31-- Usage example:
32-- local llex = require("llex_mk2")
33-- local lparser = require("lparser_mk2")
34-- llex.init(source_code, source_code_name)
35-- lparser.init(llex)
36-- local fs = lparser.parser()
37--
38-- Development notes:
39-- * see test_parser-5.1.lua for grammar elements based on lparser.c
40-- * next() (renamed to nextt) and lookahead() has been moved from llex;
41-- it's more convenient to keep tok, seminfo as local variables here
42-- * syntaxerror() is from llex, easier to keep here since little token
43-- translation needed in preparation of error message
44-- * lparser has a few extra items to help parsing/syntax checking
45-- (a) line number (error reporting), lookahead token storage
46-- * (b) per-prototype states needs a storage list
47-- * (c) 'break' needs a per-block flag in a stack
48-- * (d) 'kind' (v.k) testing needed in expr_stat() and assignment()
49-- for disambiguation, thus v.k manipulation is retained
50-- * (e) one line # var (lastln) for ambiguous (split line) function
51-- call checking
52-- * (f) LUA_COMPAT_VARARG compatibility code completely removed
53-- * (g) minimal variable management code to differentiate each type
54-- * parsing starts from the end of this file in parser()
55----------------------------------------------------------------------]]
56
57local base = _G
58local string = require "string"
59module "lparser"
60local _G = base.getfenv()
61
62--[[--------------------------------------------------------------------
63-- variable and data structure initialization
64----------------------------------------------------------------------]]
65
66----------------------------------------------------------------------
67-- initialization: main variables
68----------------------------------------------------------------------
69
70local llex, llex_lex -- references lexer module, function
71local line -- start line # for error messages
72local lastln -- last line # for ambiguous syntax chk
73local tok, seminfo -- token, semantic info pair
74local peek_tok, peek_sem -- ditto, for lookahead
75local fs -- current function state
76local top_fs -- top-level function state
77
78-- forward references for local functions
79local explist1, expr, block, exp1, body
80
81----------------------------------------------------------------------
82-- initialization: data structures
83----------------------------------------------------------------------
84
85local gmatch = string.gmatch
86
87local block_follow = {} -- lookahead check in chunk(), returnstat()
88for v in gmatch("else elseif end until <eof>", "%S+") do
89 block_follow[v] = true
90end
91
92local stat_call = {} -- lookup for calls in stat()
93for v in gmatch("if while do for repeat function local return break", "%S+") do
94 stat_call[v] = v.."_stat"
95end
96
97local binopr_left = {} -- binary operators, left priority
98local binopr_right = {} -- binary operators, right priority
99for op, lt, rt in gmatch([[
100{+ 6 6}{- 6 6}{* 7 7}{/ 7 7}{% 7 7}
101{^ 10 9}{.. 5 4}
102{~= 3 3}{== 3 3}
103{< 3 3}{<= 3 3}{> 3 3}{>= 3 3}
104{and 2 2}{or 1 1}
105]], "{(%S+)%s(%d+)%s(%d+)}") do
106 binopr_left[op] = lt + 0
107 binopr_right[op] = rt + 0
108end
109
110local unopr = { ["not"] = true, ["-"] = true,
111 ["#"] = true, } -- unary operators
112local UNARY_PRIORITY = 8 -- priority for unary operators
113
114--[[--------------------------------------------------------------------
115-- logging: this logging function is for educational purposes
116-- * logged data can be retrieved from the returned data structure
117----------------------------------------------------------------------]]
118
119local function log(msg)
120 local log = top_fs.log
121 if not log then -- initialize message table
122 log = {}; top_fs.log = log
123 end
124 log[#log + 1] = msg
125end
126
127--[[--------------------------------------------------------------------
128-- support functions
129----------------------------------------------------------------------]]
130
131----------------------------------------------------------------------
132-- handles incoming token, semantic information pairs; these two
133-- functions are from llex, they are put here because keeping the
134-- tok, seminfo variables here as locals is more convenient
135-- * NOTE: 'nextt' is named 'next' originally
136----------------------------------------------------------------------
137
138-- reads in next token
139local function nextt()
140 lastln = llex.ln
141 if peek_tok then -- is there a look-ahead token? if yes, use it
142 tok, seminfo = peek_tok, peek_sem
143 peek_tok = nil
144 else
145 tok, seminfo = llex_lex() -- read next token
146 end
147end
148
149-- peek at next token (single lookahead for table constructor)
150local function lookahead()
151 peek_tok, peek_sem = llex_lex()
152 return peek_tok
153end
154
155----------------------------------------------------------------------
156-- throws a syntax error, or if token expected is not there
157----------------------------------------------------------------------
158
159local function syntaxerror(msg)
160 local tok = tok
161 if tok ~= "<number>" and tok ~= "<string>" then
162 if tok == "<name>" then tok = seminfo end
163 tok = "'"..tok.."'"
164 end
165 llex.errorline(msg.." near "..tok)
166end
167
168local function error_expected(token)
169 syntaxerror("'"..token.."' expected")
170end
171
172----------------------------------------------------------------------
173-- tests for a token, returns outcome
174-- * return value changed to boolean
175----------------------------------------------------------------------
176
177local function testnext(c)
178 if tok == c then nextt(); return true end
179end
180
181----------------------------------------------------------------------
182-- check for existence of a token, throws error if not found
183----------------------------------------------------------------------
184
185local function check(c)
186 if tok ~= c then error_expected(c) end
187end
188
189----------------------------------------------------------------------
190-- verify existence of a token, then skip it
191----------------------------------------------------------------------
192
193local function checknext(c)
194 check(c); nextt()
195end
196
197----------------------------------------------------------------------
198-- throws error if condition not matched
199----------------------------------------------------------------------
200
201local function check_condition(c, msg)
202 if not c then syntaxerror(msg) end
203end
204
205----------------------------------------------------------------------
206-- verifies token conditions are met or else throw error
207----------------------------------------------------------------------
208
209local function check_match(what, who, where)
210 if not testnext(what) then
211 if where == llex.ln then
212 error_expected(what)
213 else
214 syntaxerror("'"..what.."' expected (to close '"..who.."' at line "..where..")")
215 end
216 end
217end
218
219----------------------------------------------------------------------
220-- expect that token is a name, return the name
221----------------------------------------------------------------------
222
223local function str_checkname()
224 check("<name>")
225 local ts = seminfo
226 nextt()
227 log(" str_checkname: '"..ts.."'")
228 return ts
229end
230
231----------------------------------------------------------------------
232-- adds given string s in string pool, sets e as VK
233----------------------------------------------------------------------
234
235local function codestring(e, s)
236 e.k = "VK"
237 log(" codestring: "..string.format("%q", s))
238end
239
240----------------------------------------------------------------------
241-- consume a name token, adds it to string pool
242----------------------------------------------------------------------
243
244local function checkname(e)
245 log(" checkname:")
246 codestring(e, str_checkname())
247end
248
249--[[--------------------------------------------------------------------
250-- state management functions with open/close pairs
251----------------------------------------------------------------------]]
252
253----------------------------------------------------------------------
254-- enters a code unit, initializes elements
255----------------------------------------------------------------------
256
257local function enterblock(isbreakable)
258 local bl = {} -- per-block state
259 bl.isbreakable = isbreakable
260 bl.prev = fs.bl
261 bl.locallist = {}
262 fs.bl = bl
263 log(">> enterblock(isbreakable="..base.tostring(isbreakable)..")")
264end
265
266----------------------------------------------------------------------
267-- leaves a code unit, close any upvalues
268----------------------------------------------------------------------
269
270local function leaveblock()
271 local bl = fs.bl
272 fs.bl = bl.prev
273 log("<< leaveblock")
274end
275
276----------------------------------------------------------------------
277-- opening of a function
278-- * top_fs is only for anchoring the top fs, so that parser() can
279-- return it to the caller function along with useful output
280-- * used in parser() and body()
281----------------------------------------------------------------------
282
283local function open_func()
284 local new_fs -- per-function state
285 if not fs then -- top_fs is created early
286 new_fs = top_fs
287 else
288 new_fs = {}
289 end
290 new_fs.prev = fs -- linked list of function states
291 new_fs.bl = nil
292 new_fs.locallist = {}
293 fs = new_fs
294 log(">> open_func")
295end
296
297----------------------------------------------------------------------
298-- closing of a function
299-- * used in parser() and body()
300----------------------------------------------------------------------
301
302local function close_func()
303 fs = fs.prev
304 log("<< close_func")
305end
306
307--[[--------------------------------------------------------------------
308-- variable (global|local|upvalue) handling
309-- * a pure parser does not really need this, but if we want to produce
310-- useful output, might as well write minimal code to manage this...
311-- * entry point is singlevar() for variable lookups
312-- * three entry points for local variable creation, in order to keep
313-- to original C calls, but the extra arguments such as positioning
314-- are removed as we are not allocating registers -- we are only
315-- doing simple classification
316-- * lookup tables (bl.locallist) are maintained awkwardly in the basic
317-- block data structures, PLUS the function data structure (this is
318-- an inelegant hack, since bl is nil for the top level of a function)
319----------------------------------------------------------------------]]
320
321----------------------------------------------------------------------
322-- register a local variable, set in active variable list
323-- * code for a simple lookup only
324-- * used in new_localvarliteral(), parlist(), fornum(), forlist(),
325-- localfunc(), localstat()
326----------------------------------------------------------------------
327
328local function new_localvar(name)
329 local bl = fs.bl
330 local locallist
331 if bl then
332 locallist = bl.locallist
333 else
334 locallist = fs.locallist
335 end
336 locallist[name] = true
337 log(" new_localvar: '"..name.."'")
338end
339
340----------------------------------------------------------------------
341-- creates a new local variable given a name
342-- * used in fornum(), forlist(), parlist(), body()
343----------------------------------------------------------------------
344
345local function new_localvarliteral(name)
346 new_localvar(name)
347end
348
349----------------------------------------------------------------------
350-- search the local variable namespace of the given fs for a match
351-- * a simple lookup only, no active variable list kept, so no useful
352-- index value can be returned by this function
353-- * used only in singlevaraux()
354----------------------------------------------------------------------
355
356local function searchvar(fs, n)
357 local bl = fs.bl
358 if bl then
359 locallist = bl.locallist
360 while locallist do
361 if locallist[n] then return 1 end -- found
362 bl = bl.prev
363 locallist = bl and bl.locallist
364 end
365 end
366 locallist = fs.locallist
367 if locallist[n] then return 1 end -- found
368 return -1 -- not found
369end
370
371----------------------------------------------------------------------
372-- handle locals, globals and upvalues and related processing
373-- * search mechanism is recursive, calls itself to search parents
374-- * used only in singlevar()
375----------------------------------------------------------------------
376
377local function singlevaraux(fs, n, var, base)
378 if fs == nil then -- no more levels?
379 var.k = "VGLOBAL" -- default is global variable
380 return "VGLOBAL"
381 else
382 local v = searchvar(fs, n) -- look up at current level
383 if v >= 0 then
384 var.k = "VLOCAL"
385 -- codegen may need to deal with upvalue here
386 return "VLOCAL"
387 else -- not found at current level; try upper one
388 if singlevaraux(fs.prev, n, var, 0) == "VGLOBAL" then
389 return "VGLOBAL"
390 end
391 -- else was LOCAL or UPVAL, handle here
392 var.k = "VUPVAL" -- upvalue in this level
393 return "VUPVAL"
394 end--if v
395 end--if fs
396end
397
398----------------------------------------------------------------------
399-- consume a name token, creates a variable (global|local|upvalue)
400-- * used in prefixexp(), funcname()
401----------------------------------------------------------------------
402
403local function singlevar(v)
404 local varname = str_checkname()
405 singlevaraux(fs, varname, v, 1)
406 log(" singlevar(kind): '"..v.k.."'")
407end
408
409--[[--------------------------------------------------------------------
410-- other parsing functions
411-- * for table constructor, parameter list, argument list
412----------------------------------------------------------------------]]
413
414----------------------------------------------------------------------
415-- parse a function name suffix, for function call specifications
416-- * used in primaryexp(), funcname()
417----------------------------------------------------------------------
418
419local function field(v)
420 -- field -> ['.' | ':'] NAME
421 local key = {}
422 log(" field: operator="..tok)
423 nextt() -- skip the dot or colon
424 checkname(key)
425 v.k = "VINDEXED"
426end
427
428----------------------------------------------------------------------
429-- parse a table indexing suffix, for constructors, expressions
430-- * used in recfield(), primaryexp()
431----------------------------------------------------------------------
432
433local function yindex(v)
434 -- index -> '[' expr ']'
435 log(">> index: begin '['")
436 nextt() -- skip the '['
437 expr(v)
438 checknext("]")
439 log("<< index: end ']'")
440end
441
442----------------------------------------------------------------------
443-- parse a table record (hash) field
444-- * used in constructor()
445----------------------------------------------------------------------
446
447local function recfield(cc)
448 -- recfield -> (NAME | '['exp1']') = exp1
449 local key, val = {}, {}
450 if tok == "<name>" then
451 log("recfield: name")
452 checkname(key)
453 else-- tok == '['
454 log("recfield: [ exp1 ]")
455 yindex(key)
456 end
457 checknext("=")
458 expr(val)
459end
460
461----------------------------------------------------------------------
462-- emit a set list instruction if enough elements (LFIELDS_PER_FLUSH)
463-- * note: retained in this skeleton because it modifies cc.v.k
464-- * used in constructor()
465----------------------------------------------------------------------
466
467local function closelistfield(cc)
468 if cc.v.k == "VVOID" then return end -- there is no list item
469 cc.v.k = "VVOID"
470end
471
472----------------------------------------------------------------------
473-- parse a table list (array) field
474-- * used in constructor()
475----------------------------------------------------------------------
476
477local function listfield(cc)
478 log("listfield: expr")
479 expr(cc.v)
480end
481
482----------------------------------------------------------------------
483-- parse a table constructor
484-- * used in funcargs(), simpleexp()
485----------------------------------------------------------------------
486
487local function constructor(t)
488 -- constructor -> '{' [ field { fieldsep field } [ fieldsep ] ] '}'
489 -- field -> recfield | listfield
490 -- fieldsep -> ',' | ';'
491 log(">> constructor: begin")
492 local line = llex.ln
493 local cc = {}
494 cc.v = {}
495 cc.t = t
496 t.k = "VRELOCABLE"
497 cc.v.k = "VVOID"
498 checknext("{")
499 repeat
500 if tok == "}" then break end
501 -- closelistfield(cc) here
502 local c = tok
503 if c == "<name>" then -- may be listfields or recfields
504 if lookahead() ~= "=" then -- look ahead: expression?
505 listfield(cc)
506 else
507 recfield(cc)
508 end
509 elseif c == "[" then -- constructor_item -> recfield
510 recfield(cc)
511 else -- constructor_part -> listfield
512 listfield(cc)
513 end
514 until not testnext(",") and not testnext(";")
515 check_match("}", "{", line)
516 -- lastlistfield(cc) here
517 log("<< constructor: end")
518end
519
520----------------------------------------------------------------------
521-- parse the arguments (parameters) of a function declaration
522-- * used in body()
523----------------------------------------------------------------------
524
525local function parlist()
526 -- parlist -> [ param { ',' param } ]
527 log(">> parlist: begin")
528 if tok ~= ")" then -- is 'parlist' not empty?
529 repeat
530 local c = tok
531 if c == "<name>" then -- param -> NAME
532 new_localvar(str_checkname())
533 elseif c == "..." then
534 log("parlist: ... (dots)")
535 nextt()
536 fs.is_vararg = true
537 else
538 syntaxerror("<name> or '...' expected")
539 end
540 until fs.is_vararg or not testnext(",")
541 end--if
542 log("<< parlist: end")
543end
544
545----------------------------------------------------------------------
546-- parse the parameters of a function call
547-- * contrast with parlist(), used in function declarations
548-- * used in primaryexp()
549----------------------------------------------------------------------
550
551local function funcargs(f)
552 local args = {}
553 local line = llex.ln
554 local c = tok
555 if c == "(" then -- funcargs -> '(' [ explist1 ] ')'
556 log(">> funcargs: begin '('")
557 if line ~= lastln then
558 syntaxerror("ambiguous syntax (function call x new statement)")
559 end
560 nextt()
561 if tok == ")" then -- arg list is empty?
562 args.k = "VVOID"
563 else
564 explist1(args)
565 end
566 check_match(")", "(", line)
567 elseif c == "{" then -- funcargs -> constructor
568 log(">> funcargs: begin '{'")
569 constructor(args)
570 elseif c == "<string>" then -- funcargs -> STRING
571 log(">> funcargs: begin <string>")
572 codestring(args, seminfo)
573 nextt() -- must use 'seminfo' before 'next'
574 else
575 syntaxerror("function arguments expected")
576 return
577 end--if c
578 f.k = "VCALL"
579 log("<< funcargs: end -- expr is a VCALL")
580end
581
582--[[--------------------------------------------------------------------
583-- mostly expression functions
584----------------------------------------------------------------------]]
585
586----------------------------------------------------------------------
587-- parses an expression in parentheses or a single variable
588-- * used in primaryexp()
589----------------------------------------------------------------------
590
591local function prefixexp(v)
592 -- prefixexp -> NAME | '(' expr ')'
593 local c = tok
594 if c == "(" then
595 log(">> prefixexp: begin ( expr ) ")
596 local line = llex.ln
597 nextt()
598 expr(v)
599 check_match(")", "(", line)
600 log("<< prefixexp: end ( expr ) ")
601 elseif c == "<name>" then
602 log("prefixexp: <name>")
603 singlevar(v)
604 else
605 syntaxerror("unexpected symbol")
606 end--if c
607end
608
609----------------------------------------------------------------------
610-- parses a prefixexp (an expression in parentheses or a single
611-- variable) or a function call specification
612-- * used in simpleexp(), assignment(), expr_stat()
613----------------------------------------------------------------------
614
615local function primaryexp(v)
616 -- primaryexp ->
617 -- prefixexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs }
618 prefixexp(v)
619 while true do
620 local c = tok
621 if c == "." then -- field
622 log("primaryexp: '.' field")
623 field(v)
624 elseif c == "[" then -- '[' exp1 ']'
625 log("primaryexp: [ exp1 ]")
626 local key = {}
627 yindex(key)
628 elseif c == ":" then -- ':' NAME funcargs
629 log("primaryexp: :<name> funcargs")
630 local key = {}
631 nextt()
632 checkname(key)
633 funcargs(v)
634 elseif c == "(" or c == "<string>" or c == "{" then -- funcargs
635 log("primaryexp: "..c.." funcargs")
636 funcargs(v)
637 else
638 return
639 end--if c
640 end--while
641end
642
643----------------------------------------------------------------------
644-- parses general expression types, constants handled here
645-- * used in subexpr()
646----------------------------------------------------------------------
647
648local function simpleexp(v)
649 -- simpleexp -> NUMBER | STRING | NIL | TRUE | FALSE | ... |
650 -- constructor | FUNCTION body | primaryexp
651 local c = tok
652 if c == "<number>" then
653 log("simpleexp: <number>="..seminfo)
654 v.k = "VKNUM"
655 elseif c == "<string>" then
656 log("simpleexp: <string>="..seminfo)
657 codestring(v, seminfo)
658 elseif c == "nil" then
659 log("simpleexp: nil")
660 v.k = "VNIL"
661 elseif c == "true" then
662 log("simpleexp: true")
663 v.k = "VTRUE"
664 elseif c == "false" then
665 log("simpleexp: false")
666 v.k = "VFALSE"
667 elseif c == "..." then -- vararg
668 check_condition(fs.is_vararg == true,
669 "cannot use '...' outside a vararg function");
670 log("simpleexp: ...")
671 v.k = "VVARARG"
672 elseif c == "{" then -- constructor
673 log("simpleexp: constructor")
674 constructor(v)
675 return
676 elseif c == "function" then
677 log("simpleexp: function")
678 nextt()
679 body(v, false, llex.ln)
680 return
681 else
682 primaryexp(v)
683 return
684 end--if c
685 nextt()
686end
687
688------------------------------------------------------------------------
689-- Parse subexpressions. Includes handling of unary operators and binary
690-- operators. A subexpr is given the rhs priority level of the operator
691-- immediately left of it, if any (limit is -1 if none,) and if a binop
692-- is found, limit is compared with the lhs priority level of the binop
693-- in order to determine which executes first.
694-- * recursively called
695-- * used in expr()
696------------------------------------------------------------------------
697
698local function subexpr(v, limit)
699 -- subexpr -> (simpleexp | unop subexpr) { binop subexpr }
700 -- * where 'binop' is any binary operator with a priority
701 -- higher than 'limit'
702 local op = tok
703 local uop = unopr[op]
704 if uop then
705 log(" subexpr: uop='"..op.."'")
706 nextt()
707 subexpr(v, UNARY_PRIORITY)
708 else
709 simpleexp(v)
710 end
711 -- expand while operators have priorities higher than 'limit'
712 op = tok
713 local binop = binopr_left[op]
714 while binop and binop > limit do
715 local v2 = {}
716 log(">> subexpr: binop='"..op.."'")
717 nextt()
718 -- read sub-expression with higher priority
719 local nextop = subexpr(v2, binopr_right[op])
720 log("<< subexpr: -- evaluate")
721 op = nextop
722 binop = binopr_left[op]
723 end
724 return op -- return first untreated operator
725end
726
727----------------------------------------------------------------------
728-- Expression parsing starts here. Function subexpr is entered with the
729-- left operator (which is non-existent) priority of -1, which is lower
730-- than all actual operators. Expr information is returned in parm v.
731-- * used in cond(), explist1(), index(), recfield(), listfield(),
732-- prefixexp(), while_stat(), exp1()
733----------------------------------------------------------------------
734
735-- this is a forward-referenced local
736function expr(v)
737 -- expr -> subexpr
738 log("expr:")
739 subexpr(v, 0)
740end
741
742--[[--------------------------------------------------------------------
743-- third level parsing functions
744----------------------------------------------------------------------]]
745
746------------------------------------------------------------------------
747-- parse a variable assignment sequence
748-- * recursively called
749-- * used in expr_stat()
750------------------------------------------------------------------------
751
752local function assignment(v)
753 local e = {}
754 local c = v.v.k
755 check_condition(c == "VLOCAL" or c == "VUPVAL" or c == "VGLOBAL"
756 or c == "VINDEXED", "syntax error")
757 if testnext(",") then -- assignment -> ',' primaryexp assignment
758 local nv = {} -- expdesc
759 nv.v = {}
760 log("assignment: ',' -- next LHS element")
761 primaryexp(nv.v)
762 -- lparser.c deals with some register usage conflict here
763 assignment(nv)
764 else -- assignment -> '=' explist1
765 checknext("=")
766 log("assignment: '=' -- RHS elements follows")
767 explist1(e)
768 return -- avoid default
769 end
770 e.k = "VNONRELOC"
771end
772
773----------------------------------------------------------------------
774-- parse a for loop body for both versions of the for loop
775-- * used in fornum(), forlist()
776----------------------------------------------------------------------
777
778local function forbody(isnum)
779 -- forbody -> DO block
780 checknext("do")
781 enterblock(false) -- scope for declared variables
782 block()
783 leaveblock() -- end of scope for declared variables
784end
785
786----------------------------------------------------------------------
787-- parse a numerical for loop, calls forbody()
788-- * used in for_stat()
789----------------------------------------------------------------------
790
791local function fornum(varname)
792 -- fornum -> NAME = exp1, exp1 [, exp1] DO body
793 local line = line
794 new_localvarliteral("(for index)")
795 new_localvarliteral("(for limit)")
796 new_localvarliteral("(for step)")
797 new_localvar(varname)
798 log(">> fornum: begin")
799 checknext("=")
800 log("fornum: index start")
801 exp1() -- initial value
802 checknext(",")
803 log("fornum: index stop")
804 exp1() -- limit
805 if testnext(",") then
806 log("fornum: index step")
807 exp1() -- optional step
808 else
809 -- default step = 1
810 end
811 log("fornum: body")
812 forbody(true)
813 log("<< fornum: end")
814end
815
816----------------------------------------------------------------------
817-- parse a generic for loop, calls forbody()
818-- * used in for_stat()
819----------------------------------------------------------------------
820
821local function forlist(indexname)
822 -- forlist -> NAME {, NAME} IN explist1 DO body
823 log(">> forlist: begin")
824 local e = {}
825 -- create control variables
826 new_localvarliteral("(for generator)")
827 new_localvarliteral("(for state)")
828 new_localvarliteral("(for control)")
829 -- create declared variables
830 new_localvar(indexname)
831 while testnext(",") do
832 new_localvar(str_checkname())
833 end
834 checknext("in")
835 local line = line
836 log("forlist: explist1")
837 explist1(e)
838 log("forlist: body")
839 forbody(false)
840 log("<< forlist: end")
841end
842
843----------------------------------------------------------------------
844-- parse a function name specification
845-- * used in func_stat()
846----------------------------------------------------------------------
847
848local function funcname(v)
849 -- funcname -> NAME {field} [':' NAME]
850 log(">> funcname: begin")
851 local needself = false
852 singlevar(v)
853 while tok == "." do
854 log("funcname: -- '.' field")
855 field(v)
856 end
857 if tok == ":" then
858 log("funcname: -- ':' field")
859 needself = true
860 field(v)
861 end
862 log("<< funcname: end")
863 return needself
864end
865
866----------------------------------------------------------------------
867-- parse the single expressions needed in numerical for loops
868-- * used in fornum()
869----------------------------------------------------------------------
870
871-- this is a forward-referenced local
872function exp1()
873 -- exp1 -> expr
874 local e = {}
875 log(">> exp1: begin")
876 expr(e)
877 log("<< exp1: end")
878end
879
880----------------------------------------------------------------------
881-- parse condition in a repeat statement or an if control structure
882-- * used in repeat_stat(), test_then_block()
883----------------------------------------------------------------------
884
885local function cond()
886 -- cond -> expr
887 log(">> cond: begin")
888 local v = {}
889 expr(v) -- read condition
890 log("<< cond: end")
891end
892
893----------------------------------------------------------------------
894-- parse part of an if control structure, including the condition
895-- * used in if_stat()
896----------------------------------------------------------------------
897
898local function test_then_block()
899 -- test_then_block -> [IF | ELSEIF] cond THEN block
900 nextt() -- skip IF or ELSEIF
901 log("test_then_block: test condition")
902 cond()
903 checknext("then")
904 log("test_then_block: then block")
905 block() -- 'then' part
906end
907
908----------------------------------------------------------------------
909-- parse a local function statement
910-- * used in local_stat()
911----------------------------------------------------------------------
912
913local function localfunc()
914 -- localfunc -> NAME body
915 local v, b = {}
916 log("localfunc: begin")
917 new_localvar(str_checkname())
918 v.k = "VLOCAL"
919 log("localfunc: body")
920 body(b, false, llex.ln)
921 log("localfunc: end")
922end
923
924----------------------------------------------------------------------
925-- parse a local variable declaration statement
926-- * used in local_stat()
927----------------------------------------------------------------------
928
929local function localstat()
930 -- localstat -> NAME {',' NAME} ['=' explist1]
931 log(">> localstat: begin")
932 local e = {}
933 repeat
934 new_localvar(str_checkname())
935 until not testnext(",")
936 if testnext("=") then
937 log("localstat: -- assignment")
938 explist1(e)
939 else
940 e.k = "VVOID"
941 end
942 log("<< localstat: end")
943end
944
945----------------------------------------------------------------------
946-- parse a list of comma-separated expressions
947-- * used in return_stat(), localstat(), funcargs(), assignment(),
948-- forlist()
949----------------------------------------------------------------------
950
951-- this is a forward-referenced local
952function explist1(e)
953 -- explist1 -> expr { ',' expr }
954 log(">> explist1: begin")
955 expr(e)
956 while testnext(",") do
957 log("explist1: ',' -- continuation")
958 expr(e)
959 end
960 log("<< explist1: end")
961end
962
963----------------------------------------------------------------------
964-- parse function declaration body
965-- * used in simpleexp(), localfunc(), func_stat()
966----------------------------------------------------------------------
967
968-- this is a forward-referenced local
969function body(e, needself, line)
970 -- body -> '(' parlist ')' chunk END
971 open_func()
972 log("body: begin")
973 checknext("(")
974 if needself then
975 new_localvarliteral("self")
976 end
977 log("body: parlist")
978 parlist()
979 checknext(")")
980 log("body: chunk")
981 chunk()
982 check_match("end", "function", line)
983 log("body: end")
984 close_func()
985end
986
987----------------------------------------------------------------------
988-- parse a code block or unit
989-- * used in do_stat(), while_stat(), forbody(), test_then_block(),
990-- if_stat()
991----------------------------------------------------------------------
992
993-- this is a forward-referenced local
994function block()
995 -- block -> chunk
996 log("block: begin")
997 enterblock(false)
998 chunk()
999 leaveblock()
1000 log("block: end")
1001end
1002
1003--[[--------------------------------------------------------------------
1004-- second level parsing functions, all with '_stat' suffix
1005-- * since they are called via a table lookup, they cannot be local
1006-- functions (a lookup table of local functions might be smaller...)
1007-- * stat() -> *_stat()
1008----------------------------------------------------------------------]]
1009
1010----------------------------------------------------------------------
1011-- initial parsing for a for loop, calls fornum() or forlist()
1012-- * removed 'line' parameter (used to set debug information only)
1013-- * used in stat()
1014----------------------------------------------------------------------
1015
1016function for_stat()
1017 -- stat -> for_stat -> FOR (fornum | forlist) END
1018 local line = line
1019 log("for_stat: begin")
1020 enterblock(true) -- scope for loop and control variables
1021 nextt() -- skip 'for'
1022 local varname = str_checkname() -- first variable name
1023 local c = tok
1024 if c == "=" then
1025 log("for_stat: numerical loop")
1026 fornum(varname)
1027 elseif c == "," or c == "in" then
1028 log("for_stat: list-based loop")
1029 forlist(varname)
1030 else
1031 syntaxerror("'=' or 'in' expected")
1032 end
1033 check_match("end", "for", line)
1034 leaveblock() -- loop scope (`break' jumps to this point)
1035 log("for_stat: end")
1036end
1037
1038----------------------------------------------------------------------
1039-- parse a while-do control structure, body processed by block()
1040-- * used in stat()
1041----------------------------------------------------------------------
1042
1043function while_stat()
1044 -- stat -> while_stat -> WHILE cond DO block END
1045 local line = line
1046 nextt() -- skip WHILE
1047 log("while_stat: begin/condition")
1048 cond() -- parse condition
1049 enterblock(true)
1050 checknext("do")
1051 log("while_stat: block")
1052 block()
1053 check_match("end", "while", line)
1054 leaveblock()
1055 log("while_stat: end")
1056end
1057
1058----------------------------------------------------------------------
1059-- parse a repeat-until control structure, body parsed by chunk()
1060-- * originally, repeatstat() calls breakstat() too if there is an
1061-- upvalue in the scope block; nothing is actually lexed, it is
1062-- actually the common code in breakstat() for closing of upvalues
1063-- * used in stat()
1064----------------------------------------------------------------------
1065
1066function repeat_stat()
1067 -- stat -> repeat_stat -> REPEAT block UNTIL cond
1068 local line = line
1069 log("repeat_stat: begin")
1070 enterblock(true) -- loop block
1071 enterblock(false) -- scope block
1072 nextt() -- skip REPEAT
1073 chunk()
1074 check_match("until", "repeat", line)
1075 log("repeat_stat: condition")
1076 cond()
1077 -- close upvalues at scope level below
1078 leaveblock() -- finish scope
1079 leaveblock() -- finish loop
1080 log("repeat_stat: end")
1081end
1082
1083----------------------------------------------------------------------
1084-- parse an if control structure
1085-- * used in stat()
1086----------------------------------------------------------------------
1087
1088function if_stat()
1089 -- stat -> if_stat -> IF cond THEN block
1090 -- {ELSEIF cond THEN block} [ELSE block] END
1091 local line = line
1092 local v = {}
1093 log("if_stat: if...then")
1094 test_then_block() -- IF cond THEN block
1095 while tok == "elseif" do
1096 log("if_stat: elseif...then")
1097 test_then_block() -- ELSEIF cond THEN block
1098 end
1099 if tok == "else" then
1100 log("if_stat: else...")
1101 nextt() -- skip ELSE
1102 block() -- 'else' part
1103 end
1104 check_match("end", "if", line)
1105 log("if_stat: end")
1106end
1107
1108----------------------------------------------------------------------
1109-- parse a return statement
1110-- * used in stat()
1111----------------------------------------------------------------------
1112
1113function return_stat()
1114 -- stat -> return_stat -> RETURN explist
1115 local e = {}
1116 nextt() -- skip RETURN
1117 local c = tok
1118 if block_follow[c] or c == ";" then
1119 -- return no values
1120 log("return_stat: no return values")
1121 else
1122 log("return_stat: begin")
1123 explist1(e) -- optional return values
1124 log("return_stat: end")
1125 end
1126end
1127
1128----------------------------------------------------------------------
1129-- parse a break statement
1130-- * used in stat()
1131----------------------------------------------------------------------
1132
1133function break_stat()
1134 -- stat -> break_stat -> BREAK
1135 local bl = fs.bl
1136 nextt() -- skip BREAK
1137 while bl and not bl.isbreakable do -- find a breakable block
1138 bl = bl.prev
1139 end
1140 if not bl then
1141 syntaxerror("no loop to break")
1142 end
1143 log("break_stat: -- break out of loop")
1144end
1145
1146----------------------------------------------------------------------
1147-- parse a function call with no returns or an assignment statement
1148-- * the struct with .prev is used for name searching in lparse.c,
1149-- so it is retained for now; present in assignment() also
1150-- * used in stat()
1151----------------------------------------------------------------------
1152
1153function expr_stat()
1154 -- stat -> expr_stat -> func | assignment
1155 local v = {}
1156 v.v = {}
1157 primaryexp(v.v)
1158 if v.v.k == "VCALL" then -- stat -> func
1159 -- call statement uses no results
1160 log("expr_stat: function call k='"..v.v.k.."'")
1161 else -- stat -> assignment
1162 log("expr_stat: assignment k='"..v.v.k.."'")
1163 v.prev = nil
1164 assignment(v)
1165 end
1166end
1167
1168----------------------------------------------------------------------
1169-- parse a function statement
1170-- * used in stat()
1171----------------------------------------------------------------------
1172
1173function function_stat()
1174 -- stat -> function_stat -> FUNCTION funcname body
1175 local line = line
1176 local v, b = {}, {}
1177 log("function_stat: begin")
1178 nextt() -- skip FUNCTION
1179 local needself = funcname(v)
1180 log("function_stat: body needself='"..base.tostring(needself).."'")
1181 body(b, needself, line)
1182 log("function_stat: end")
1183end
1184
1185----------------------------------------------------------------------
1186-- parse a simple block enclosed by a DO..END pair
1187-- * used in stat()
1188----------------------------------------------------------------------
1189
1190function do_stat()
1191 -- stat -> do_stat -> DO block END
1192 local line = line
1193 nextt() -- skip DO
1194 log("do_stat: begin")
1195 block()
1196 log("do_stat: end")
1197 check_match("end", "do", line)
1198end
1199
1200----------------------------------------------------------------------
1201-- parse a statement starting with LOCAL
1202-- * used in stat()
1203----------------------------------------------------------------------
1204
1205function local_stat()
1206 -- stat -> local_stat -> LOCAL FUNCTION localfunc
1207 -- -> LOCAL localstat
1208 nextt() -- skip LOCAL
1209 if testnext("function") then -- local function?
1210 log("local_stat: local function")
1211 localfunc()
1212 else
1213 log("local_stat: local statement")
1214 localstat()
1215 end
1216end
1217
1218--[[--------------------------------------------------------------------
1219-- main functions, top level parsing functions
1220-- * accessible functions are: init(lexer), parser()
1221-- * [entry] -> parser() -> chunk() -> stat()
1222----------------------------------------------------------------------]]
1223
1224----------------------------------------------------------------------
1225-- initial parsing for statements, calls '_stat' suffixed functions
1226-- * used in chunk()
1227----------------------------------------------------------------------
1228
1229local function stat()
1230 -- stat -> if_stat while_stat do_stat for_stat repeat_stat
1231 -- function_stat local_stat return_stat break_stat
1232 -- expr_stat
1233 line = llex.ln -- may be needed for error messages
1234 local c = tok
1235 local fn = stat_call[c]
1236 -- handles: if while do for repeat function local return break
1237 if fn then
1238 log("-- STATEMENT: begin '"..c.."' line="..line)
1239 _G[fn]()
1240 log("-- STATEMENT: end '"..c.."'")
1241 -- return or break must be last statement
1242 if c == "return" or c == "break" then return true end
1243 else
1244 log("-- STATEMENT: begin 'expr' line="..line)
1245 expr_stat()
1246 log("-- STATEMENT: end 'expr'")
1247 end
1248 log("")
1249 return false
1250end
1251
1252----------------------------------------------------------------------
1253-- parse a chunk, which consists of a bunch of statements
1254-- * used in parser(), body(), block(), repeat_stat()
1255----------------------------------------------------------------------
1256
1257function chunk()
1258 -- chunk -> { stat [';'] }
1259 log("chunk:")
1260 local islast = false
1261 while not islast and not block_follow[tok] do
1262 islast = stat()
1263 testnext(";")
1264 end
1265end
1266
1267----------------------------------------------------------------------
1268-- performs parsing, returns parsed data structure
1269----------------------------------------------------------------------
1270
1271function parser()
1272 log("-- TOP: begin")
1273 open_func()
1274 fs.is_vararg = true -- main func. is always vararg
1275 log("")
1276 nextt() -- read first token
1277 chunk()
1278 check("<eof>")
1279 close_func()
1280 log("-- TOP: end")
1281 return top_fs
1282end
1283
1284----------------------------------------------------------------------
1285-- initialization function
1286----------------------------------------------------------------------
1287
1288function init(lexer)
1289 llex = lexer -- set lexer (assume user-initialized)
1290 llex_lex = llex.llex
1291 top_fs = {} -- reset top level function state
1292end
1293
1294return _G
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_01.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_01.lua
deleted file mode 100644
index 379cc9d..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_01.lua
+++ /dev/null
@@ -1,9 +0,0 @@
1-- START OF SOURCE --
2-- END OF SOURCE --
3
4-- TOP: begin
5 open_func
6
7 chunk:
8 close_func
9-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_02.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_02.lua
deleted file mode 100644
index 13eb2e6..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_02.lua
+++ /dev/null
@@ -1,10 +0,0 @@
1-- START OF SOURCE --
2-- foobar
3-- END OF SOURCE --
4
5-- TOP: begin
6 open_func
7
8 chunk:
9 close_func
10-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_03.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_03.lua
deleted file mode 100644
index 33df29c..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_03.lua
+++ /dev/null
@@ -1,21 +0,0 @@
1-- START OF SOURCE --
2do
3end
4-- END OF SOURCE --
5
6-- TOP: begin
7 open_func
8
9 chunk:
10 -- STATEMENT: begin 'do' line=1
11 do_stat: begin
12 block: begin
13 enterblock(isbreakable=false)
14 chunk:
15 leaveblock
16 block: end
17 do_stat: end
18 -- STATEMENT: end 'do'
19
20 close_func
21-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_04.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_04.lua
deleted file mode 100644
index d0fefbc..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_04.lua
+++ /dev/null
@@ -1,31 +0,0 @@
1-- START OF SOURCE --
2do end
3do end
4-- END OF SOURCE --
5
6-- TOP: begin
7 open_func
8
9 chunk:
10 -- STATEMENT: begin 'do' line=1
11 do_stat: begin
12 block: begin
13 enterblock(isbreakable=false)
14 chunk:
15 leaveblock
16 block: end
17 do_stat: end
18 -- STATEMENT: end 'do'
19
20 -- STATEMENT: begin 'do' line=2
21 do_stat: begin
22 block: begin
23 enterblock(isbreakable=false)
24 chunk:
25 leaveblock
26 block: end
27 do_stat: end
28 -- STATEMENT: end 'do'
29
30 close_func
31-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_05.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_05.lua
deleted file mode 100644
index 17a9231..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_05.lua
+++ /dev/null
@@ -1,129 +0,0 @@
1-- START OF SOURCE --
2foo()
3foo{}
4foo""
5foo:bar()
6foo=false
7foo.bar=true
8foo[true]=nil
9foo,bar=1,"a"
10-- END OF SOURCE --
11
12-- TOP: begin
13 open_func
14
15 chunk:
16 -- STATEMENT: begin 'expr' line=1
17 prefixexp: <name>
18 str_checkname: 'foo'
19 singlevar(kind): 'VGLOBAL'
20 primaryexp: ( funcargs
21 funcargs: begin '('
22 funcargs: end -- expr is a VCALL
23 expr_stat: function call k='VCALL'
24 -- STATEMENT: end 'expr'
25
26 -- STATEMENT: begin 'expr' line=2
27 prefixexp: <name>
28 str_checkname: 'foo'
29 singlevar(kind): 'VGLOBAL'
30 primaryexp: { funcargs
31 funcargs: begin '{'
32 constructor: begin
33 constructor: end
34 funcargs: end -- expr is a VCALL
35 expr_stat: function call k='VCALL'
36 -- STATEMENT: end 'expr'
37
38 -- STATEMENT: begin 'expr' line=3
39 prefixexp: <name>
40 str_checkname: 'foo'
41 singlevar(kind): 'VGLOBAL'
42 primaryexp: <string> funcargs
43 funcargs: begin <string>
44 codestring: ""
45 funcargs: end -- expr is a VCALL
46 expr_stat: function call k='VCALL'
47 -- STATEMENT: end 'expr'
48
49 -- STATEMENT: begin 'expr' line=4
50 prefixexp: <name>
51 str_checkname: 'foo'
52 singlevar(kind): 'VGLOBAL'
53 primaryexp: :<name> funcargs
54 checkname:
55 str_checkname: 'bar'
56 codestring: "bar"
57 funcargs: begin '('
58 funcargs: end -- expr is a VCALL
59 expr_stat: function call k='VCALL'
60 -- STATEMENT: end 'expr'
61
62 -- STATEMENT: begin 'expr' line=5
63 prefixexp: <name>
64 str_checkname: 'foo'
65 singlevar(kind): 'VGLOBAL'
66 expr_stat: assignment k='VGLOBAL'
67 assignment: '=' -- RHS elements follows
68 explist1: begin
69 expr:
70 simpleexp: false
71 explist1: end
72 -- STATEMENT: end 'expr'
73
74 -- STATEMENT: begin 'expr' line=6
75 prefixexp: <name>
76 str_checkname: 'foo'
77 singlevar(kind): 'VGLOBAL'
78 primaryexp: '.' field
79 field: operator=.
80 checkname:
81 str_checkname: 'bar'
82 codestring: "bar"
83 expr_stat: assignment k='VINDEXED'
84 assignment: '=' -- RHS elements follows
85 explist1: begin
86 expr:
87 simpleexp: true
88 explist1: end
89 -- STATEMENT: end 'expr'
90
91 -- STATEMENT: begin 'expr' line=7
92 prefixexp: <name>
93 str_checkname: 'foo'
94 singlevar(kind): 'VGLOBAL'
95 primaryexp: [ exp1 ]
96 index: begin '['
97 expr:
98 simpleexp: true
99 index: end ']'
100 expr_stat: assignment k='VGLOBAL'
101 assignment: '=' -- RHS elements follows
102 explist1: begin
103 expr:
104 simpleexp: nil
105 explist1: end
106 -- STATEMENT: end 'expr'
107
108 -- STATEMENT: begin 'expr' line=8
109 prefixexp: <name>
110 str_checkname: 'foo'
111 singlevar(kind): 'VGLOBAL'
112 expr_stat: assignment k='VGLOBAL'
113 assignment: ',' -- next LHS element
114 prefixexp: <name>
115 str_checkname: 'bar'
116 singlevar(kind): 'VGLOBAL'
117 assignment: '=' -- RHS elements follows
118 explist1: begin
119 expr:
120 simpleexp: <number>=1
121 explist1: ',' -- continuation
122 expr:
123 simpleexp: <string>=a
124 codestring: "a"
125 explist1: end
126 -- STATEMENT: end 'expr'
127
128 close_func
129-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_06.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_06.lua
deleted file mode 100644
index 29f1703..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_06.lua
+++ /dev/null
@@ -1,132 +0,0 @@
1-- START OF SOURCE --
2foo=true
3foo=false
4foo=nil
5foo=1.23e45
6foo=-1
7foo=(0)
8foo=1+2
9foo=1+2*3-4/5
10-- END OF SOURCE --
11
12-- TOP: begin
13 open_func
14
15 chunk:
16 -- STATEMENT: begin 'expr' line=1
17 prefixexp: <name>
18 str_checkname: 'foo'
19 singlevar(kind): 'VGLOBAL'
20 expr_stat: assignment k='VGLOBAL'
21 assignment: '=' -- RHS elements follows
22 explist1: begin
23 expr:
24 simpleexp: true
25 explist1: end
26 -- STATEMENT: end 'expr'
27
28 -- STATEMENT: begin 'expr' line=2
29 prefixexp: <name>
30 str_checkname: 'foo'
31 singlevar(kind): 'VGLOBAL'
32 expr_stat: assignment k='VGLOBAL'
33 assignment: '=' -- RHS elements follows
34 explist1: begin
35 expr:
36 simpleexp: false
37 explist1: end
38 -- STATEMENT: end 'expr'
39
40 -- STATEMENT: begin 'expr' line=3
41 prefixexp: <name>
42 str_checkname: 'foo'
43 singlevar(kind): 'VGLOBAL'
44 expr_stat: assignment k='VGLOBAL'
45 assignment: '=' -- RHS elements follows
46 explist1: begin
47 expr:
48 simpleexp: nil
49 explist1: end
50 -- STATEMENT: end 'expr'
51
52 -- STATEMENT: begin 'expr' line=4
53 prefixexp: <name>
54 str_checkname: 'foo'
55 singlevar(kind): 'VGLOBAL'
56 expr_stat: assignment k='VGLOBAL'
57 assignment: '=' -- RHS elements follows
58 explist1: begin
59 expr:
60 simpleexp: <number>=1.23e+45
61 explist1: end
62 -- STATEMENT: end 'expr'
63
64 -- STATEMENT: begin 'expr' line=5
65 prefixexp: <name>
66 str_checkname: 'foo'
67 singlevar(kind): 'VGLOBAL'
68 expr_stat: assignment k='VGLOBAL'
69 assignment: '=' -- RHS elements follows
70 explist1: begin
71 expr:
72 subexpr: uop='-'
73 simpleexp: <number>=1
74 explist1: end
75 -- STATEMENT: end 'expr'
76
77 -- STATEMENT: begin 'expr' line=6
78 prefixexp: <name>
79 str_checkname: 'foo'
80 singlevar(kind): 'VGLOBAL'
81 expr_stat: assignment k='VGLOBAL'
82 assignment: '=' -- RHS elements follows
83 explist1: begin
84 expr:
85 prefixexp: begin ( expr )
86 expr:
87 simpleexp: <number>=0
88 prefixexp: end ( expr )
89 explist1: end
90 -- STATEMENT: end 'expr'
91
92 -- STATEMENT: begin 'expr' line=7
93 prefixexp: <name>
94 str_checkname: 'foo'
95 singlevar(kind): 'VGLOBAL'
96 expr_stat: assignment k='VGLOBAL'
97 assignment: '=' -- RHS elements follows
98 explist1: begin
99 expr:
100 simpleexp: <number>=1
101 subexpr: binop='+'
102 simpleexp: <number>=2
103 subexpr: -- evaluate
104 explist1: end
105 -- STATEMENT: end 'expr'
106
107 -- STATEMENT: begin 'expr' line=8
108 prefixexp: <name>
109 str_checkname: 'foo'
110 singlevar(kind): 'VGLOBAL'
111 expr_stat: assignment k='VGLOBAL'
112 assignment: '=' -- RHS elements follows
113 explist1: begin
114 expr:
115 simpleexp: <number>=1
116 subexpr: binop='+'
117 simpleexp: <number>=2
118 subexpr: binop='*'
119 simpleexp: <number>=3
120 subexpr: -- evaluate
121 subexpr: -- evaluate
122 subexpr: binop='-'
123 simpleexp: <number>=4
124 subexpr: binop='/'
125 simpleexp: <number>=5
126 subexpr: -- evaluate
127 subexpr: -- evaluate
128 explist1: end
129 -- STATEMENT: end 'expr'
130
131 close_func
132-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_07.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_07.lua
deleted file mode 100644
index c3a4600..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_07.lua
+++ /dev/null
@@ -1,147 +0,0 @@
1-- START OF SOURCE --
2if foo then foo=1 end
3if foo then foo=1 else foo=0 end
4if foo then foo=1 elseif not foo then foo=0 end
5-- END OF SOURCE --
6
7-- TOP: begin
8 open_func
9
10 chunk:
11 -- STATEMENT: begin 'if' line=1
12 if_stat: if...then
13 test_then_block: test condition
14 cond: begin
15 expr:
16 prefixexp: <name>
17 str_checkname: 'foo'
18 singlevar(kind): 'VGLOBAL'
19 cond: end
20 test_then_block: then block
21 block: begin
22 enterblock(isbreakable=false)
23 chunk:
24 -- STATEMENT: begin 'expr' line=1
25 prefixexp: <name>
26 str_checkname: 'foo'
27 singlevar(kind): 'VGLOBAL'
28 expr_stat: assignment k='VGLOBAL'
29 assignment: '=' -- RHS elements follows
30 explist1: begin
31 expr:
32 simpleexp: <number>=1
33 explist1: end
34 -- STATEMENT: end 'expr'
35
36 leaveblock
37 block: end
38 if_stat: end
39 -- STATEMENT: end 'if'
40
41 -- STATEMENT: begin 'if' line=2
42 if_stat: if...then
43 test_then_block: test condition
44 cond: begin
45 expr:
46 prefixexp: <name>
47 str_checkname: 'foo'
48 singlevar(kind): 'VGLOBAL'
49 cond: end
50 test_then_block: then block
51 block: begin
52 enterblock(isbreakable=false)
53 chunk:
54 -- STATEMENT: begin 'expr' line=2
55 prefixexp: <name>
56 str_checkname: 'foo'
57 singlevar(kind): 'VGLOBAL'
58 expr_stat: assignment k='VGLOBAL'
59 assignment: '=' -- RHS elements follows
60 explist1: begin
61 expr:
62 simpleexp: <number>=1
63 explist1: end
64 -- STATEMENT: end 'expr'
65
66 leaveblock
67 block: end
68 if_stat: else...
69 block: begin
70 enterblock(isbreakable=false)
71 chunk:
72 -- STATEMENT: begin 'expr' line=2
73 prefixexp: <name>
74 str_checkname: 'foo'
75 singlevar(kind): 'VGLOBAL'
76 expr_stat: assignment k='VGLOBAL'
77 assignment: '=' -- RHS elements follows
78 explist1: begin
79 expr:
80 simpleexp: <number>=0
81 explist1: end
82 -- STATEMENT: end 'expr'
83
84 leaveblock
85 block: end
86 if_stat: end
87 -- STATEMENT: end 'if'
88
89 -- STATEMENT: begin 'if' line=3
90 if_stat: if...then
91 test_then_block: test condition
92 cond: begin
93 expr:
94 prefixexp: <name>
95 str_checkname: 'foo'
96 singlevar(kind): 'VGLOBAL'
97 cond: end
98 test_then_block: then block
99 block: begin
100 enterblock(isbreakable=false)
101 chunk:
102 -- STATEMENT: begin 'expr' line=3
103 prefixexp: <name>
104 str_checkname: 'foo'
105 singlevar(kind): 'VGLOBAL'
106 expr_stat: assignment k='VGLOBAL'
107 assignment: '=' -- RHS elements follows
108 explist1: begin
109 expr:
110 simpleexp: <number>=1
111 explist1: end
112 -- STATEMENT: end 'expr'
113
114 leaveblock
115 block: end
116 if_stat: elseif...then
117 test_then_block: test condition
118 cond: begin
119 expr:
120 subexpr: uop='not'
121 prefixexp: <name>
122 str_checkname: 'foo'
123 singlevar(kind): 'VGLOBAL'
124 cond: end
125 test_then_block: then block
126 block: begin
127 enterblock(isbreakable=false)
128 chunk:
129 -- STATEMENT: begin 'expr' line=3
130 prefixexp: <name>
131 str_checkname: 'foo'
132 singlevar(kind): 'VGLOBAL'
133 expr_stat: assignment k='VGLOBAL'
134 assignment: '=' -- RHS elements follows
135 explist1: begin
136 expr:
137 simpleexp: <number>=0
138 explist1: end
139 -- STATEMENT: end 'expr'
140
141 leaveblock
142 block: end
143 if_stat: end
144 -- STATEMENT: end 'if'
145
146 close_func
147-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_08.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_08.lua
deleted file mode 100644
index d086c98..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_08.lua
+++ /dev/null
@@ -1,66 +0,0 @@
1-- START OF SOURCE --
2do return end
3do return 123 end
4do return "foo","bar" end
5-- END OF SOURCE --
6
7-- TOP: begin
8 open_func
9
10 chunk:
11 -- STATEMENT: begin 'do' line=1
12 do_stat: begin
13 block: begin
14 enterblock(isbreakable=false)
15 chunk:
16 -- STATEMENT: begin 'return' line=1
17 return_stat: no return values
18 -- STATEMENT: end 'return'
19 leaveblock
20 block: end
21 do_stat: end
22 -- STATEMENT: end 'do'
23
24 -- STATEMENT: begin 'do' line=2
25 do_stat: begin
26 block: begin
27 enterblock(isbreakable=false)
28 chunk:
29 -- STATEMENT: begin 'return' line=2
30 return_stat: begin
31 explist1: begin
32 expr:
33 simpleexp: <number>=123
34 explist1: end
35 return_stat: end
36 -- STATEMENT: end 'return'
37 leaveblock
38 block: end
39 do_stat: end
40 -- STATEMENT: end 'do'
41
42 -- STATEMENT: begin 'do' line=3
43 do_stat: begin
44 block: begin
45 enterblock(isbreakable=false)
46 chunk:
47 -- STATEMENT: begin 'return' line=3
48 return_stat: begin
49 explist1: begin
50 expr:
51 simpleexp: <string>=foo
52 codestring: "foo"
53 explist1: ',' -- continuation
54 expr:
55 simpleexp: <string>=bar
56 codestring: "bar"
57 explist1: end
58 return_stat: end
59 -- STATEMENT: end 'return'
60 leaveblock
61 block: end
62 do_stat: end
63 -- STATEMENT: end 'do'
64
65 close_func
66-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_09.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_09.lua
deleted file mode 100644
index 67c6cf3..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_09.lua
+++ /dev/null
@@ -1,103 +0,0 @@
1-- START OF SOURCE --
2while true do foo=not foo end
3while foo~=42 do foo=foo-1 end
4while true do break end
5-- END OF SOURCE --
6
7-- TOP: begin
8 open_func
9
10 chunk:
11 -- STATEMENT: begin 'while' line=1
12 while_stat: begin/condition
13 cond: begin
14 expr:
15 simpleexp: true
16 cond: end
17 enterblock(isbreakable=true)
18 while_stat: block
19 block: begin
20 enterblock(isbreakable=false)
21 chunk:
22 -- STATEMENT: begin 'expr' line=1
23 prefixexp: <name>
24 str_checkname: 'foo'
25 singlevar(kind): 'VGLOBAL'
26 expr_stat: assignment k='VGLOBAL'
27 assignment: '=' -- RHS elements follows
28 explist1: begin
29 expr:
30 subexpr: uop='not'
31 prefixexp: <name>
32 str_checkname: 'foo'
33 singlevar(kind): 'VGLOBAL'
34 explist1: end
35 -- STATEMENT: end 'expr'
36
37 leaveblock
38 block: end
39 leaveblock
40 while_stat: end
41 -- STATEMENT: end 'while'
42
43 -- STATEMENT: begin 'while' line=2
44 while_stat: begin/condition
45 cond: begin
46 expr:
47 prefixexp: <name>
48 str_checkname: 'foo'
49 singlevar(kind): 'VGLOBAL'
50 subexpr: binop='~='
51 simpleexp: <number>=42
52 subexpr: -- evaluate
53 cond: end
54 enterblock(isbreakable=true)
55 while_stat: block
56 block: begin
57 enterblock(isbreakable=false)
58 chunk:
59 -- STATEMENT: begin 'expr' line=2
60 prefixexp: <name>
61 str_checkname: 'foo'
62 singlevar(kind): 'VGLOBAL'
63 expr_stat: assignment k='VGLOBAL'
64 assignment: '=' -- RHS elements follows
65 explist1: begin
66 expr:
67 prefixexp: <name>
68 str_checkname: 'foo'
69 singlevar(kind): 'VGLOBAL'
70 subexpr: binop='-'
71 simpleexp: <number>=1
72 subexpr: -- evaluate
73 explist1: end
74 -- STATEMENT: end 'expr'
75
76 leaveblock
77 block: end
78 leaveblock
79 while_stat: end
80 -- STATEMENT: end 'while'
81
82 -- STATEMENT: begin 'while' line=3
83 while_stat: begin/condition
84 cond: begin
85 expr:
86 simpleexp: true
87 cond: end
88 enterblock(isbreakable=true)
89 while_stat: block
90 block: begin
91 enterblock(isbreakable=false)
92 chunk:
93 -- STATEMENT: begin 'break' line=3
94 break_stat: -- break out of loop
95 -- STATEMENT: end 'break'
96 leaveblock
97 block: end
98 leaveblock
99 while_stat: end
100 -- STATEMENT: end 'while'
101
102 close_func
103-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_10.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_10.lua
deleted file mode 100644
index b8e7754..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_10.lua
+++ /dev/null
@@ -1,100 +0,0 @@
1-- START OF SOURCE --
2repeat foo=foo.."bar" until false
3repeat foo=foo/2 until foo<1
4repeat break until false
5-- END OF SOURCE --
6
7-- TOP: begin
8 open_func
9
10 chunk:
11 -- STATEMENT: begin 'repeat' line=1
12 repeat_stat: begin
13 enterblock(isbreakable=true)
14 enterblock(isbreakable=false)
15 chunk:
16 -- STATEMENT: begin 'expr' line=1
17 prefixexp: <name>
18 str_checkname: 'foo'
19 singlevar(kind): 'VGLOBAL'
20 expr_stat: assignment k='VGLOBAL'
21 assignment: '=' -- RHS elements follows
22 explist1: begin
23 expr:
24 prefixexp: <name>
25 str_checkname: 'foo'
26 singlevar(kind): 'VGLOBAL'
27 subexpr: binop='..'
28 simpleexp: <string>=bar
29 codestring: "bar"
30 subexpr: -- evaluate
31 explist1: end
32 -- STATEMENT: end 'expr'
33
34 repeat_stat: condition
35 cond: begin
36 expr:
37 simpleexp: false
38 cond: end
39 leaveblock
40 leaveblock
41 repeat_stat: end
42 -- STATEMENT: end 'repeat'
43
44 -- STATEMENT: begin 'repeat' line=2
45 repeat_stat: begin
46 enterblock(isbreakable=true)
47 enterblock(isbreakable=false)
48 chunk:
49 -- STATEMENT: begin 'expr' line=2
50 prefixexp: <name>
51 str_checkname: 'foo'
52 singlevar(kind): 'VGLOBAL'
53 expr_stat: assignment k='VGLOBAL'
54 assignment: '=' -- RHS elements follows
55 explist1: begin
56 expr:
57 prefixexp: <name>
58 str_checkname: 'foo'
59 singlevar(kind): 'VGLOBAL'
60 subexpr: binop='/'
61 simpleexp: <number>=2
62 subexpr: -- evaluate
63 explist1: end
64 -- STATEMENT: end 'expr'
65
66 repeat_stat: condition
67 cond: begin
68 expr:
69 prefixexp: <name>
70 str_checkname: 'foo'
71 singlevar(kind): 'VGLOBAL'
72 subexpr: binop='<'
73 simpleexp: <number>=1
74 subexpr: -- evaluate
75 cond: end
76 leaveblock
77 leaveblock
78 repeat_stat: end
79 -- STATEMENT: end 'repeat'
80
81 -- STATEMENT: begin 'repeat' line=3
82 repeat_stat: begin
83 enterblock(isbreakable=true)
84 enterblock(isbreakable=false)
85 chunk:
86 -- STATEMENT: begin 'break' line=3
87 break_stat: -- break out of loop
88 -- STATEMENT: end 'break'
89 repeat_stat: condition
90 cond: begin
91 expr:
92 simpleexp: false
93 cond: end
94 leaveblock
95 leaveblock
96 repeat_stat: end
97 -- STATEMENT: end 'repeat'
98
99 close_func
100-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_11.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_11.lua
deleted file mode 100644
index 461ea82..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_11.lua
+++ /dev/null
@@ -1,192 +0,0 @@
1-- START OF SOURCE --
2for i=1,10 do foo=i end
3for i=1,10,2 do break end
4for i in foo do bar=0 end
5for i,j in foo,bar do baz=0 end
6-- END OF SOURCE --
7
8-- TOP: begin
9 open_func
10
11 chunk:
12 -- STATEMENT: begin 'for' line=1
13 for_stat: begin
14 enterblock(isbreakable=true)
15 str_checkname: 'i'
16 for_stat: numerical loop
17 new_localvar: '(for index)'
18 new_localvar: '(for limit)'
19 new_localvar: '(for step)'
20 new_localvar: 'i'
21 fornum: begin
22 fornum: index start
23 exp1: begin
24 expr:
25 simpleexp: <number>=1
26 exp1: end
27 fornum: index stop
28 exp1: begin
29 expr:
30 simpleexp: <number>=10
31 exp1: end
32 fornum: body
33 enterblock(isbreakable=false)
34 block: begin
35 enterblock(isbreakable=false)
36 chunk:
37 -- STATEMENT: begin 'expr' line=1
38 prefixexp: <name>
39 str_checkname: 'foo'
40 singlevar(kind): 'VGLOBAL'
41 expr_stat: assignment k='VGLOBAL'
42 assignment: '=' -- RHS elements follows
43 explist1: begin
44 expr:
45 prefixexp: <name>
46 str_checkname: 'i'
47 singlevar(kind): 'VLOCAL'
48 explist1: end
49 -- STATEMENT: end 'expr'
50
51 leaveblock
52 block: end
53 leaveblock
54 fornum: end
55 leaveblock
56 for_stat: end
57 -- STATEMENT: end 'for'
58
59 -- STATEMENT: begin 'for' line=2
60 for_stat: begin
61 enterblock(isbreakable=true)
62 str_checkname: 'i'
63 for_stat: numerical loop
64 new_localvar: '(for index)'
65 new_localvar: '(for limit)'
66 new_localvar: '(for step)'
67 new_localvar: 'i'
68 fornum: begin
69 fornum: index start
70 exp1: begin
71 expr:
72 simpleexp: <number>=1
73 exp1: end
74 fornum: index stop
75 exp1: begin
76 expr:
77 simpleexp: <number>=10
78 exp1: end
79 fornum: index step
80 exp1: begin
81 expr:
82 simpleexp: <number>=2
83 exp1: end
84 fornum: body
85 enterblock(isbreakable=false)
86 block: begin
87 enterblock(isbreakable=false)
88 chunk:
89 -- STATEMENT: begin 'break' line=2
90 break_stat: -- break out of loop
91 -- STATEMENT: end 'break'
92 leaveblock
93 block: end
94 leaveblock
95 fornum: end
96 leaveblock
97 for_stat: end
98 -- STATEMENT: end 'for'
99
100 -- STATEMENT: begin 'for' line=3
101 for_stat: begin
102 enterblock(isbreakable=true)
103 str_checkname: 'i'
104 for_stat: list-based loop
105 forlist: begin
106 new_localvar: '(for generator)'
107 new_localvar: '(for state)'
108 new_localvar: '(for control)'
109 new_localvar: 'i'
110 forlist: explist1
111 explist1: begin
112 expr:
113 prefixexp: <name>
114 str_checkname: 'foo'
115 singlevar(kind): 'VGLOBAL'
116 explist1: end
117 forlist: body
118 enterblock(isbreakable=false)
119 block: begin
120 enterblock(isbreakable=false)
121 chunk:
122 -- STATEMENT: begin 'expr' line=3
123 prefixexp: <name>
124 str_checkname: 'bar'
125 singlevar(kind): 'VGLOBAL'
126 expr_stat: assignment k='VGLOBAL'
127 assignment: '=' -- RHS elements follows
128 explist1: begin
129 expr:
130 simpleexp: <number>=0
131 explist1: end
132 -- STATEMENT: end 'expr'
133
134 leaveblock
135 block: end
136 leaveblock
137 forlist: end
138 leaveblock
139 for_stat: end
140 -- STATEMENT: end 'for'
141
142 -- STATEMENT: begin 'for' line=4
143 for_stat: begin
144 enterblock(isbreakable=true)
145 str_checkname: 'i'
146 for_stat: list-based loop
147 forlist: begin
148 new_localvar: '(for generator)'
149 new_localvar: '(for state)'
150 new_localvar: '(for control)'
151 new_localvar: 'i'
152 str_checkname: 'j'
153 new_localvar: 'j'
154 forlist: explist1
155 explist1: begin
156 expr:
157 prefixexp: <name>
158 str_checkname: 'foo'
159 singlevar(kind): 'VGLOBAL'
160 explist1: ',' -- continuation
161 expr:
162 prefixexp: <name>
163 str_checkname: 'bar'
164 singlevar(kind): 'VGLOBAL'
165 explist1: end
166 forlist: body
167 enterblock(isbreakable=false)
168 block: begin
169 enterblock(isbreakable=false)
170 chunk:
171 -- STATEMENT: begin 'expr' line=4
172 prefixexp: <name>
173 str_checkname: 'baz'
174 singlevar(kind): 'VGLOBAL'
175 expr_stat: assignment k='VGLOBAL'
176 assignment: '=' -- RHS elements follows
177 explist1: begin
178 expr:
179 simpleexp: <number>=0
180 explist1: end
181 -- STATEMENT: end 'expr'
182
183 leaveblock
184 block: end
185 leaveblock
186 forlist: end
187 leaveblock
188 for_stat: end
189 -- STATEMENT: end 'for'
190
191 close_func
192-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_12.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_12.lua
deleted file mode 100644
index c423d85..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_12.lua
+++ /dev/null
@@ -1,52 +0,0 @@
1-- START OF SOURCE --
2local foo
3local foo,bar,baz
4local foo,bar="foo","bar"
5-- END OF SOURCE --
6
7-- TOP: begin
8 open_func
9
10 chunk:
11 -- STATEMENT: begin 'local' line=1
12 local_stat: local statement
13 localstat: begin
14 str_checkname: 'foo'
15 new_localvar: 'foo'
16 localstat: end
17 -- STATEMENT: end 'local'
18
19 -- STATEMENT: begin 'local' line=2
20 local_stat: local statement
21 localstat: begin
22 str_checkname: 'foo'
23 new_localvar: 'foo'
24 str_checkname: 'bar'
25 new_localvar: 'bar'
26 str_checkname: 'baz'
27 new_localvar: 'baz'
28 localstat: end
29 -- STATEMENT: end 'local'
30
31 -- STATEMENT: begin 'local' line=3
32 local_stat: local statement
33 localstat: begin
34 str_checkname: 'foo'
35 new_localvar: 'foo'
36 str_checkname: 'bar'
37 new_localvar: 'bar'
38 localstat: -- assignment
39 explist1: begin
40 expr:
41 simpleexp: <string>=foo
42 codestring: "foo"
43 explist1: ',' -- continuation
44 expr:
45 simpleexp: <string>=bar
46 codestring: "bar"
47 explist1: end
48 localstat: end
49 -- STATEMENT: end 'local'
50
51 close_func
52-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_13.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_13.lua
deleted file mode 100644
index b5f598a..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_13.lua
+++ /dev/null
@@ -1,108 +0,0 @@
1-- START OF SOURCE --
2local function foo() return end
3local function foo(a) return end
4local function foo(x,y,z) return end
5local function foo(x,...) return end
6-- END OF SOURCE --
7
8-- TOP: begin
9 open_func
10
11 chunk:
12 -- STATEMENT: begin 'local' line=1
13 local_stat: local function
14 localfunc: begin
15 str_checkname: 'foo'
16 new_localvar: 'foo'
17 localfunc: body
18 open_func
19 body: begin
20 body: parlist
21 parlist: begin
22 parlist: end
23 body: chunk
24 chunk:
25 -- STATEMENT: begin 'return' line=1
26 return_stat: no return values
27 -- STATEMENT: end 'return'
28 body: end
29 close_func
30 localfunc: end
31 -- STATEMENT: end 'local'
32
33 -- STATEMENT: begin 'local' line=2
34 local_stat: local function
35 localfunc: begin
36 str_checkname: 'foo'
37 new_localvar: 'foo'
38 localfunc: body
39 open_func
40 body: begin
41 body: parlist
42 parlist: begin
43 str_checkname: 'a'
44 new_localvar: 'a'
45 parlist: end
46 body: chunk
47 chunk:
48 -- STATEMENT: begin 'return' line=2
49 return_stat: no return values
50 -- STATEMENT: end 'return'
51 body: end
52 close_func
53 localfunc: end
54 -- STATEMENT: end 'local'
55
56 -- STATEMENT: begin 'local' line=3
57 local_stat: local function
58 localfunc: begin
59 str_checkname: 'foo'
60 new_localvar: 'foo'
61 localfunc: body
62 open_func
63 body: begin
64 body: parlist
65 parlist: begin
66 str_checkname: 'x'
67 new_localvar: 'x'
68 str_checkname: 'y'
69 new_localvar: 'y'
70 str_checkname: 'z'
71 new_localvar: 'z'
72 parlist: end
73 body: chunk
74 chunk:
75 -- STATEMENT: begin 'return' line=3
76 return_stat: no return values
77 -- STATEMENT: end 'return'
78 body: end
79 close_func
80 localfunc: end
81 -- STATEMENT: end 'local'
82
83 -- STATEMENT: begin 'local' line=4
84 local_stat: local function
85 localfunc: begin
86 str_checkname: 'foo'
87 new_localvar: 'foo'
88 localfunc: body
89 open_func
90 body: begin
91 body: parlist
92 parlist: begin
93 str_checkname: 'x'
94 new_localvar: 'x'
95 parlist: ... (dots)
96 parlist: end
97 body: chunk
98 chunk:
99 -- STATEMENT: begin 'return' line=4
100 return_stat: no return values
101 -- STATEMENT: end 'return'
102 body: end
103 close_func
104 localfunc: end
105 -- STATEMENT: end 'local'
106
107 close_func
108-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_14.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_14.lua
deleted file mode 100644
index a6b9ad0..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_14.lua
+++ /dev/null
@@ -1,112 +0,0 @@
1-- START OF SOURCE --
2function foo() return end
3function foo(a) return end
4function foo(x,y,z) return end
5function foo(x,...) return end
6-- END OF SOURCE --
7
8-- TOP: begin
9 open_func
10
11 chunk:
12 -- STATEMENT: begin 'function' line=1
13 function_stat: begin
14 funcname: begin
15 str_checkname: 'foo'
16 singlevar(kind): 'VGLOBAL'
17 funcname: end
18 function_stat: body needself='false'
19 open_func
20 body: begin
21 body: parlist
22 parlist: begin
23 parlist: end
24 body: chunk
25 chunk:
26 -- STATEMENT: begin 'return' line=1
27 return_stat: no return values
28 -- STATEMENT: end 'return'
29 body: end
30 close_func
31 function_stat: end
32 -- STATEMENT: end 'function'
33
34 -- STATEMENT: begin 'function' line=2
35 function_stat: begin
36 funcname: begin
37 str_checkname: 'foo'
38 singlevar(kind): 'VGLOBAL'
39 funcname: end
40 function_stat: body needself='false'
41 open_func
42 body: begin
43 body: parlist
44 parlist: begin
45 str_checkname: 'a'
46 new_localvar: 'a'
47 parlist: end
48 body: chunk
49 chunk:
50 -- STATEMENT: begin 'return' line=2
51 return_stat: no return values
52 -- STATEMENT: end 'return'
53 body: end
54 close_func
55 function_stat: end
56 -- STATEMENT: end 'function'
57
58 -- STATEMENT: begin 'function' line=3
59 function_stat: begin
60 funcname: begin
61 str_checkname: 'foo'
62 singlevar(kind): 'VGLOBAL'
63 funcname: end
64 function_stat: body needself='false'
65 open_func
66 body: begin
67 body: parlist
68 parlist: begin
69 str_checkname: 'x'
70 new_localvar: 'x'
71 str_checkname: 'y'
72 new_localvar: 'y'
73 str_checkname: 'z'
74 new_localvar: 'z'
75 parlist: end
76 body: chunk
77 chunk:
78 -- STATEMENT: begin 'return' line=3
79 return_stat: no return values
80 -- STATEMENT: end 'return'
81 body: end
82 close_func
83 function_stat: end
84 -- STATEMENT: end 'function'
85
86 -- STATEMENT: begin 'function' line=4
87 function_stat: begin
88 funcname: begin
89 str_checkname: 'foo'
90 singlevar(kind): 'VGLOBAL'
91 funcname: end
92 function_stat: body needself='false'
93 open_func
94 body: begin
95 body: parlist
96 parlist: begin
97 str_checkname: 'x'
98 new_localvar: 'x'
99 parlist: ... (dots)
100 parlist: end
101 body: chunk
102 chunk:
103 -- STATEMENT: begin 'return' line=4
104 return_stat: no return values
105 -- STATEMENT: end 'return'
106 body: end
107 close_func
108 function_stat: end
109 -- STATEMENT: end 'function'
110
111 close_func
112-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_15.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_15.lua
deleted file mode 100644
index 497eeaf..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_15.lua
+++ /dev/null
@@ -1,140 +0,0 @@
1-- START OF SOURCE --
2function foo.bar(p) return end
3function foo.bar.baz(p) return end
4function foo:bar(p) return end
5function foo.bar.baz(p) return end
6-- END OF SOURCE --
7
8-- TOP: begin
9 open_func
10
11 chunk:
12 -- STATEMENT: begin 'function' line=1
13 function_stat: begin
14 funcname: begin
15 str_checkname: 'foo'
16 singlevar(kind): 'VGLOBAL'
17 funcname: -- '.' field
18 field: operator=.
19 checkname:
20 str_checkname: 'bar'
21 codestring: "bar"
22 funcname: end
23 function_stat: body needself='false'
24 open_func
25 body: begin
26 body: parlist
27 parlist: begin
28 str_checkname: 'p'
29 new_localvar: 'p'
30 parlist: end
31 body: chunk
32 chunk:
33 -- STATEMENT: begin 'return' line=1
34 return_stat: no return values
35 -- STATEMENT: end 'return'
36 body: end
37 close_func
38 function_stat: end
39 -- STATEMENT: end 'function'
40
41 -- STATEMENT: begin 'function' line=2
42 function_stat: begin
43 funcname: begin
44 str_checkname: 'foo'
45 singlevar(kind): 'VGLOBAL'
46 funcname: -- '.' field
47 field: operator=.
48 checkname:
49 str_checkname: 'bar'
50 codestring: "bar"
51 funcname: -- '.' field
52 field: operator=.
53 checkname:
54 str_checkname: 'baz'
55 codestring: "baz"
56 funcname: end
57 function_stat: body needself='false'
58 open_func
59 body: begin
60 body: parlist
61 parlist: begin
62 str_checkname: 'p'
63 new_localvar: 'p'
64 parlist: end
65 body: chunk
66 chunk:
67 -- STATEMENT: begin 'return' line=2
68 return_stat: no return values
69 -- STATEMENT: end 'return'
70 body: end
71 close_func
72 function_stat: end
73 -- STATEMENT: end 'function'
74
75 -- STATEMENT: begin 'function' line=3
76 function_stat: begin
77 funcname: begin
78 str_checkname: 'foo'
79 singlevar(kind): 'VGLOBAL'
80 funcname: -- ':' field
81 field: operator=:
82 checkname:
83 str_checkname: 'bar'
84 codestring: "bar"
85 funcname: end
86 function_stat: body needself='true'
87 open_func
88 body: begin
89 new_localvar: 'self'
90 body: parlist
91 parlist: begin
92 str_checkname: 'p'
93 new_localvar: 'p'
94 parlist: end
95 body: chunk
96 chunk:
97 -- STATEMENT: begin 'return' line=3
98 return_stat: no return values
99 -- STATEMENT: end 'return'
100 body: end
101 close_func
102 function_stat: end
103 -- STATEMENT: end 'function'
104
105 -- STATEMENT: begin 'function' line=4
106 function_stat: begin
107 funcname: begin
108 str_checkname: 'foo'
109 singlevar(kind): 'VGLOBAL'
110 funcname: -- '.' field
111 field: operator=.
112 checkname:
113 str_checkname: 'bar'
114 codestring: "bar"
115 funcname: -- '.' field
116 field: operator=.
117 checkname:
118 str_checkname: 'baz'
119 codestring: "baz"
120 funcname: end
121 function_stat: body needself='false'
122 open_func
123 body: begin
124 body: parlist
125 parlist: begin
126 str_checkname: 'p'
127 new_localvar: 'p'
128 parlist: end
129 body: chunk
130 chunk:
131 -- STATEMENT: begin 'return' line=4
132 return_stat: no return values
133 -- STATEMENT: end 'return'
134 body: end
135 close_func
136 function_stat: end
137 -- STATEMENT: end 'function'
138
139 close_func
140-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_16.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_16.lua
deleted file mode 100644
index b7907b8..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_16.lua
+++ /dev/null
@@ -1,128 +0,0 @@
1-- START OF SOURCE --
2foo = function() return end
3foo = function(x,y) return end
4foo = function(...) return end
5foo = function(...) local bar = ... return end
6-- END OF SOURCE --
7
8-- TOP: begin
9 open_func
10
11 chunk:
12 -- STATEMENT: begin 'expr' line=1
13 prefixexp: <name>
14 str_checkname: 'foo'
15 singlevar(kind): 'VGLOBAL'
16 expr_stat: assignment k='VGLOBAL'
17 assignment: '=' -- RHS elements follows
18 explist1: begin
19 expr:
20 simpleexp: function
21 open_func
22 body: begin
23 body: parlist
24 parlist: begin
25 parlist: end
26 body: chunk
27 chunk:
28 -- STATEMENT: begin 'return' line=1
29 return_stat: no return values
30 -- STATEMENT: end 'return'
31 body: end
32 close_func
33 explist1: end
34 -- STATEMENT: end 'expr'
35
36 -- STATEMENT: begin 'expr' line=2
37 prefixexp: <name>
38 str_checkname: 'foo'
39 singlevar(kind): 'VGLOBAL'
40 expr_stat: assignment k='VGLOBAL'
41 assignment: '=' -- RHS elements follows
42 explist1: begin
43 expr:
44 simpleexp: function
45 open_func
46 body: begin
47 body: parlist
48 parlist: begin
49 str_checkname: 'x'
50 new_localvar: 'x'
51 str_checkname: 'y'
52 new_localvar: 'y'
53 parlist: end
54 body: chunk
55 chunk:
56 -- STATEMENT: begin 'return' line=2
57 return_stat: no return values
58 -- STATEMENT: end 'return'
59 body: end
60 close_func
61 explist1: end
62 -- STATEMENT: end 'expr'
63
64 -- STATEMENT: begin 'expr' line=3
65 prefixexp: <name>
66 str_checkname: 'foo'
67 singlevar(kind): 'VGLOBAL'
68 expr_stat: assignment k='VGLOBAL'
69 assignment: '=' -- RHS elements follows
70 explist1: begin
71 expr:
72 simpleexp: function
73 open_func
74 body: begin
75 body: parlist
76 parlist: begin
77 parlist: ... (dots)
78 parlist: end
79 body: chunk
80 chunk:
81 -- STATEMENT: begin 'return' line=3
82 return_stat: no return values
83 -- STATEMENT: end 'return'
84 body: end
85 close_func
86 explist1: end
87 -- STATEMENT: end 'expr'
88
89 -- STATEMENT: begin 'expr' line=4
90 prefixexp: <name>
91 str_checkname: 'foo'
92 singlevar(kind): 'VGLOBAL'
93 expr_stat: assignment k='VGLOBAL'
94 assignment: '=' -- RHS elements follows
95 explist1: begin
96 expr:
97 simpleexp: function
98 open_func
99 body: begin
100 body: parlist
101 parlist: begin
102 parlist: ... (dots)
103 parlist: end
104 body: chunk
105 chunk:
106 -- STATEMENT: begin 'local' line=4
107 local_stat: local statement
108 localstat: begin
109 str_checkname: 'bar'
110 new_localvar: 'bar'
111 localstat: -- assignment
112 explist1: begin
113 expr:
114 simpleexp: ...
115 explist1: end
116 localstat: end
117 -- STATEMENT: end 'local'
118
119 -- STATEMENT: begin 'return' line=4
120 return_stat: no return values
121 -- STATEMENT: end 'return'
122 body: end
123 close_func
124 explist1: end
125 -- STATEMENT: end 'expr'
126
127 close_func
128-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_17.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_17.lua
deleted file mode 100644
index fadc7f9..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_17.lua
+++ /dev/null
@@ -1,110 +0,0 @@
1-- START OF SOURCE --
2foo = {}
3foo = { 1,2,3; "foo"; }
4foo = { bar=77, baz=88, }
5foo = { ["bar"]=77, ["baz"]=88, }
6-- END OF SOURCE --
7
8-- TOP: begin
9 open_func
10
11 chunk:
12 -- STATEMENT: begin 'expr' line=1
13 prefixexp: <name>
14 str_checkname: 'foo'
15 singlevar(kind): 'VGLOBAL'
16 expr_stat: assignment k='VGLOBAL'
17 assignment: '=' -- RHS elements follows
18 explist1: begin
19 expr:
20 simpleexp: constructor
21 constructor: begin
22 constructor: end
23 explist1: end
24 -- STATEMENT: end 'expr'
25
26 -- STATEMENT: begin 'expr' line=2
27 prefixexp: <name>
28 str_checkname: 'foo'
29 singlevar(kind): 'VGLOBAL'
30 expr_stat: assignment k='VGLOBAL'
31 assignment: '=' -- RHS elements follows
32 explist1: begin
33 expr:
34 simpleexp: constructor
35 constructor: begin
36 listfield: expr
37 expr:
38 simpleexp: <number>=1
39 listfield: expr
40 expr:
41 simpleexp: <number>=2
42 listfield: expr
43 expr:
44 simpleexp: <number>=3
45 listfield: expr
46 expr:
47 simpleexp: <string>=foo
48 codestring: "foo"
49 constructor: end
50 explist1: end
51 -- STATEMENT: end 'expr'
52
53 -- STATEMENT: begin 'expr' line=3
54 prefixexp: <name>
55 str_checkname: 'foo'
56 singlevar(kind): 'VGLOBAL'
57 expr_stat: assignment k='VGLOBAL'
58 assignment: '=' -- RHS elements follows
59 explist1: begin
60 expr:
61 simpleexp: constructor
62 constructor: begin
63 recfield: name
64 checkname:
65 str_checkname: 'bar'
66 codestring: "bar"
67 expr:
68 simpleexp: <number>=77
69 recfield: name
70 checkname:
71 str_checkname: 'baz'
72 codestring: "baz"
73 expr:
74 simpleexp: <number>=88
75 constructor: end
76 explist1: end
77 -- STATEMENT: end 'expr'
78
79 -- STATEMENT: begin 'expr' line=4
80 prefixexp: <name>
81 str_checkname: 'foo'
82 singlevar(kind): 'VGLOBAL'
83 expr_stat: assignment k='VGLOBAL'
84 assignment: '=' -- RHS elements follows
85 explist1: begin
86 expr:
87 simpleexp: constructor
88 constructor: begin
89 recfield: [ exp1 ]
90 index: begin '['
91 expr:
92 simpleexp: <string>=bar
93 codestring: "bar"
94 index: end ']'
95 expr:
96 simpleexp: <number>=77
97 recfield: [ exp1 ]
98 index: begin '['
99 expr:
100 simpleexp: <string>=baz
101 codestring: "baz"
102 index: end ']'
103 expr:
104 simpleexp: <number>=88
105 constructor: end
106 explist1: end
107 -- STATEMENT: end 'expr'
108
109 close_func
110-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_18.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_18.lua
deleted file mode 100644
index 732b4d6..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_18.lua
+++ /dev/null
@@ -1,26 +0,0 @@
1-- START OF SOURCE --
2 print(a)
3-- END OF SOURCE --
4
5-- TOP: begin
6 open_func
7
8 chunk:
9 -- STATEMENT: begin 'expr' line=1
10 prefixexp: <name>
11 str_checkname: 'print'
12 singlevar(kind): 'VGLOBAL'
13 primaryexp: ( funcargs
14 funcargs: begin '('
15 explist1: begin
16 expr:
17 prefixexp: <name>
18 str_checkname: 'a'
19 singlevar(kind): 'VGLOBAL'
20 explist1: end
21 funcargs: end -- expr is a VCALL
22 expr_stat: function call k='VCALL'
23 -- STATEMENT: end 'expr'
24
25 close_func
26-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_19.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_19.lua
deleted file mode 100644
index 9863b4a..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_19.lua
+++ /dev/null
@@ -1,35 +0,0 @@
1-- START OF SOURCE --
2 local a
3 print(a)
4-- END OF SOURCE --
5
6-- TOP: begin
7 open_func
8
9 chunk:
10 -- STATEMENT: begin 'local' line=1
11 local_stat: local statement
12 localstat: begin
13 str_checkname: 'a'
14 new_localvar: 'a'
15 localstat: end
16 -- STATEMENT: end 'local'
17
18 -- STATEMENT: begin 'expr' line=2
19 prefixexp: <name>
20 str_checkname: 'print'
21 singlevar(kind): 'VGLOBAL'
22 primaryexp: ( funcargs
23 funcargs: begin '('
24 explist1: begin
25 expr:
26 prefixexp: <name>
27 str_checkname: 'a'
28 singlevar(kind): 'VLOCAL'
29 explist1: end
30 funcargs: end -- expr is a VCALL
31 expr_stat: function call k='VCALL'
32 -- STATEMENT: end 'expr'
33
34 close_func
35-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_20.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_20.lua
deleted file mode 100644
index bc37280..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_20.lua
+++ /dev/null
@@ -1,64 +0,0 @@
1-- START OF SOURCE --
2 do
3 local a
4 print(a)
5 end
6 print(a)
7-- END OF SOURCE --
8
9-- TOP: begin
10 open_func
11
12 chunk:
13 -- STATEMENT: begin 'do' line=1
14 do_stat: begin
15 block: begin
16 enterblock(isbreakable=false)
17 chunk:
18 -- STATEMENT: begin 'local' line=2
19 local_stat: local statement
20 localstat: begin
21 str_checkname: 'a'
22 new_localvar: 'a'
23 localstat: end
24 -- STATEMENT: end 'local'
25
26 -- STATEMENT: begin 'expr' line=3
27 prefixexp: <name>
28 str_checkname: 'print'
29 singlevar(kind): 'VGLOBAL'
30 primaryexp: ( funcargs
31 funcargs: begin '('
32 explist1: begin
33 expr:
34 prefixexp: <name>
35 str_checkname: 'a'
36 singlevar(kind): 'VLOCAL'
37 explist1: end
38 funcargs: end -- expr is a VCALL
39 expr_stat: function call k='VCALL'
40 -- STATEMENT: end 'expr'
41
42 leaveblock
43 block: end
44 do_stat: end
45 -- STATEMENT: end 'do'
46
47 -- STATEMENT: begin 'expr' line=5
48 prefixexp: <name>
49 str_checkname: 'print'
50 singlevar(kind): 'VGLOBAL'
51 primaryexp: ( funcargs
52 funcargs: begin '('
53 explist1: begin
54 expr:
55 prefixexp: <name>
56 str_checkname: 'a'
57 singlevar(kind): 'VGLOBAL'
58 explist1: end
59 funcargs: end -- expr is a VCALL
60 expr_stat: function call k='VCALL'
61 -- STATEMENT: end 'expr'
62
63 close_func
64-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_21.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_21.lua
deleted file mode 100644
index b2bac4b..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_21.lua
+++ /dev/null
@@ -1,77 +0,0 @@
1-- START OF SOURCE --
2 local a,b,c
3 do
4 local b
5 print(b)
6 end
7 print(b)
8-- END OF SOURCE --
9
10-- TOP: begin
11 open_func
12
13 chunk:
14 -- STATEMENT: begin 'local' line=1
15 local_stat: local statement
16 localstat: begin
17 str_checkname: 'a'
18 new_localvar: 'a'
19 str_checkname: 'b'
20 new_localvar: 'b'
21 str_checkname: 'c'
22 new_localvar: 'c'
23 localstat: end
24 -- STATEMENT: end 'local'
25
26 -- STATEMENT: begin 'do' line=2
27 do_stat: begin
28 block: begin
29 enterblock(isbreakable=false)
30 chunk:
31 -- STATEMENT: begin 'local' line=3
32 local_stat: local statement
33 localstat: begin
34 str_checkname: 'b'
35 new_localvar: 'b'
36 localstat: end
37 -- STATEMENT: end 'local'
38
39 -- STATEMENT: begin 'expr' line=4
40 prefixexp: <name>
41 str_checkname: 'print'
42 singlevar(kind): 'VGLOBAL'
43 primaryexp: ( funcargs
44 funcargs: begin '('
45 explist1: begin
46 expr:
47 prefixexp: <name>
48 str_checkname: 'b'
49 singlevar(kind): 'VLOCAL'
50 explist1: end
51 funcargs: end -- expr is a VCALL
52 expr_stat: function call k='VCALL'
53 -- STATEMENT: end 'expr'
54
55 leaveblock
56 block: end
57 do_stat: end
58 -- STATEMENT: end 'do'
59
60 -- STATEMENT: begin 'expr' line=6
61 prefixexp: <name>
62 str_checkname: 'print'
63 singlevar(kind): 'VGLOBAL'
64 primaryexp: ( funcargs
65 funcargs: begin '('
66 explist1: begin
67 expr:
68 prefixexp: <name>
69 str_checkname: 'b'
70 singlevar(kind): 'VLOCAL'
71 explist1: end
72 funcargs: end -- expr is a VCALL
73 expr_stat: function call k='VCALL'
74 -- STATEMENT: end 'expr'
75
76 close_func
77-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_22.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_22.lua
deleted file mode 100644
index 6885f01..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_22.lua
+++ /dev/null
@@ -1,43 +0,0 @@
1-- START OF SOURCE --
2 local function foo() end
3 bar = foo
4-- END OF SOURCE --
5
6-- TOP: begin
7 open_func
8
9 chunk:
10 -- STATEMENT: begin 'local' line=1
11 local_stat: local function
12 localfunc: begin
13 str_checkname: 'foo'
14 new_localvar: 'foo'
15 localfunc: body
16 open_func
17 body: begin
18 body: parlist
19 parlist: begin
20 parlist: end
21 body: chunk
22 chunk:
23 body: end
24 close_func
25 localfunc: end
26 -- STATEMENT: end 'local'
27
28 -- STATEMENT: begin 'expr' line=2
29 prefixexp: <name>
30 str_checkname: 'bar'
31 singlevar(kind): 'VGLOBAL'
32 expr_stat: assignment k='VGLOBAL'
33 assignment: '=' -- RHS elements follows
34 explist1: begin
35 expr:
36 prefixexp: <name>
37 str_checkname: 'foo'
38 singlevar(kind): 'VLOCAL'
39 explist1: end
40 -- STATEMENT: end 'expr'
41
42 close_func
43-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_23.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_23.lua
deleted file mode 100644
index eb658ed..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_23.lua
+++ /dev/null
@@ -1,70 +0,0 @@
1-- START OF SOURCE --
2 do
3 local function foo() end
4 bar = foo
5 end
6 baz = foo
7-- END OF SOURCE --
8
9-- TOP: begin
10 open_func
11
12 chunk:
13 -- STATEMENT: begin 'do' line=1
14 do_stat: begin
15 block: begin
16 enterblock(isbreakable=false)
17 chunk:
18 -- STATEMENT: begin 'local' line=2
19 local_stat: local function
20 localfunc: begin
21 str_checkname: 'foo'
22 new_localvar: 'foo'
23 localfunc: body
24 open_func
25 body: begin
26 body: parlist
27 parlist: begin
28 parlist: end
29 body: chunk
30 chunk:
31 body: end
32 close_func
33 localfunc: end
34 -- STATEMENT: end 'local'
35
36 -- STATEMENT: begin 'expr' line=3
37 prefixexp: <name>
38 str_checkname: 'bar'
39 singlevar(kind): 'VGLOBAL'
40 expr_stat: assignment k='VGLOBAL'
41 assignment: '=' -- RHS elements follows
42 explist1: begin
43 expr:
44 prefixexp: <name>
45 str_checkname: 'foo'
46 singlevar(kind): 'VLOCAL'
47 explist1: end
48 -- STATEMENT: end 'expr'
49
50 leaveblock
51 block: end
52 do_stat: end
53 -- STATEMENT: end 'do'
54
55 -- STATEMENT: begin 'expr' line=5
56 prefixexp: <name>
57 str_checkname: 'baz'
58 singlevar(kind): 'VGLOBAL'
59 expr_stat: assignment k='VGLOBAL'
60 assignment: '=' -- RHS elements follows
61 explist1: begin
62 expr:
63 prefixexp: <name>
64 str_checkname: 'foo'
65 singlevar(kind): 'VGLOBAL'
66 explist1: end
67 -- STATEMENT: end 'expr'
68
69 close_func
70-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_24.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_24.lua
deleted file mode 100644
index 6403234..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_24.lua
+++ /dev/null
@@ -1,84 +0,0 @@
1-- START OF SOURCE --
2 local foo
3 local function bar()
4 baz = nil
5 foo = bar()
6 end
7 foo = bar
8-- END OF SOURCE --
9
10-- TOP: begin
11 open_func
12
13 chunk:
14 -- STATEMENT: begin 'local' line=1
15 local_stat: local statement
16 localstat: begin
17 str_checkname: 'foo'
18 new_localvar: 'foo'
19 localstat: end
20 -- STATEMENT: end 'local'
21
22 -- STATEMENT: begin 'local' line=2
23 local_stat: local function
24 localfunc: begin
25 str_checkname: 'bar'
26 new_localvar: 'bar'
27 localfunc: body
28 open_func
29 body: begin
30 body: parlist
31 parlist: begin
32 parlist: end
33 body: chunk
34 chunk:
35 -- STATEMENT: begin 'expr' line=3
36 prefixexp: <name>
37 str_checkname: 'baz'
38 singlevar(kind): 'VGLOBAL'
39 expr_stat: assignment k='VGLOBAL'
40 assignment: '=' -- RHS elements follows
41 explist1: begin
42 expr:
43 simpleexp: nil
44 explist1: end
45 -- STATEMENT: end 'expr'
46
47 -- STATEMENT: begin 'expr' line=4
48 prefixexp: <name>
49 str_checkname: 'foo'
50 singlevar(kind): 'VUPVAL'
51 expr_stat: assignment k='VUPVAL'
52 assignment: '=' -- RHS elements follows
53 explist1: begin
54 expr:
55 prefixexp: <name>
56 str_checkname: 'bar'
57 singlevar(kind): 'VUPVAL'
58 primaryexp: ( funcargs
59 funcargs: begin '('
60 funcargs: end -- expr is a VCALL
61 explist1: end
62 -- STATEMENT: end 'expr'
63
64 body: end
65 close_func
66 localfunc: end
67 -- STATEMENT: end 'local'
68
69 -- STATEMENT: begin 'expr' line=6
70 prefixexp: <name>
71 str_checkname: 'foo'
72 singlevar(kind): 'VLOCAL'
73 expr_stat: assignment k='VLOCAL'
74 assignment: '=' -- RHS elements follows
75 explist1: begin
76 expr:
77 prefixexp: <name>
78 str_checkname: 'bar'
79 singlevar(kind): 'VLOCAL'
80 explist1: end
81 -- STATEMENT: end 'expr'
82
83 close_func
84-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_25.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_25.lua
deleted file mode 100644
index 594e267..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_25.lua
+++ /dev/null
@@ -1,159 +0,0 @@
1-- START OF SOURCE --
2 local foo
3 local function bar()
4 local function baz()
5 local foo, bar
6 foo = bar
7 foo = baz
8 end
9 foo = bar
10 foo = baz
11 end
12 foo = bar
13 foo = baz
14-- END OF SOURCE --
15
16-- TOP: begin
17 open_func
18
19 chunk:
20 -- STATEMENT: begin 'local' line=1
21 local_stat: local statement
22 localstat: begin
23 str_checkname: 'foo'
24 new_localvar: 'foo'
25 localstat: end
26 -- STATEMENT: end 'local'
27
28 -- STATEMENT: begin 'local' line=2
29 local_stat: local function
30 localfunc: begin
31 str_checkname: 'bar'
32 new_localvar: 'bar'
33 localfunc: body
34 open_func
35 body: begin
36 body: parlist
37 parlist: begin
38 parlist: end
39 body: chunk
40 chunk:
41 -- STATEMENT: begin 'local' line=3
42 local_stat: local function
43 localfunc: begin
44 str_checkname: 'baz'
45 new_localvar: 'baz'
46 localfunc: body
47 open_func
48 body: begin
49 body: parlist
50 parlist: begin
51 parlist: end
52 body: chunk
53 chunk:
54 -- STATEMENT: begin 'local' line=4
55 local_stat: local statement
56 localstat: begin
57 str_checkname: 'foo'
58 new_localvar: 'foo'
59 str_checkname: 'bar'
60 new_localvar: 'bar'
61 localstat: end
62 -- STATEMENT: end 'local'
63
64 -- STATEMENT: begin 'expr' line=5
65 prefixexp: <name>
66 str_checkname: 'foo'
67 singlevar(kind): 'VLOCAL'
68 expr_stat: assignment k='VLOCAL'
69 assignment: '=' -- RHS elements follows
70 explist1: begin
71 expr:
72 prefixexp: <name>
73 str_checkname: 'bar'
74 singlevar(kind): 'VLOCAL'
75 explist1: end
76 -- STATEMENT: end 'expr'
77
78 -- STATEMENT: begin 'expr' line=6
79 prefixexp: <name>
80 str_checkname: 'foo'
81 singlevar(kind): 'VLOCAL'
82 expr_stat: assignment k='VLOCAL'
83 assignment: '=' -- RHS elements follows
84 explist1: begin
85 expr:
86 prefixexp: <name>
87 str_checkname: 'baz'
88 singlevar(kind): 'VUPVAL'
89 explist1: end
90 -- STATEMENT: end 'expr'
91
92 body: end
93 close_func
94 localfunc: end
95 -- STATEMENT: end 'local'
96
97 -- STATEMENT: begin 'expr' line=8
98 prefixexp: <name>
99 str_checkname: 'foo'
100 singlevar(kind): 'VUPVAL'
101 expr_stat: assignment k='VUPVAL'
102 assignment: '=' -- RHS elements follows
103 explist1: begin
104 expr:
105 prefixexp: <name>
106 str_checkname: 'bar'
107 singlevar(kind): 'VUPVAL'
108 explist1: end
109 -- STATEMENT: end 'expr'
110
111 -- STATEMENT: begin 'expr' line=9
112 prefixexp: <name>
113 str_checkname: 'foo'
114 singlevar(kind): 'VUPVAL'
115 expr_stat: assignment k='VUPVAL'
116 assignment: '=' -- RHS elements follows
117 explist1: begin
118 expr:
119 prefixexp: <name>
120 str_checkname: 'baz'
121 singlevar(kind): 'VLOCAL'
122 explist1: end
123 -- STATEMENT: end 'expr'
124
125 body: end
126 close_func
127 localfunc: end
128 -- STATEMENT: end 'local'
129
130 -- STATEMENT: begin 'expr' line=11
131 prefixexp: <name>
132 str_checkname: 'foo'
133 singlevar(kind): 'VLOCAL'
134 expr_stat: assignment k='VLOCAL'
135 assignment: '=' -- RHS elements follows
136 explist1: begin
137 expr:
138 prefixexp: <name>
139 str_checkname: 'bar'
140 singlevar(kind): 'VLOCAL'
141 explist1: end
142 -- STATEMENT: end 'expr'
143
144 -- STATEMENT: begin 'expr' line=12
145 prefixexp: <name>
146 str_checkname: 'foo'
147 singlevar(kind): 'VLOCAL'
148 expr_stat: assignment k='VLOCAL'
149 assignment: '=' -- RHS elements follows
150 explist1: begin
151 expr:
152 prefixexp: <name>
153 str_checkname: 'baz'
154 singlevar(kind): 'VGLOBAL'
155 explist1: end
156 -- STATEMENT: end 'expr'
157
158 close_func
159-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_26.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_26.lua
deleted file mode 100644
index bfa3920..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_26.lua
+++ /dev/null
@@ -1,53 +0,0 @@
1-- START OF SOURCE --
2 function foo:bar()
3 print(self)
4 end
5-- END OF SOURCE --
6
7-- TOP: begin
8 open_func
9
10 chunk:
11 -- STATEMENT: begin 'function' line=1
12 function_stat: begin
13 funcname: begin
14 str_checkname: 'foo'
15 singlevar(kind): 'VGLOBAL'
16 funcname: -- ':' field
17 field: operator=:
18 checkname:
19 str_checkname: 'bar'
20 codestring: "bar"
21 funcname: end
22 function_stat: body needself='true'
23 open_func
24 body: begin
25 new_localvar: 'self'
26 body: parlist
27 parlist: begin
28 parlist: end
29 body: chunk
30 chunk:
31 -- STATEMENT: begin 'expr' line=2
32 prefixexp: <name>
33 str_checkname: 'print'
34 singlevar(kind): 'VGLOBAL'
35 primaryexp: ( funcargs
36 funcargs: begin '('
37 explist1: begin
38 expr:
39 prefixexp: <name>
40 str_checkname: 'self'
41 singlevar(kind): 'VLOCAL'
42 explist1: end
43 funcargs: end -- expr is a VCALL
44 expr_stat: function call k='VCALL'
45 -- STATEMENT: end 'expr'
46
47 body: end
48 close_func
49 function_stat: end
50 -- STATEMENT: end 'function'
51
52 close_func
53-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_27.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_27.lua
deleted file mode 100644
index 77db3ef..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_27.lua
+++ /dev/null
@@ -1,48 +0,0 @@
1-- START OF SOURCE --
2 function foo(...)
3 print(arg)
4 end
5-- END OF SOURCE --
6
7-- TOP: begin
8 open_func
9
10 chunk:
11 -- STATEMENT: begin 'function' line=1
12 function_stat: begin
13 funcname: begin
14 str_checkname: 'foo'
15 singlevar(kind): 'VGLOBAL'
16 funcname: end
17 function_stat: body needself='false'
18 open_func
19 body: begin
20 body: parlist
21 parlist: begin
22 parlist: ... (dots)
23 parlist: end
24 body: chunk
25 chunk:
26 -- STATEMENT: begin 'expr' line=2
27 prefixexp: <name>
28 str_checkname: 'print'
29 singlevar(kind): 'VGLOBAL'
30 primaryexp: ( funcargs
31 funcargs: begin '('
32 explist1: begin
33 expr:
34 prefixexp: <name>
35 str_checkname: 'arg'
36 singlevar(kind): 'VGLOBAL'
37 explist1: end
38 funcargs: end -- expr is a VCALL
39 expr_stat: function call k='VCALL'
40 -- STATEMENT: end 'expr'
41
42 body: end
43 close_func
44 function_stat: end
45 -- STATEMENT: end 'function'
46
47 close_func
48-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_28.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_28.lua
deleted file mode 100644
index e4c9e21..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_28.lua
+++ /dev/null
@@ -1,79 +0,0 @@
1-- START OF SOURCE --
2 local c,d
3 function foo(a,b,c)
4 print(a,c,d,e)
5 end
6-- END OF SOURCE --
7
8-- TOP: begin
9 open_func
10
11 chunk:
12 -- STATEMENT: begin 'local' line=1
13 local_stat: local statement
14 localstat: begin
15 str_checkname: 'c'
16 new_localvar: 'c'
17 str_checkname: 'd'
18 new_localvar: 'd'
19 localstat: end
20 -- STATEMENT: end 'local'
21
22 -- STATEMENT: begin 'function' line=2
23 function_stat: begin
24 funcname: begin
25 str_checkname: 'foo'
26 singlevar(kind): 'VGLOBAL'
27 funcname: end
28 function_stat: body needself='false'
29 open_func
30 body: begin
31 body: parlist
32 parlist: begin
33 str_checkname: 'a'
34 new_localvar: 'a'
35 str_checkname: 'b'
36 new_localvar: 'b'
37 str_checkname: 'c'
38 new_localvar: 'c'
39 parlist: end
40 body: chunk
41 chunk:
42 -- STATEMENT: begin 'expr' line=3
43 prefixexp: <name>
44 str_checkname: 'print'
45 singlevar(kind): 'VGLOBAL'
46 primaryexp: ( funcargs
47 funcargs: begin '('
48 explist1: begin
49 expr:
50 prefixexp: <name>
51 str_checkname: 'a'
52 singlevar(kind): 'VLOCAL'
53 explist1: ',' -- continuation
54 expr:
55 prefixexp: <name>
56 str_checkname: 'c'
57 singlevar(kind): 'VLOCAL'
58 explist1: ',' -- continuation
59 expr:
60 prefixexp: <name>
61 str_checkname: 'd'
62 singlevar(kind): 'VUPVAL'
63 explist1: ',' -- continuation
64 expr:
65 prefixexp: <name>
66 str_checkname: 'e'
67 singlevar(kind): 'VGLOBAL'
68 explist1: end
69 funcargs: end -- expr is a VCALL
70 expr_stat: function call k='VCALL'
71 -- STATEMENT: end 'expr'
72
73 body: end
74 close_func
75 function_stat: end
76 -- STATEMENT: end 'function'
77
78 close_func
79-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_29.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_29.lua
deleted file mode 100644
index b278ba2..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_29.lua
+++ /dev/null
@@ -1,94 +0,0 @@
1-- START OF SOURCE --
2 function foo(a,b)
3 local bar = function(c,d)
4 print(a,b,c,d)
5 end
6 end
7-- END OF SOURCE --
8
9-- TOP: begin
10 open_func
11
12 chunk:
13 -- STATEMENT: begin 'function' line=1
14 function_stat: begin
15 funcname: begin
16 str_checkname: 'foo'
17 singlevar(kind): 'VGLOBAL'
18 funcname: end
19 function_stat: body needself='false'
20 open_func
21 body: begin
22 body: parlist
23 parlist: begin
24 str_checkname: 'a'
25 new_localvar: 'a'
26 str_checkname: 'b'
27 new_localvar: 'b'
28 parlist: end
29 body: chunk
30 chunk:
31 -- STATEMENT: begin 'local' line=2
32 local_stat: local statement
33 localstat: begin
34 str_checkname: 'bar'
35 new_localvar: 'bar'
36 localstat: -- assignment
37 explist1: begin
38 expr:
39 simpleexp: function
40 open_func
41 body: begin
42 body: parlist
43 parlist: begin
44 str_checkname: 'c'
45 new_localvar: 'c'
46 str_checkname: 'd'
47 new_localvar: 'd'
48 parlist: end
49 body: chunk
50 chunk:
51 -- STATEMENT: begin 'expr' line=3
52 prefixexp: <name>
53 str_checkname: 'print'
54 singlevar(kind): 'VGLOBAL'
55 primaryexp: ( funcargs
56 funcargs: begin '('
57 explist1: begin
58 expr:
59 prefixexp: <name>
60 str_checkname: 'a'
61 singlevar(kind): 'VUPVAL'
62 explist1: ',' -- continuation
63 expr:
64 prefixexp: <name>
65 str_checkname: 'b'
66 singlevar(kind): 'VUPVAL'
67 explist1: ',' -- continuation
68 expr:
69 prefixexp: <name>
70 str_checkname: 'c'
71 singlevar(kind): 'VLOCAL'
72 explist1: ',' -- continuation
73 expr:
74 prefixexp: <name>
75 str_checkname: 'd'
76 singlevar(kind): 'VLOCAL'
77 explist1: end
78 funcargs: end -- expr is a VCALL
79 expr_stat: function call k='VCALL'
80 -- STATEMENT: end 'expr'
81
82 body: end
83 close_func
84 explist1: end
85 localstat: end
86 -- STATEMENT: end 'local'
87
88 body: end
89 close_func
90 function_stat: end
91 -- STATEMENT: end 'function'
92
93 close_func
94-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_30.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_30.lua
deleted file mode 100644
index 3807d14..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_30.lua
+++ /dev/null
@@ -1,119 +0,0 @@
1-- START OF SOURCE --
2 for i = 1,10 do
3 print(i)
4 end
5 for i = 1,10,-2 do
6 print(i)
7 end
8-- END OF SOURCE --
9
10-- TOP: begin
11 open_func
12
13 chunk:
14 -- STATEMENT: begin 'for' line=1
15 for_stat: begin
16 enterblock(isbreakable=true)
17 str_checkname: 'i'
18 for_stat: numerical loop
19 new_localvar: '(for index)'
20 new_localvar: '(for limit)'
21 new_localvar: '(for step)'
22 new_localvar: 'i'
23 fornum: begin
24 fornum: index start
25 exp1: begin
26 expr:
27 simpleexp: <number>=1
28 exp1: end
29 fornum: index stop
30 exp1: begin
31 expr:
32 simpleexp: <number>=10
33 exp1: end
34 fornum: body
35 enterblock(isbreakable=false)
36 block: begin
37 enterblock(isbreakable=false)
38 chunk:
39 -- STATEMENT: begin 'expr' line=2
40 prefixexp: <name>
41 str_checkname: 'print'
42 singlevar(kind): 'VGLOBAL'
43 primaryexp: ( funcargs
44 funcargs: begin '('
45 explist1: begin
46 expr:
47 prefixexp: <name>
48 str_checkname: 'i'
49 singlevar(kind): 'VLOCAL'
50 explist1: end
51 funcargs: end -- expr is a VCALL
52 expr_stat: function call k='VCALL'
53 -- STATEMENT: end 'expr'
54
55 leaveblock
56 block: end
57 leaveblock
58 fornum: end
59 leaveblock
60 for_stat: end
61 -- STATEMENT: end 'for'
62
63 -- STATEMENT: begin 'for' line=4
64 for_stat: begin
65 enterblock(isbreakable=true)
66 str_checkname: 'i'
67 for_stat: numerical loop
68 new_localvar: '(for index)'
69 new_localvar: '(for limit)'
70 new_localvar: '(for step)'
71 new_localvar: 'i'
72 fornum: begin
73 fornum: index start
74 exp1: begin
75 expr:
76 simpleexp: <number>=1
77 exp1: end
78 fornum: index stop
79 exp1: begin
80 expr:
81 simpleexp: <number>=10
82 exp1: end
83 fornum: index step
84 exp1: begin
85 expr:
86 subexpr: uop='-'
87 simpleexp: <number>=2
88 exp1: end
89 fornum: body
90 enterblock(isbreakable=false)
91 block: begin
92 enterblock(isbreakable=false)
93 chunk:
94 -- STATEMENT: begin 'expr' line=5
95 prefixexp: <name>
96 str_checkname: 'print'
97 singlevar(kind): 'VGLOBAL'
98 primaryexp: ( funcargs
99 funcargs: begin '('
100 explist1: begin
101 expr:
102 prefixexp: <name>
103 str_checkname: 'i'
104 singlevar(kind): 'VLOCAL'
105 explist1: end
106 funcargs: end -- expr is a VCALL
107 expr_stat: function call k='VCALL'
108 -- STATEMENT: end 'expr'
109
110 leaveblock
111 block: end
112 leaveblock
113 fornum: end
114 leaveblock
115 for_stat: end
116 -- STATEMENT: end 'for'
117
118 close_func
119-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_31.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_31.lua
deleted file mode 100644
index 0d0a602..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_31.lua
+++ /dev/null
@@ -1,127 +0,0 @@
1-- START OF SOURCE --
2 for foo in bar() do
3 print(foo)
4 end
5 for foo,bar,baz in spring() do
6 print(foo,bar,baz)
7 end
8-- END OF SOURCE --
9
10-- TOP: begin
11 open_func
12
13 chunk:
14 -- STATEMENT: begin 'for' line=1
15 for_stat: begin
16 enterblock(isbreakable=true)
17 str_checkname: 'foo'
18 for_stat: list-based loop
19 forlist: begin
20 new_localvar: '(for generator)'
21 new_localvar: '(for state)'
22 new_localvar: '(for control)'
23 new_localvar: 'foo'
24 forlist: explist1
25 explist1: begin
26 expr:
27 prefixexp: <name>
28 str_checkname: 'bar'
29 singlevar(kind): 'VGLOBAL'
30 primaryexp: ( funcargs
31 funcargs: begin '('
32 funcargs: end -- expr is a VCALL
33 explist1: end
34 forlist: body
35 enterblock(isbreakable=false)
36 block: begin
37 enterblock(isbreakable=false)
38 chunk:
39 -- STATEMENT: begin 'expr' line=2
40 prefixexp: <name>
41 str_checkname: 'print'
42 singlevar(kind): 'VGLOBAL'
43 primaryexp: ( funcargs
44 funcargs: begin '('
45 explist1: begin
46 expr:
47 prefixexp: <name>
48 str_checkname: 'foo'
49 singlevar(kind): 'VLOCAL'
50 explist1: end
51 funcargs: end -- expr is a VCALL
52 expr_stat: function call k='VCALL'
53 -- STATEMENT: end 'expr'
54
55 leaveblock
56 block: end
57 leaveblock
58 forlist: end
59 leaveblock
60 for_stat: end
61 -- STATEMENT: end 'for'
62
63 -- STATEMENT: begin 'for' line=4
64 for_stat: begin
65 enterblock(isbreakable=true)
66 str_checkname: 'foo'
67 for_stat: list-based loop
68 forlist: begin
69 new_localvar: '(for generator)'
70 new_localvar: '(for state)'
71 new_localvar: '(for control)'
72 new_localvar: 'foo'
73 str_checkname: 'bar'
74 new_localvar: 'bar'
75 str_checkname: 'baz'
76 new_localvar: 'baz'
77 forlist: explist1
78 explist1: begin
79 expr:
80 prefixexp: <name>
81 str_checkname: 'spring'
82 singlevar(kind): 'VGLOBAL'
83 primaryexp: ( funcargs
84 funcargs: begin '('
85 funcargs: end -- expr is a VCALL
86 explist1: end
87 forlist: body
88 enterblock(isbreakable=false)
89 block: begin
90 enterblock(isbreakable=false)
91 chunk:
92 -- STATEMENT: begin 'expr' line=5
93 prefixexp: <name>
94 str_checkname: 'print'
95 singlevar(kind): 'VGLOBAL'
96 primaryexp: ( funcargs
97 funcargs: begin '('
98 explist1: begin
99 expr:
100 prefixexp: <name>
101 str_checkname: 'foo'
102 singlevar(kind): 'VLOCAL'
103 explist1: ',' -- continuation
104 expr:
105 prefixexp: <name>
106 str_checkname: 'bar'
107 singlevar(kind): 'VLOCAL'
108 explist1: ',' -- continuation
109 expr:
110 prefixexp: <name>
111 str_checkname: 'baz'
112 singlevar(kind): 'VLOCAL'
113 explist1: end
114 funcargs: end -- expr is a VCALL
115 expr_stat: function call k='VCALL'
116 -- STATEMENT: end 'expr'
117
118 leaveblock
119 block: end
120 leaveblock
121 forlist: end
122 leaveblock
123 for_stat: end
124 -- STATEMENT: end 'for'
125
126 close_func
127-- TOP: end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/test_llex_mk2.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/test_llex_mk2.lua
deleted file mode 100644
index e9ad45f..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/test_llex_mk2.lua
+++ /dev/null
@@ -1,566 +0,0 @@
1--[[--------------------------------------------------------------------
2
3 test_llex_mk2.lua
4 Test for llex_mk2.lua
5 This file is part of Yueliang.
6
7 Copyright (c) 2008 Kein-Hong Man <khman@users.sf.net>
8 The COPYRIGHT file describes the conditions
9 under which this software may be distributed.
10
11 See the ChangeLog for more information.
12
13----------------------------------------------------------------------]]
14
15------------------------------------------------------------------------
16-- if BRIEF is not set to false, auto-test will silently succeed
17------------------------------------------------------------------------
18BRIEF = true -- if set to true, messages are less verbose
19
20package.path = "../?.lua;"..package.path
21local llex = require "llex_mk2"
22
23------------------------------------------------------------------------
24-- simple manual tests
25------------------------------------------------------------------------
26
27--[[
28local function dump(z)
29 llex.init(z)
30 while true do
31 local token, seminfo = llex.llex()
32 if token == "<name>" then
33 seminfo = " "..seminfo
34 elseif token == "<number>" then
35 seminfo = " "..seminfo
36 elseif token == "<string>" then
37 seminfo = " '"..seminfo.."'"
38 else
39 seminfo = ""
40 end
41 io.stdout:write(token..seminfo.."\n")
42 if token == "<eof>" then break end
43 end
44end
45
46dump("local c = luaZ:zgetc(z)")
47os.exit()
48--]]
49
50------------------------------------------------------------------------
51-- auto-testing of simple test cases to validate lexer behaviour:
52-- * NOTE coverage has not been checked; not comprehensive
53-- * only test cases with non-empty comments are processed
54-- * if no result, then the output is displayed for manual decision
55-- (output may be used to set expected success or fail text)
56-- * cases expected to be successful may be a partial match
57-- * cases expected to fail may also be a partial match
58------------------------------------------------------------------------
59
60-- [=====[
61local function auto_test()
62 local PASS, FAIL = true, false
63 ------------------------------------------------------------------
64 -- table of test cases
65 ------------------------------------------------------------------
66 local test_cases =
67 {
68 -------------------------------------------------------------
69 --{ "comment", -- comment about the test
70 -- "chunk", -- chunk to test
71 -- PASS, -- PASS or FAIL outcome
72 -- "output", -- output to compare against
73 --},
74 -------------------------------------------------------------
75 { "empty chunk string, test EOS",
76 "",
77 PASS, "1 <eof>",
78 },
79 -------------------------------------------------------------
80 { "line number counting",
81 "\n\n\r\n",
82 PASS, "4 <eof>",
83 },
84 -------------------------------------------------------------
85 { "various whitespaces",
86 " \n\t\t\n \t \t \n\n",
87 PASS, "5 <eof>",
88 },
89 -------------------------------------------------------------
90 { "short comment ending in EOS",
91 "-- moo moo",
92 PASS, "1 <eof>",
93 },
94 -------------------------------------------------------------
95 { "short comment ending in newline",
96 "-- moo moo\n",
97 PASS, "2 <eof>",
98 },
99 -------------------------------------------------------------
100 { "several lines of short comments",
101 "--moo\n-- moo moo\n\n--\tmoo\n",
102 PASS, "5 <eof>",
103 },
104 -------------------------------------------------------------
105 { "basic block comment 1",
106 "--[[bovine]]",
107 PASS, "1 <eof>",
108 },
109 -------------------------------------------------------------
110 { "basic block comment 2",
111 "--[=[bovine]=]",
112 PASS, "1 <eof>",
113 },
114 -------------------------------------------------------------
115 { "basic block comment 3",
116 "--[====[-[[bovine]]-]====]",
117 PASS, "1 <eof>",
118 },
119 -------------------------------------------------------------
120 { "unterminated block comment 1",
121 "--[[bovine",
122 FAIL, ":1: unfinished long comment",
123 },
124 -------------------------------------------------------------
125 { "unterminated block comment 2",
126 "--[==[bovine",
127 FAIL, ":1: unfinished long comment",
128 },
129 -------------------------------------------------------------
130 { "unterminated block comment 3",
131 "--[[bovine]",
132 FAIL, ":1: unfinished long comment",
133 },
134 -------------------------------------------------------------
135 { "unterminated block comment 4",
136 "--[[bovine\nmoo moo\nwoof",
137 FAIL, ":3: unfinished long comment",
138 },
139 -------------------------------------------------------------
140 { "basic long string 1",
141 "\n[[bovine]]\n",
142 PASS, "2 <string> = bovine\n3 <eof>",
143 },
144 -------------------------------------------------------------
145 { "basic long string 2",
146 "\n[=[bovine]=]\n",
147 PASS, "2 <string> = bovine\n3 <eof>",
148 },
149 -------------------------------------------------------------
150 { "first newline consumed in long string",
151 "[[\nmoo]]",
152 PASS, "2 <string> = moo\n2 <eof>",
153 },
154 -------------------------------------------------------------
155 { "multiline long string 1",
156 "[[moo\nmoo moo\n]]",
157 PASS, "3 <string> = moo\nmoo moo\n\n3 <eof>",
158 },
159 -------------------------------------------------------------
160 { "multiline long string 2",
161 "[===[moo\n[=[moo moo]=]\n]===]",
162 PASS, "3 <string> = moo\n[=[moo moo]=]\n\n3 <eof>",
163 },
164 -------------------------------------------------------------
165 { "unterminated long string 1",
166 "\n[[\nbovine",
167 FAIL, ":3: unfinished long string",
168 },
169 -------------------------------------------------------------
170 { "unterminated long string 2",
171 "[[bovine]",
172 FAIL, ":1: unfinished long string",
173 },
174 -------------------------------------------------------------
175 { "unterminated long string 2",
176 "[==[bovine]==",
177 FAIL, ":1: unfinished long string",
178 },
179 -------------------------------------------------------------
180 { "complex long string 1",
181 "[=[moo[[moo]]moo]=]",
182 PASS, "moo[[moo]]moo",
183 },
184 -------------------------------------------------------------
185 { "complex long string 2",
186 "[=[moo[[moo[[[[]]]]moo]]moo]=]",
187 PASS, "moo[[moo[[[[]]]]moo]]moo",
188 },
189 -------------------------------------------------------------
190 { "complex long string 3",
191 "[=[[[[[]]]][[[[]]]]]=]",
192 PASS, "[[[[]]]][[[[]]]]",
193 },
194 -------------------------------------------------------------
195 -- NOTE: this native lexer does not support compatible long
196 -- strings (LUA_COMPAT_LSTR)
197 -------------------------------------------------------------
198 --{ "deprecated long string 1",
199 -- "[[moo[[moo]]moo]]",
200 -- FAIL, ":1: nesting of [[...]] is deprecated near '['",
201 --},
202 ---------------------------------------------------------------
203 --{ "deprecated long string 2",
204 -- "[[[[ \n",
205 -- FAIL, ":1: nesting of [[...]] is deprecated near '['",
206 --},
207 ---------------------------------------------------------------
208 --{ "deprecated long string 3",
209 -- "[[moo[[moo[[[[]]]]moo]]moo]]",
210 -- FAIL, ":1: nesting of [[...]] is deprecated near '['",
211 --},
212 ---------------------------------------------------------------
213 --{ "deprecated long string 4",
214 -- "[[[[[[]]]][[[[]]]]]]",
215 -- FAIL, ":1: nesting of [[...]] is deprecated near '['",
216 --},
217 -------------------------------------------------------------
218 { "brackets in long strings 1",
219 "[[moo[moo]]",
220 PASS, "moo[moo",
221 },
222 -------------------------------------------------------------
223 { "brackets in long strings 2",
224 "[=[moo[[moo]moo]]moo]=]",
225 PASS, "moo[[moo]moo]]moo",
226 },
227 -------------------------------------------------------------
228 { "unprocessed escapes in long strings",
229 [[ [=[\a\b\f\n\r\t\v\123]=] ]],
230 PASS, [[\a\b\f\n\r\t\v\123]],
231 },
232 -------------------------------------------------------------
233 { "unbalanced long string",
234 "[[moo]]moo]]",
235 PASS, "1 <string> = moo\n1 <name> = moo\n1 CHAR = ']'\n1 CHAR = ']'\n1 <eof>",
236 },
237 -------------------------------------------------------------
238 { "keywords 1",
239 "and break do else",
240 PASS, "1 and\n1 break\n1 do\n1 else\n1 <eof>",
241 },
242 -------------------------------------------------------------
243 { "keywords 2",
244 "elseif end false for",
245 PASS, "1 elseif\n1 end\n1 false\n1 for\n1 <eof>",
246 },
247 -------------------------------------------------------------
248 { "keywords 3",
249 "function if in local nil",
250 PASS, "1 function\n1 if\n1 in\n1 local\n1 nil\n1 <eof>",
251 },
252 -------------------------------------------------------------
253 { "keywords 4",
254 "not or repeat return",
255 PASS, "1 not\n1 or\n1 repeat\n1 return\n1 <eof>",
256 },
257 -------------------------------------------------------------
258 { "keywords 5",
259 "then true until while",
260 PASS, "1 then\n1 true\n1 until\n1 while\n1 <eof>",
261 },
262 -------------------------------------------------------------
263 { "concat and dots",
264 ".. ...",
265 PASS, "1 ..\n1 ...\n1 <eof>",
266 },
267 -------------------------------------------------------------
268 -- NOTE: in Lua 5.1.x, shbang handling is no longer performed
269 -- in the lexer; it is now done in lauxlib.c (luaL_loadfile)
270 -- so the following cannot be performed by the lexer...
271 -------------------------------------------------------------
272 --{ "shbang handling 1",
273 -- "#blahblah",
274 -- PASS, "1 <eof>",
275 --},
276 -------------------------------------------------------------
277 --{ "shbang handling 2",
278 -- "#blahblah\nmoo moo\n",
279 -- PASS, "2 <name> = moo\n2 <name> = moo\n3 <eof>",
280 --},
281 -------------------------------------------------------------
282 { "empty string",
283 [['']],
284 PASS, "1 <string> = \n1 <eof>",
285 },
286 -------------------------------------------------------------
287 { "single-quoted string",
288 [['bovine']],
289 PASS, "1 <string> = bovine\n1 <eof>",
290 },
291 -------------------------------------------------------------
292 { "double-quoted string",
293 [["bovine"]],
294 PASS, "1 <string> = bovine\n1 <eof>",
295 },
296 -------------------------------------------------------------
297 { "unterminated string 1",
298 [['moo ]],
299 FAIL, ":1: unfinished string",
300 },
301 -------------------------------------------------------------
302 { "unterminated string 2",
303 [["moo \n]],
304 FAIL, ":1: unfinished string",
305 },
306 -------------------------------------------------------------
307 { "escaped newline in string, line number counted",
308 "\"moo\\\nmoo\\\nmoo\"",
309 PASS, "3 <string> = moo\nmoo\nmoo\n3 <eof>",
310 },
311 -------------------------------------------------------------
312 { "escaped characters in string 1",
313 [["moo\amoo"]],
314 PASS, "1 <string> = moo\amoo",
315 },
316 -------------------------------------------------------------
317 { "escaped characters in string 2",
318 [["moo\bmoo"]],
319 PASS, "1 <string> = moo\bmoo",
320 },
321 -------------------------------------------------------------
322 { "escaped characters in string 3",
323 [["moo\f\n\r\t\vmoo"]],
324 PASS, "1 <string> = moo\f\n\r\t\vmoo",
325 },
326 -------------------------------------------------------------
327 { "escaped characters in string 4",
328 [["\\ \" \' \? \[ \]"]],
329 PASS, "1 <string> = \\ \" \' \? \[ \]",
330 },
331 -------------------------------------------------------------
332 { "escaped characters in string 5",
333 [["\z \k \: \;"]],
334 PASS, "1 <string> = z k : ;",
335 },
336 -------------------------------------------------------------
337 { "escaped characters in string 6",
338 [["\8 \65 \160 \180K \097097"]],
339 PASS, "1 <string> = \8 \65 \160 \180K \097097\n",
340 },
341 -------------------------------------------------------------
342 { "escaped characters in string 7",
343 [["\666"]],
344 FAIL, ":1: escape sequence too large",
345 },
346 -------------------------------------------------------------
347 { "simple numbers",
348 "123 123+",
349 PASS, "1 <number> = 123\n1 <number> = 123\n1 CHAR = '+'\n1 <eof>",
350 },
351 -------------------------------------------------------------
352 { "longer numbers",
353 "1234567890 12345678901234567890",
354 PASS, "1 <number> = 1234567890\n1 <number> = 1.2345678901235e+19\n",
355 },
356 -------------------------------------------------------------
357 { "fractional numbers",
358 ".123 .12345678901234567890",
359 PASS, "1 <number> = 0.123\n1 <number> = 0.12345678901235\n",
360 },
361 -------------------------------------------------------------
362 { "more numbers with decimal points",
363 "12345.67890",
364 PASS, "1 <number> = 12345.6789\n",
365 },
366 -------------------------------------------------------------
367 { "malformed number with decimal points",
368 "1.1.",
369 FAIL, ":1: malformed number",
370 },
371 -------------------------------------------------------------
372 { "double decimal points",
373 ".1.1",
374 FAIL, ":1: malformed number",
375 },
376 -------------------------------------------------------------
377 { "double dots within numbers",
378 "1..1",
379 FAIL, ":1: malformed number",
380 },
381 -------------------------------------------------------------
382 { "incomplete exponential numbers",
383 "123e",
384 FAIL, ":1: malformed number",
385 },
386 -------------------------------------------------------------
387 { "exponential numbers 1",
388 "1234e5 1234e5.",
389 PASS, "1 <number> = 123400000\n1 <number> = 123400000\n1 CHAR = '.'",
390 },
391 -------------------------------------------------------------
392 { "exponential numbers 2",
393 "1234e56 1.23e123",
394 PASS, "1 <number> = 1.234e+59\n1 <number> = 1.23e+123\n",
395 },
396 -------------------------------------------------------------
397 { "exponential numbers 3",
398 "12.34e+",
399 FAIL, ":1: malformed number",
400 },
401 -------------------------------------------------------------
402 { "exponential numbers 4",
403 "12.34e+5 123.4e-5 1234.E+5",
404 PASS, "1 <number> = 1234000\n1 <number> = 0.001234\n1 <number> = 123400000\n",
405 },
406 -------------------------------------------------------------
407 { "hexadecimal numbers",
408 "0x00FF 0X1234 0xDEADBEEF",
409 PASS, "1 <number> = 255\n1 <number> = 4660\n1 <number> = 3735928559\n",
410 },
411 -------------------------------------------------------------
412 { "invalid hexadecimal numbers 1",
413 "0xFOO",
414 FAIL, ":1: malformed number",
415 },
416 -------------------------------------------------------------
417 { "invalid hexadecimal numbers 2",
418 "0.BAR",
419 FAIL, ":1: malformed number",
420 },
421 -------------------------------------------------------------
422 { "invalid hexadecimal numbers 3",
423 "0BAZ",
424 FAIL, ":1: malformed number",
425 },
426 -------------------------------------------------------------
427 { "single character symbols 1",
428 "= > < ~ #",
429 PASS, "1 CHAR = '='\n1 CHAR = '>'\n1 CHAR = '<'\n1 CHAR = '~'\n1 CHAR = '#'\n",
430 },
431 -------------------------------------------------------------
432 { "double character symbols",
433 "== >= <= ~=",
434 PASS, "1 ==\n1 >=\n1 <=\n1 ~=\n",
435 },
436 -------------------------------------------------------------
437 { "simple identifiers",
438 "abc ABC",
439 PASS, "1 <name> = abc\n1 <name> = ABC\n1 <eof>",
440 },
441 -------------------------------------------------------------
442 { "more identifiers",
443 "_abc _ABC",
444 PASS, "1 <name> = _abc\n1 <name> = _ABC\n1 <eof>",
445 },
446 -------------------------------------------------------------
447 { "still more identifiers",
448 "_aB_ _123",
449 PASS, "1 <name> = _aB_\n1 <name> = _123\n1 <eof>",
450 },
451 -------------------------------------------------------------
452 -- NOTE: in Lua 5.1.x, this test is no longer performed
453 -------------------------------------------------------------
454 --{ "invalid control character",
455 -- "\4",
456 -- FAIL, ":1: invalid control char near 'char(4)'",
457 --},
458 -------------------------------------------------------------
459 { "single character symbols 2",
460 "` ! @ $ %",
461 PASS, "1 CHAR = '`'\n1 CHAR = '!'\n1 CHAR = '@'\n1 CHAR = '$'\n1 CHAR = '%'\n",
462 },
463 -------------------------------------------------------------
464 { "single character symbols 3",
465 "^ & * ( )",
466 PASS, "1 CHAR = '^'\n1 CHAR = '&'\n1 CHAR = '*'\n1 CHAR = '('\n1 CHAR = ')'\n",
467 },
468 -------------------------------------------------------------
469 { "single character symbols 4",
470 "_ - + \\ |",
471 PASS, "1 <name> = _\n1 CHAR = '-'\n1 CHAR = '+'\n1 CHAR = '\\'\n1 CHAR = '|'\n",
472 },
473 -------------------------------------------------------------
474 { "single character symbols 5",
475 "{ } [ ] :",
476 PASS, "1 CHAR = '{'\n1 CHAR = '}'\n1 CHAR = '['\n1 CHAR = ']'\n1 CHAR = ':'\n",
477 },
478 -------------------------------------------------------------
479 { "single character symbols 6",
480 "; , . / ?",
481 PASS, "1 CHAR = ';'\n1 CHAR = ','\n1 CHAR = '.'\n1 CHAR = '/'\n1 CHAR = '?'\n",
482 },
483 -------------------------------------------------------------
484 }
485 ------------------------------------------------------------------
486 -- perform a test case
487 ------------------------------------------------------------------
488 function do_test_case(count, test_case)
489 if comment == "" then return end -- skip empty entries
490 local comment, chunk, outcome, matcher = unpack(test_case)
491 local result = PASS
492 local output = ""
493 -- initialize lexer
494 llex.init(chunk, "=test")
495 -- lexer test loop
496 repeat
497 -- protected call
498 local status, token, seminfo = pcall(llex.llex)
499 output = output..llex.ln.." "
500 if status then
501 -- successful call
502 if #token > 1 then
503 if token == "<name>"
504 or token == "<number>"
505 or token == "<string>" then
506 token = token.." = "..seminfo
507 end
508 elseif string.byte(token) >= 32 then -- displayable chars
509 token = "CHAR = '"..token.."'"
510 else -- control characters
511 token = "CHAR = (".. string.byte(token)..")"
512 end
513 output = output..token.."\n"
514 else
515 -- failed call
516 output = output..token -- token is the error message
517 result = FAIL
518 break
519 end
520 until token == "<eof>"
521 -- decision making and reporting
522 local head = "Test "..count..": "..comment
523 if matcher == "" then
524 -- nothing to check against, display for manual check
525 print(head.."\nMANUAL please check manually"..
526 "\n--chunk---------------------------------\n"..chunk..
527 "\n--actual--------------------------------\n"..output..
528 "\n\n")
529 return
530 else
531 if outcome == PASS then
532 -- success expected, may be a partial match
533 if string.find(output, matcher, 1, 1) and result == PASS then
534 if not BRIEF then print(head.."\nOK expected success\n") end
535 return
536 end
537 else
538 -- failure expected, may be a partial match
539 if string.find(output, matcher, 1, 1) and result == FAIL then
540 if not BRIEF then print(head.."\nOK expected failure\n") end
541 return
542 end
543 end
544 -- failed because of unmatched string or boolean result
545 local function passfail(status)
546 if status == PASS then return "PASS" else return "FAIL" end
547 end
548 print(head.." *FAILED*"..
549 "\noutcome="..passfail(outcome)..
550 "\nactual= "..passfail(result)..
551 "\n--chunk---------------------------------\n"..chunk..
552 "\n--expected------------------------------\n"..matcher..
553 "\n--actual--------------------------------\n"..output..
554 "\n\n")
555 end
556 end
557 ------------------------------------------------------------------
558 -- perform auto testing
559 ------------------------------------------------------------------
560 for i,test_case in ipairs(test_cases) do
561 do_test_case(i, test_case)
562 end
563end
564
565auto_test()
566--]=====]
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/test_lparser_mk2.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/test_lparser_mk2.lua
deleted file mode 100644
index 11f2827..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/test_lparser_mk2.lua
+++ /dev/null
@@ -1,329 +0,0 @@
1--[[--------------------------------------------------------------------
2
3 test_lparser_mk2.lua
4 Test for lparser_mk2.lua
5 This file is part of Yueliang.
6
7 Copyright (c) 2008 Kein-Hong Man <khman@users.sf.net>
8 The COPYRIGHT file describes the conditions
9 under which this software may be distributed.
10
11 See the ChangeLog for more information.
12
13----------------------------------------------------------------------]]
14
15------------------------------------------------------------------------
16-- test the whole kaboodle
17------------------------------------------------------------------------
18
19package.path = "../?.lua;"..package.path
20local llex = require "llex_mk2"
21local lparser = require "lparser_mk2"
22
23------------------------------------------------------------------------
24-- dump contents of log table
25------------------------------------------------------------------------
26
27local function dump_log(fs)
28 local log = fs.log
29 for i = 1, #log do
30 print(log[i])
31 end
32end
33
34------------------------------------------------------------------------
35-- try 1
36------------------------------------------------------------------------
37
38--[=[
39llex.init("local a = 1", "=string")
40lparser.init(llex)
41-- nothing is returned, so hope there is an error if problem occurs
42local fs = lparser.parser()
43dump_log(fs)
44--]=]
45
46------------------------------------------------------------------------
47-- try 2
48------------------------------------------------------------------------
49
50-- a slightly larger sample
51--[=[
52llex.init([[
53local a = 47
54local b = "hello, world!"
55print(a, b)
56]], "@sample.lua")
57lparser.init(llex)
58-- nothing is returned, so hope there is an error if problem occurs
59local fs = lparser.parser()
60dump_log(fs)
61--]=]
62
63------------------------------------------------------------------------
64-- automatic dumper of output log data
65------------------------------------------------------------------------
66
67local test_case = {
68-- 1 attempts to exercise most parts, extent of coverage not known
69[[
70]],
71-- 2
72[[
73-- foobar
74]],
75-- 3
76[[
77do
78end
79]],
80-- 4
81[[
82do end
83do end
84]],
85-- 5
86[[
87foo()
88foo{}
89foo""
90foo:bar()
91foo=false
92foo.bar=true
93foo[true]=nil
94foo,bar=1,"a"
95]],
96-- 6
97[[
98foo=true
99foo=false
100foo=nil
101foo=1.23e45
102foo=-1
103foo=(0)
104foo=1+2
105foo=1+2*3-4/5
106]],
107-- 7
108[[
109if foo then foo=1 end
110if foo then foo=1 else foo=0 end
111if foo then foo=1 elseif not foo then foo=0 end
112]],
113-- 8
114[[
115do return end
116do return 123 end
117do return "foo","bar" end
118]],
119-- 9
120[[
121while true do foo=not foo end
122while foo~=42 do foo=foo-1 end
123while true do break end
124]],
125-- 10
126[[
127repeat foo=foo.."bar" until false
128repeat foo=foo/2 until foo<1
129repeat break until false
130]],
131-- 11
132[[
133for i=1,10 do foo=i end
134for i=1,10,2 do break end
135for i in foo do bar=0 end
136for i,j in foo,bar do baz=0 end
137]],
138-- 12
139[[
140local foo
141local foo,bar,baz
142local foo,bar="foo","bar"
143]],
144-- 13
145[[
146local function foo() return end
147local function foo(a) return end
148local function foo(x,y,z) return end
149local function foo(x,...) return end
150]],
151-- 14
152[[
153function foo() return end
154function foo(a) return end
155function foo(x,y,z) return end
156function foo(x,...) return end
157]],
158-- 15
159[[
160function foo.bar(p) return end
161function foo.bar.baz(p) return end
162function foo:bar(p) return end
163function foo.bar.baz(p) return end
164]],
165-- 16
166[[
167foo = function() return end
168foo = function(x,y) return end
169foo = function(...) return end
170foo = function(...) local bar = ... return end
171]],
172-- 17
173[[
174foo = {}
175foo = { 1,2,3; "foo"; }
176foo = { bar=77, baz=88, }
177foo = { ["bar"]=77, ["baz"]=88, }
178]],
179-- 18 simple tests for variable management follows
180[[
181 print(a)
182]],
183-- 19
184[[
185 local a
186 print(a)
187]],
188-- 20
189[[
190 do
191 local a
192 print(a)
193 end
194 print(a)
195]],
196-- 21
197[[
198 local a,b,c
199 do
200 local b
201 print(b)
202 end
203 print(b)
204]],
205-- 22
206[[
207 local function foo() end
208 bar = foo
209]],
210-- 23
211[[
212 do
213 local function foo() end
214 bar = foo
215 end
216 baz = foo
217]],
218-- 24
219[[
220 local foo
221 local function bar()
222 baz = nil
223 foo = bar()
224 end
225 foo = bar
226]],
227-- 25
228[[
229 local foo
230 local function bar()
231 local function baz()
232 local foo, bar
233 foo = bar
234 foo = baz
235 end
236 foo = bar
237 foo = baz
238 end
239 foo = bar
240 foo = baz
241]],
242-- 26
243[[
244 function foo:bar()
245 print(self)
246 end
247]],
248-- 27
249[[
250 function foo(...)
251 print(arg)
252 end
253]],
254-- 28
255[[
256 local c,d
257 function foo(a,b,c)
258 print(a,c,d,e)
259 end
260]],
261-- 29
262[[
263 function foo(a,b)
264 local bar = function(c,d)
265 print(a,b,c,d)
266 end
267 end
268]],
269-- 30
270[[
271 for i = 1,10 do
272 print(i)
273 end
274 for i = 1,10,-2 do
275 print(i)
276 end
277]],
278-- 31
279[[
280 for foo in bar() do
281 print(foo)
282 end
283 for foo,bar,baz in spring() do
284 print(foo,bar,baz)
285 end
286]],
287}
288
289-- helps to skip old stuff during development of snippets
290local do_beg, do_end = 1, #test_case
291
292-- loop for all example snippets
293for i = do_beg, do_end do
294 local fname = "parser_log/sample_"..string.format("%02d", i)..".lua"
295 local src = test_case[i]
296 local OUTF = io.open(fname, "wb")
297 if not OUTF then error("failed to write to file '"..fname.."'") end
298 -- write out actual source for comparison
299 OUTF:write(
300 "-- START OF SOURCE --\n"..
301 src..
302 "-- END OF SOURCE --\n"..
303 "\n"
304 )
305 -- attempt to parse
306 llex.init(src, "=string")
307 lparser.init(llex)
308 local fs = lparser.parser()
309 -- grab logged messages and write
310 local log = fs.log
311 local indent = 0
312 for i = 1, #log do
313 local ln = log[i]
314 -- handle indentation
315 local tag = string.sub(ln, 1, 2)
316 if tag == ">>" or tag == "<<" then
317 ln = string.sub(ln, 4)
318 end
319 if tag == ">>" then
320 indent = indent + 1
321 end
322 OUTF:write(string.rep(" ", indent)..ln.."\n")
323 if tag == "<<" then
324 indent = indent - 1
325 end
326 end
327 -- we're done
328 OUTF:close()
329end
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/test_lparser_mk2_2.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/test_lparser_mk2_2.lua
deleted file mode 100644
index c135a8c..0000000
--- a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/test_lparser_mk2_2.lua
+++ /dev/null
@@ -1,159 +0,0 @@
1--[[--------------------------------------------------------------------
2
3 test_lparser_mk2_2.lua
4 Test for lparser_mk2.lua, using the test case file
5 This file is part of Yueliang.
6
7 Copyright (c) 2006-2008 Kein-Hong Man <khman@users.sf.net>
8 The COPYRIGHT file describes the conditions
9 under which this software may be distributed.
10
11 See the ChangeLog for more information.
12
13----------------------------------------------------------------------]]
14
15--[[--------------------------------------------------------------------
16-- Notes:
17-- * unlike the equivalent in the orig-5.1.3/ directory, this version
18-- tests only parsing, lparser_mk3 cannot generate binary chunks
19-- * the test cases are in the test_lua directory (test_parser-5.1.lua)
20----------------------------------------------------------------------]]
21
22-- * true if you want an output of all failure cases in native Lua,
23-- for checking whether test cases fail where you intend them to
24local DEBUG_FAILS = false
25
26------------------------------------------------------------------------
27-- test the whole kaboodle
28------------------------------------------------------------------------
29
30package.path = "../?.lua;"..package.path
31local llex = require "llex_mk2"
32local lparser = require "lparser_mk2"
33
34------------------------------------------------------------------------
35-- load test cases
36------------------------------------------------------------------------
37
38dofile("../../test_lua/test_parser-5.1.lua")
39
40local test, expect, heading = {}, {}, {}
41local total, total_pass, total_fail = 0, 0, 0
42
43for ln in string.gfind(tests_source, "([^\n]*)\n") do
44 if string.find(ln, "^%s*%-%-") then
45 -- comment, ignore
46 else
47 local m, _, head = string.find(ln, "^%s*(TESTS:%s*.*)$")
48 if m then
49 heading[total + 1] = head -- informational heading
50 else
51 total = total + 1
52 local n, _, flag = string.find(ln, "%s*%-%-%s*FAIL%s*$")
53 if n then -- FAIL test case
54 ln = string.sub(ln, 1, n - 1) -- remove comment
55 expect[total] = "FAIL"
56 total_fail = total_fail + 1
57 else -- PASS test case
58 expect[total] = "PASS"
59 total_pass = total_pass + 1
60 end--n
61 test[total] = ln
62 end--m
63 end--ln
64end--for
65
66print("Tests loaded: "..total.." (total), "
67 ..total_pass.." (passes), "
68 ..total_fail.." (fails)")
69
70------------------------------------------------------------------------
71-- verify test cases using native Lua
72------------------------------------------------------------------------
73
74local last_head = "TESTS: no heading yet"
75for i = 1, total do
76 local test_case, expected, head = test[i], expect[i], heading[i]
77 -- show progress
78 if head then
79 last_head = head
80 if DEBUG_FAILS then print("\n"..head.."\n") end
81 end
82 ------------------------------------------------------------------
83 -- perform test
84 local f, err = loadstring(test_case)
85 -- look at outcome
86 ------------------------------------------------------------------
87 if f then-- actual PASS
88 if expected == "FAIL" then
89 print("\nVerified as PASS but expected to FAIL"..
90 "\n-------------------------------------")
91 print("Lastest heading: "..last_head)
92 print("TEST: "..test_case)
93 os.exit()
94 end
95 ------------------------------------------------------------------
96 else-- actual FAIL
97 if expected == "PASS" then
98 print("\nVerified as FAIL but expected to PASS"..
99 "\n-------------------------------------")
100 print("Lastest heading: "..last_head)
101 print("TEST: "..test_case)
102 print("ERROR: "..err)
103 os.exit()
104 end
105 if DEBUG_FAILS then
106 print("TEST: "..test_case)
107 print("ERROR: "..err.."\n")
108 end
109 ------------------------------------------------------------------
110 end--f
111end--for
112
113print("Test cases verified using native Lua, no anomalies.")
114
115------------------------------------------------------------------------
116-- test using Yueliang front end
117------------------------------------------------------------------------
118
119local last_head = "TESTS: no heading yet"
120for i = 1, total do
121 local test_case, expected, head = test[i], expect[i], heading[i]
122 -- show progress
123 if head then last_head = head end
124 ------------------------------------------------------------------
125 -- perform test
126 llex.init(test_case, "=test_sample")
127 lparser.init(llex)
128
129 local status, func = pcall(lparser.parser)
130 -- look at outcome
131 ------------------------------------------------------------------
132 if status then-- actual PASS
133 if expected == "FAIL" then
134 print("\nTested as PASS but expected to FAIL"..
135 "\n-----------------------------------")
136 print("Lastest heading: "..last_head)
137 print("TEST: "..test_case)
138 os.exit()
139 end
140 ------------------------------------------------------------------
141 else-- actual FAIL
142 if expected == "PASS" then
143 print("\nTested as FAIL but expected to PASS"..
144 "\n-----------------------------------")
145 print("Lastest heading: "..last_head)
146 print("TEST: "..test_case)
147 os.exit()
148 else
149 io.stdout:write("-")
150 end
151 ------------------------------------------------------------------
152 end--status
153 io.stdout:write("\rTesting ["..i.."]...")
154end--for
155print(" done.")
156
157print("Test cases run on Yueliang, no anomalies.")
158
159-- end
generated by cgit v1.1 at 2024-07-11 19:23:10 +0000