diff options
Diffstat (limited to '')
51 files changed, 0 insertions, 8456 deletions
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/README b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/README deleted file mode 100644 index b6a65d2..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/README +++ /dev/null | |||
| @@ -1,122 +0,0 @@ | |||
| 1 | nat-5.0.3 | ||
| 2 | |||
| 3 | This directory contains versions of front end files that are rewritten | ||
| 4 | to be more "native" to Lua. These files should be considered as | ||
| 5 | exercises in exploring ways to write the front end, for example, to | ||
| 6 | write a front end that is optimized for size, etc. See also file size | ||
| 7 | data further below. | ||
| 8 | |||
| 9 | The following are the different versions available (mk2 == "mark 2", | ||
| 10 | this is commonly used in the UK, e.g. for aeroplanes during WWII): | ||
| 11 | |||
| 12 | Lexers | ||
| 13 | ------ | ||
| 14 | |||
| 15 | WARNING: Theses lexer may or may not exhibit exact behaviour when lexing | ||
| 16 | strings or long strings with embedded CRLF newlines. The CRLF sequence | ||
| 17 | may be translated into LF (the reference manual is unclear on this.) The | ||
| 18 | user is advised to stick to LF line endings exclusively. | ||
| 19 | |||
| 20 | llex_mk2 Rewritten from original ported code to become more | ||
| 21 | Lua-like. Still uses a stream-based input interface. | ||
| 22 | MK2 still scans using a per-character function that | ||
| 23 | is pretty inefficient. | ||
| 24 | |||
| 25 | Status: TESTED | ||
| 26 | |||
| 27 | llex_mk3 A rewritten version of MK2 that needs input to be | ||
| 28 | entered as a single string. Unless an application's | ||
| 29 | need is very unusual, this should not be a problem. | ||
| 30 | It will not work for per-line interaction, though. | ||
| 31 | MK3 no longer needs stream input functions. This | ||
| 32 | version is also heavily optimized for size. MK3 scans | ||
| 33 | using find functions and doesn't create many strings. | ||
| 34 | |||
| 35 | Status: TESTED | ||
| 36 | |||
| 37 | llex_mk4 A rewritten version of MK3 that is line-oriented. | ||
| 38 | This allows a command-line version that works in the | ||
| 39 | usual way to be written. | ||
| 40 | |||
| 41 | Status: TESTED | ||
| 42 | |||
| 43 | The following is a comparison of file sizes (as of 20061111): | ||
| 44 | |||
| 45 | lzio llex TOTAL Speed (2) | ||
| 46 | (bytes) (bytes) (bytes) (KB/s) | ||
| 47 | ---------------------------------------------- | ||
| 48 | Binary (Mingw) 416 5312 5728 N/A | ||
| 49 | ---------------------------------------------- | ||
| 50 | (in orig-5.0.3:) | ||
| 51 | ---------------------------------------------- | ||
| 52 | normal 2219 12639 14585 404.9 | ||
| 53 | stripped 1292 7618 8910 | ||
| 54 | ---------------------------------------------- | ||
| 55 | (in nat-5.0.3:) | ||
| 56 | ---------------------------------------------- | ||
| 57 | mk2 1995 7628 9623 469.5 | ||
| 58 | mk2-stripped 1195 4003 5298 | ||
| 59 | ---------------------------------------------- | ||
| 60 | mk3 (1) - 6552 6552 1870.8 | ||
| 61 | mk3-stripped - 3286 3286 | ||
| 62 | ---------------------------------------------- | ||
| 63 | mk4 1337 6956 8293 802.9 | ||
| 64 | mk4-stripped 798 3457 4225 | ||
| 65 | ---------------------------------------------- | ||
| 66 | |||
| 67 | (1) mk3 does not have a file input streaming function | ||
| 68 | |||
| 69 | (2) Speed was benchmarked using a Sempron 3000+. Benchmark scripts are | ||
| 70 | in the test directories. Best of first three figures quoted. This is a | ||
| 71 | measurement of raw lexer speed, i.e. tokens are read but no processing | ||
| 72 | is done. All files are read in entirely before running the lexer. | ||
| 73 | |||
| 74 | The performance of the orig-5.0.3 parser is probably a whole magnitude | ||
| 75 | less than the orig-5.0.3 lexer performance. | ||
| 76 | |||
| 77 | Parsers | ||
| 78 | ------- | ||
| 79 | |||
| 80 | lparser_mk3 Written for the simplified lexer interface of llex_mk3+. | ||
| 81 | (Should be compatible with llex_mk4 too, but untested.) | ||
| 82 | This is a lexer skeleton, stripped of codegen code. See | ||
| 83 | the comments in the source code for more information. | ||
| 84 | Without logging messages and comments, it's under 600 LOC. | ||
| 85 | |||
| 86 | Sample output of the parser message logger can be found | ||
| 87 | in the test/parser_log subdirectory. | ||
| 88 | |||
| 89 | Tested with test_parser-5.0.lua, the Lua 5.0.x parser test | ||
| 90 | cases in the test_lua/ directory, appears to be fine. | ||
| 91 | |||
| 92 | Status: SNIPPETS APPEAR TO WORK | ||
| 93 | |||
| 94 | lparser_mk3b As above, with variable management code added. In order | ||
| 95 | to use the parser usefully, variable management code is | ||
| 96 | a big step forward, allowing the parser to differentiate | ||
| 97 | locals, upvalues and globals. The number of added lines | ||
| 98 | is around 100 LOC. A binary chunk of lparser_mk3b | ||
| 99 | (stripped) is 18076 bytes. | ||
| 100 | |||
| 101 | Sample output of the parser message logger can be found | ||
| 102 | in the test/parser_log subdirectory. | ||
| 103 | |||
| 104 | Tested with test_parser-5.0.lua, the Lua 5.0.x parser test | ||
| 105 | cases in the test_lua/ directory, appears to be fine. | ||
| 106 | |||
| 107 | Status: SNIPPETS APPEAR TO WORK | ||
| 108 | |||
| 109 | There will be no further development beyond lparser_mk3b. Further work | ||
| 110 | will focus on a 5.1.x equivalent, for which both a parser skeleton and a | ||
| 111 | parser with full code generation using nicely commented code is planned. | ||
| 112 | |||
| 113 | Other notes: | ||
| 114 | ------------ | ||
| 115 | |||
| 116 | For Lua 5.0.2, see Yueliang 0.1.3, which was the last release of Lua | ||
| 117 | 5.0.2 material. | ||
| 118 | |||
| 119 | Test scripts for the lexer should probably be consolidated, but it's a | ||
| 120 | little difficult because not all lexers give the same error messages or | ||
| 121 | use the same token names or format. | ||
| 122 | |||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/llex_mk2.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/llex_mk2.lua deleted file mode 100644 index 955f229..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/llex_mk2.lua +++ /dev/null | |||
| @@ -1,309 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | llex.lua | ||
| 4 | Lua 5 lexical analyzer in Lua | ||
| 5 | This file is part of Yueliang. | ||
| 6 | |||
| 7 | Copyright (c) 2005-2006 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 | -- * parser to implement luaX_syntaxerror, call errorline with 2 parms | ||
| 18 | ----------------------------------------------------------------------]] | ||
| 19 | |||
| 20 | --[[-------------------------------------------------------------------- | ||
| 21 | -- local lex_init = require("llex.lua") | ||
| 22 | -- local llex = lex_init(z, source) | ||
| 23 | -- llex:chunkid() | ||
| 24 | -- * returns formatted name of chunk id | ||
| 25 | -- llex:errorline(s, token, line) | ||
| 26 | -- * throws an error with a formatted message | ||
| 27 | -- llex:lex() | ||
| 28 | -- * returns next lexical element (token, seminfo) | ||
| 29 | ----------------------------------------------------------------------]] | ||
| 30 | |||
| 31 | return | ||
| 32 | function(z, source) | ||
| 33 | --[[-------------------------------------------------------------------- | ||
| 34 | -- lexer initialization | ||
| 35 | ----------------------------------------------------------------------]] | ||
| 36 | -------------------------------------------------------------------- | ||
| 37 | -- initialize variables | ||
| 38 | -------------------------------------------------------------------- | ||
| 39 | local string = string | ||
| 40 | local EOF = "<eof>" | ||
| 41 | local z = z | ||
| 42 | local luaX = {source = source, lineno = 1,} | ||
| 43 | local curr, buff | ||
| 44 | -------------------------------------------------------------------- | ||
| 45 | -- initialize keyword list | ||
| 46 | -------------------------------------------------------------------- | ||
| 47 | local kw = {} | ||
| 48 | for v in string.gfind([[ | ||
| 49 | and break do else elseif end false for function if in | ||
| 50 | local nil not or repeat return then true until while]], "%S+") do | ||
| 51 | kw[v] = true | ||
| 52 | end | ||
| 53 | --[[-------------------------------------------------------------------- | ||
| 54 | -- support functions | ||
| 55 | ----------------------------------------------------------------------]] | ||
| 56 | -------------------------------------------------------------------- | ||
| 57 | -- returns a chunk name or id | ||
| 58 | -------------------------------------------------------------------- | ||
| 59 | function luaX:chunkid() | ||
| 60 | local sub = string.sub | ||
| 61 | local first = sub(source, 1, 1) | ||
| 62 | if first == "=" or first == "@" then | ||
| 63 | return sub(source, 2) -- remove first char | ||
| 64 | end | ||
| 65 | return "[string]" | ||
| 66 | end | ||
| 67 | -------------------------------------------------------------------- | ||
| 68 | -- formats error message and throws error | ||
| 69 | -------------------------------------------------------------------- | ||
| 70 | function luaX:errorline(s, token, line) | ||
| 71 | if not line then line = self.lineno end | ||
| 72 | error(string.format("%s:%d: %s near '%s'", self:chunkid(), line, s, token)) | ||
| 73 | end | ||
| 74 | -------------------------------------------------------------------- | ||
| 75 | -- throws a lexer error | ||
| 76 | -------------------------------------------------------------------- | ||
| 77 | local function lexerror(s, token) | ||
| 78 | if not token then token = buff end | ||
| 79 | luaX:errorline(s, token) | ||
| 80 | end | ||
| 81 | -------------------------------------------------------------------- | ||
| 82 | -- gets the next character and returns it | ||
| 83 | -------------------------------------------------------------------- | ||
| 84 | local function nextc() | ||
| 85 | local c = z:getc() | ||
| 86 | curr = c | ||
| 87 | return c | ||
| 88 | end | ||
| 89 | -------------------------------------------------------------------- | ||
| 90 | -- save current character into token buffer, grabs next character | ||
| 91 | -- * save(c) merged into this and elsewhere to save space | ||
| 92 | -------------------------------------------------------------------- | ||
| 93 | local function save_next() | ||
| 94 | buff = buff..curr | ||
| 95 | return nextc() | ||
| 96 | end | ||
| 97 | -------------------------------------------------------------------- | ||
| 98 | -- move on to next line | ||
| 99 | -------------------------------------------------------------------- | ||
| 100 | local function nextline() | ||
| 101 | local luaX = luaX | ||
| 102 | nextc() -- skip '\n' | ||
| 103 | luaX.lineno = luaX.lineno + 1 | ||
| 104 | end | ||
| 105 | --[[-------------------------------------------------------------------- | ||
| 106 | -- reads a number (LUA_NUMBER) | ||
| 107 | ----------------------------------------------------------------------]] | ||
| 108 | local function read_numeral(comma) | ||
| 109 | buff = "" | ||
| 110 | local find = string.find | ||
| 111 | if comma then buff = "." end | ||
| 112 | ------------------------------------------------------------------ | ||
| 113 | while find(curr, "%d") do save_next() end | ||
| 114 | if curr == "." then | ||
| 115 | if save_next() == "." then | ||
| 116 | save_next() | ||
| 117 | lexerror("ambiguous syntax (dots follows digits)") | ||
| 118 | end | ||
| 119 | end | ||
| 120 | ------------------------------------------------------------------ | ||
| 121 | while find(curr, "%d") do save_next() end | ||
| 122 | if find(curr, "^[eE]$") then | ||
| 123 | save_next() -- read 'E' and optional exponent sign | ||
| 124 | if find(curr, "^[+-]$") then save_next() end | ||
| 125 | while find(curr, "%d") do save_next() end | ||
| 126 | end | ||
| 127 | c = tonumber(buff) | ||
| 128 | if c then return c end | ||
| 129 | lexerror("malformed number") | ||
| 130 | end | ||
| 131 | --[[-------------------------------------------------------------------- | ||
| 132 | -- reads a long string or long comment | ||
| 133 | ----------------------------------------------------------------------]] | ||
| 134 | local function read_long(is_str) | ||
| 135 | local cont = 0 | ||
| 136 | buff = "" | ||
| 137 | nextc() -- pass the '[[' | ||
| 138 | if curr == "\n" then -- string starts with a newline? | ||
| 139 | nextline() -- skip it | ||
| 140 | end | ||
| 141 | while true do | ||
| 142 | local c = curr | ||
| 143 | ---------------------------------------------------------------- | ||
| 144 | if c == "EOZ" then | ||
| 145 | lexerror(is_str and "unfinished long string" or | ||
| 146 | "unfinished long comment", EOF) | ||
| 147 | ---------------------------------------------------------------- | ||
| 148 | elseif c == "[" then | ||
| 149 | if save_next() == "[" then | ||
| 150 | cont = cont + 1; save_next() | ||
| 151 | end | ||
| 152 | ---------------------------------------------------------------- | ||
| 153 | elseif c == "]" then | ||
| 154 | if save_next() == "]" then | ||
| 155 | if cont == 0 then break end | ||
| 156 | cont = cont - 1; save_next() | ||
| 157 | end | ||
| 158 | ---------------------------------------------------------------- | ||
| 159 | elseif c == "\n" then | ||
| 160 | buff = buff.."\n"; nextline() | ||
| 161 | if not is_str then buff = "" end -- avoid wasting space | ||
| 162 | ---------------------------------------------------------------- | ||
| 163 | else | ||
| 164 | save_next() | ||
| 165 | ---------------------------------------------------------------- | ||
| 166 | end--if c | ||
| 167 | end--while | ||
| 168 | nextc() -- skip second ']' | ||
| 169 | return string.sub(buff, 1, -2) | ||
| 170 | end | ||
| 171 | --[[-------------------------------------------------------------------- | ||
| 172 | -- reads a string | ||
| 173 | ----------------------------------------------------------------------]] | ||
| 174 | local function read_string(del) | ||
| 175 | local find = string.find | ||
| 176 | buff = "" | ||
| 177 | save_next() -- save delimiter | ||
| 178 | while curr ~= del do | ||
| 179 | local c = curr | ||
| 180 | ---------------------------------------------------------------- | ||
| 181 | -- end-of-file, newline | ||
| 182 | ---------------------------------------------------------------- | ||
| 183 | if c == "EOZ" then | ||
| 184 | lexerror("unfinished string", EOF) | ||
| 185 | elseif c == "\n" then | ||
| 186 | lexerror("unfinished string") | ||
| 187 | ---------------------------------------------------------------- | ||
| 188 | -- escapes | ||
| 189 | ---------------------------------------------------------------- | ||
| 190 | elseif c == "\\" then | ||
| 191 | c = nextc() -- do not save the '\' | ||
| 192 | if c ~= "EOZ" then -- will raise an error next loop iteration | ||
| 193 | local d = find("\nabfnrtv", c, 1, 1) | ||
| 194 | if d then | ||
| 195 | buff = buff..string.sub("\n\a\b\f\n\r\t\v", d, d) | ||
| 196 | if d == 1 then nextline() else nextc() end | ||
| 197 | elseif find(c, "%D") then | ||
| 198 | save_next() -- handles \\, \", \', and \? | ||
| 199 | else -- \xxx | ||
| 200 | c, d = 0, 0 | ||
| 201 | repeat | ||
| 202 | c = 10 * c + curr; d = d + 1; nextc() | ||
| 203 | until d >= 3 or find(curr, "%D") | ||
| 204 | if c > 255 then -- UCHAR_MAX | ||
| 205 | lexerror("escape sequence too large") | ||
| 206 | end | ||
| 207 | buff = buff..string.char(c) | ||
| 208 | end | ||
| 209 | end | ||
| 210 | ---------------------------------------------------------------- | ||
| 211 | -- a regular character | ||
| 212 | ---------------------------------------------------------------- | ||
| 213 | else | ||
| 214 | save_next() | ||
| 215 | ---------------------------------------------------------------- | ||
| 216 | end--if c | ||
| 217 | end--while | ||
| 218 | nextc() -- skip delimiter | ||
| 219 | return string.sub(buff, 2) | ||
| 220 | end | ||
| 221 | --[[-------------------------------------------------------------------- | ||
| 222 | -- main lexer function | ||
| 223 | ----------------------------------------------------------------------]] | ||
| 224 | function luaX:lex() | ||
| 225 | local find = string.find | ||
| 226 | while true do | ||
| 227 | local c = curr | ||
| 228 | ---------------------------------------------------------------- | ||
| 229 | -- operators, numbers | ||
| 230 | ---------------------------------------------------------------- | ||
| 231 | local d = find("=<>~\"'-[.\n", c, 1, 1) | ||
| 232 | if d then | ||
| 233 | ------------------------------------------------------------ | ||
| 234 | if d <= 4 then -- "=<>~" (relational operators) | ||
| 235 | if nextc() ~= "=" then return c end | ||
| 236 | nextc(); return c.."=" | ||
| 237 | ------------------------------------------------------------ | ||
| 238 | elseif d <= 6 then -- "\"" or "'" (string) | ||
| 239 | return "<string>", read_string(c) | ||
| 240 | ------------------------------------------------------------ | ||
| 241 | elseif c == "-" then -- "-" ("-", comment, or long comment) | ||
| 242 | if nextc() ~= "-" then return "-" end | ||
| 243 | c = nextc() -- otherwise it is a comment | ||
| 244 | if c == "[" and nextc() == "[" then | ||
| 245 | read_long() -- long comment | ||
| 246 | else -- short comment | ||
| 247 | while c ~= "\n" and c ~= "EOZ" do c = nextc() end | ||
| 248 | end | ||
| 249 | ------------------------------------------------------------ | ||
| 250 | elseif c == "[" then -- "[" ("[" or long string) | ||
| 251 | if nextc() ~= "[" then return c end | ||
| 252 | return "<string>", read_long(true) | ||
| 253 | ------------------------------------------------------------ | ||
| 254 | elseif c == "." then -- "." (".", concatenation, or dots) | ||
| 255 | buff = "" | ||
| 256 | c = save_next() | ||
| 257 | if c == "." then -- interpret 2 or 3 dots | ||
| 258 | if save_next() == "." then save_next() end | ||
| 259 | return buff | ||
| 260 | end | ||
| 261 | if find(c, "%d") then | ||
| 262 | return "<number>", read_numeral(true) | ||
| 263 | end | ||
| 264 | return "." | ||
| 265 | ------------------------------------------------------------ | ||
| 266 | else-- c == "\n" then -- "\n" (newline) | ||
| 267 | nextline() | ||
| 268 | ------------------------------------------------------------ | ||
| 269 | end--if d/c | ||
| 270 | ---------------------------------------------------------------- | ||
| 271 | -- number, end-of-file, identifier or reserved word | ||
| 272 | ---------------------------------------------------------------- | ||
| 273 | elseif find(c, "%d") then -- number | ||
| 274 | return "<number>", read_numeral(false) | ||
| 275 | ---------------------------------------------------------------- | ||
| 276 | elseif find(c, "[_%a]") then -- reads a name | ||
| 277 | if c == "EOZ" then return EOF end -- end-of-file | ||
| 278 | buff = "" | ||
| 279 | repeat | ||
| 280 | c = save_next() | ||
| 281 | until c == "EOZ" or find(c, "[^_%w]") | ||
| 282 | c = buff | ||
| 283 | if kw[c] then return c end -- reserved word | ||
| 284 | return "<name>", c | ||
| 285 | ---------------------------------------------------------------- | ||
| 286 | -- whitespace, other characters, control characters | ||
| 287 | ---------------------------------------------------------------- | ||
| 288 | elseif find(c, "%s") then -- whitespace | ||
| 289 | nextc() | ||
| 290 | ---------------------------------------------------------------- | ||
| 291 | elseif find(c, "%c") then -- control characters | ||
| 292 | lexerror("invalid control char", "char("..string.byte(c)..")") | ||
| 293 | ---------------------------------------------------------------- | ||
| 294 | else -- single-char tokens (+ - / etc.) | ||
| 295 | nextc(); return c | ||
| 296 | ---------------------------------------------------------------- | ||
| 297 | end--if d/c | ||
| 298 | end--while | ||
| 299 | end | ||
| 300 | --[[-------------------------------------------------------------------- | ||
| 301 | -- initial processing (shbang handling) | ||
| 302 | ----------------------------------------------------------------------]] | ||
| 303 | nextc() -- read first char | ||
| 304 | if cur == "#" then -- skip first line | ||
| 305 | repeat nextc() until curr == "\n" or curr == "EOZ" | ||
| 306 | end | ||
| 307 | return luaX | ||
| 308 | --[[------------------------------------------------------------------]] | ||
| 309 | end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/llex_mk3.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/llex_mk3.lua deleted file mode 100644 index 1cd22b5..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/llex_mk3.lua +++ /dev/null | |||
| @@ -1,266 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | llex.lua | ||
| 4 | Lua 5 lexical analyzer in Lua | ||
| 5 | This file is part of Yueliang. | ||
| 6 | |||
| 7 | Copyright (c) 2006 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 | -- * code is heavily optimized for size | ||
| 19 | -- | ||
| 20 | -- local lex_init = require("llex.lua") | ||
| 21 | -- local llex = lex_init(z, source) | ||
| 22 | -- llex:chunkid() | ||
| 23 | -- * returns formatted name of chunk id | ||
| 24 | -- llex:errorline(s, line) | ||
| 25 | -- * throws an error with a formatted message | ||
| 26 | -- llex:lex() | ||
| 27 | -- * returns next lexical element (token, seminfo) | ||
| 28 | -- llex.ln | ||
| 29 | -- * line number | ||
| 30 | ----------------------------------------------------------------------]] | ||
| 31 | |||
| 32 | return | ||
| 33 | function(z, source) | ||
| 34 | -------------------------------------------------------------------- | ||
| 35 | -- initialize variables | ||
| 36 | -- * I is the upvalue, i is the local version for space/efficiency | ||
| 37 | -------------------------------------------------------------------- | ||
| 38 | local string = string | ||
| 39 | local find, sub = string.find, string.sub | ||
| 40 | local EOF = "<eof>" | ||
| 41 | local luaX = { ln = 1 } | ||
| 42 | local I = 1 | ||
| 43 | -------------------------------------------------------------------- | ||
| 44 | -- initialize keyword list | ||
| 45 | -------------------------------------------------------------------- | ||
| 46 | local kw = {} | ||
| 47 | for v in string.gfind([[ | ||
| 48 | and break do else elseif end false for function if in | ||
| 49 | local nil not or repeat return then true until while]], "%S+") do | ||
| 50 | kw[v] = true | ||
| 51 | end | ||
| 52 | -------------------------------------------------------------------- | ||
| 53 | -- returns a chunk name or id | ||
| 54 | -------------------------------------------------------------------- | ||
| 55 | function luaX:chunkid() | ||
| 56 | if find(source, "^[=@]") then | ||
| 57 | return sub(source, 2) -- remove first char | ||
| 58 | end | ||
| 59 | return "[string]" | ||
| 60 | end | ||
| 61 | -------------------------------------------------------------------- | ||
| 62 | -- formats error message and throws error | ||
| 63 | -- * a simplified version, does not report what token was responsible | ||
| 64 | -------------------------------------------------------------------- | ||
| 65 | function luaX:errorline(s, line) | ||
| 66 | error(string.format("%s:%d: %s", self:chunkid(), line or self.ln, s)) | ||
| 67 | end | ||
| 68 | ---------------------------------------------------------------------- | ||
| 69 | -- reads a long string or long comment | ||
| 70 | ---------------------------------------------------------------------- | ||
| 71 | local function read_long(i, is_str) | ||
| 72 | local luaX = luaX | ||
| 73 | local string = string | ||
| 74 | local cont = 1 | ||
| 75 | if sub(z, i, i) == "\n" then | ||
| 76 | i = i + 1 | ||
| 77 | luaX.ln = luaX.ln + 1 | ||
| 78 | end | ||
| 79 | local j = i | ||
| 80 | while true do | ||
| 81 | local p, q, r = find(z, "([\n%[%]])", i) -- (long range) | ||
| 82 | if not p then | ||
| 83 | luaX:errorline(is_str and "unfinished long string" or | ||
| 84 | "unfinished long comment") | ||
| 85 | end | ||
| 86 | i = p + 1 | ||
| 87 | if r == "\n" then | ||
| 88 | luaX.ln = luaX.ln + 1 | ||
| 89 | elseif sub(z, i, i) == r then -- only [[ or ]] | ||
| 90 | i = i + 1 | ||
| 91 | if r == "[" then | ||
| 92 | cont = cont + 1 | ||
| 93 | else-- r == "]" then | ||
| 94 | if cont == 1 then break end -- last ]] found | ||
| 95 | cont = cont - 1 | ||
| 96 | end | ||
| 97 | end | ||
| 98 | end--while | ||
| 99 | I = i | ||
| 100 | return sub(z, j, i - 3) | ||
| 101 | end | ||
| 102 | ---------------------------------------------------------------------- | ||
| 103 | -- reads a string | ||
| 104 | ---------------------------------------------------------------------- | ||
| 105 | local function read_string(i, del) | ||
| 106 | local luaX = luaX | ||
| 107 | local string = string | ||
| 108 | local buff = "" | ||
| 109 | while true do | ||
| 110 | local p, q, r = find(z, "([\n\\\"\'])", i) -- (long range) | ||
| 111 | if p then | ||
| 112 | if r == "\n" then | ||
| 113 | luaX:errorline("unfinished string") | ||
| 114 | end | ||
| 115 | buff = buff..sub(z, i, p - 1) -- normal portions | ||
| 116 | i = p | ||
| 117 | if r == "\\" then -- handle escapes | ||
| 118 | i = i + 1 | ||
| 119 | r = sub(z, i, i) | ||
| 120 | if r == "" then break end -- (error) | ||
| 121 | p = find("\nabfnrtv", r, 1, 1) | ||
| 122 | ------------------------------------------------------ | ||
| 123 | if p then -- special escapes | ||
| 124 | r = sub("\n\a\b\f\n\r\t\v", p, p) | ||
| 125 | if p == 1 then luaX.ln = luaX.ln + 1 end | ||
| 126 | i = i + 1 | ||
| 127 | ------------------------------------------------------ | ||
| 128 | elseif find(r, "%D") then -- other non-digits | ||
| 129 | i = i + 1 | ||
| 130 | ------------------------------------------------------ | ||
| 131 | else -- \xxx sequence | ||
| 132 | local p, q, s = find(z, "^(%d%d?%d?)", i) | ||
| 133 | i = q + 1 | ||
| 134 | if s + 1 > 256 then -- UCHAR_MAX | ||
| 135 | luaX:errorline("escape sequence too large") | ||
| 136 | end | ||
| 137 | r = string.char(s) | ||
| 138 | ------------------------------------------------------ | ||
| 139 | end--if p | ||
| 140 | else | ||
| 141 | i = i + 1 | ||
| 142 | if r == del then | ||
| 143 | I = i | ||
| 144 | return buff -- ending delimiter | ||
| 145 | end | ||
| 146 | end--if r | ||
| 147 | buff = buff..r | ||
| 148 | else | ||
| 149 | break -- (error) | ||
| 150 | end--if p | ||
| 151 | end--while | ||
| 152 | luaX:errorline("unfinished string") | ||
| 153 | end | ||
| 154 | ---------------------------------------------------------------------- | ||
| 155 | -- main lexer function | ||
| 156 | ---------------------------------------------------------------------- | ||
| 157 | function luaX:lex() | ||
| 158 | local string = string | ||
| 159 | local find, len = find, string.len | ||
| 160 | while true do--outer | ||
| 161 | local i = I | ||
| 162 | -- inner loop allows break to be used to nicely section tests | ||
| 163 | while true do--inner | ||
| 164 | ---------------------------------------------------------------- | ||
| 165 | local p, _, r = find(z, "^([_%a][_%w]*)", i) | ||
| 166 | if p then | ||
| 167 | I = i + len(r) | ||
| 168 | if kw[r] then return r end -- keyword | ||
| 169 | return "<name>", r -- identifier | ||
| 170 | end | ||
| 171 | ---------------------------------------------------------------- | ||
| 172 | local p, q, r = find(z, "^(%.?)%d", i) | ||
| 173 | if p then -- numeral | ||
| 174 | if r == "." then i = i + 1 end | ||
| 175 | local _, n, r, s = find(z, "^%d*(%.?%.?)%d*([eE]?)", i) | ||
| 176 | q = n | ||
| 177 | i = q + 1 | ||
| 178 | if len(r) == 2 then | ||
| 179 | self:errorline("ambiguous syntax (dots follows digits)") | ||
| 180 | end | ||
| 181 | if len(s) == 1 then -- optional exponent | ||
| 182 | local _, n = find(z, "^[%+%-]?%d*", i) -- optional sign | ||
| 183 | q = n | ||
| 184 | i = q + 1 | ||
| 185 | end | ||
| 186 | r = tonumber(sub(z, p, q)) | ||
| 187 | I = i | ||
| 188 | if not r then self:errorline("malformed number") end | ||
| 189 | return "<number>", r | ||
| 190 | end | ||
| 191 | ---------------------------------------------------------------- | ||
| 192 | local p, q, r = find(z, "^(%s)[ \t]*", i) | ||
| 193 | if p then | ||
| 194 | if r == "\n" then -- newline | ||
| 195 | self.ln = self.ln + 1 | ||
| 196 | I = i + 1 | ||
| 197 | else | ||
| 198 | I = q + 1 -- whitespace | ||
| 199 | end | ||
| 200 | break -- (continue) | ||
| 201 | end | ||
| 202 | ---------------------------------------------------------------- | ||
| 203 | local p, _, r = find(z, "^(%p)", i) -- symbols/punctuation | ||
| 204 | if p then | ||
| 205 | local q = find("-[\"\'.=<>~", r, 1, 1) | ||
| 206 | if q then -- further processing for more complex symbols | ||
| 207 | ---------------------------------------------------- | ||
| 208 | if q <= 2 then | ||
| 209 | if q == 1 then -- minus | ||
| 210 | if find(z, "^%-%-", i) then | ||
| 211 | i = i + 2 | ||
| 212 | if find(z, "^%[%[", i) then -- long comment | ||
| 213 | read_long(i + 2) | ||
| 214 | else -- short comment | ||
| 215 | I = find(z, "\n", i) or (len(z) + 1) | ||
| 216 | end | ||
| 217 | break -- (continue) | ||
| 218 | end | ||
| 219 | -- (fall through for "-") | ||
| 220 | elseif q == 2 then -- [ or long string | ||
| 221 | if find(z, "^%[%[", i) then | ||
| 222 | return "<string>", read_long(i + 2, true) | ||
| 223 | end | ||
| 224 | -- (fall through for "[") | ||
| 225 | end | ||
| 226 | ---------------------------------------------------- | ||
| 227 | elseif q <= 5 then | ||
| 228 | if q < 5 then -- strings | ||
| 229 | return "<string>", read_string(i + 1, r) | ||
| 230 | end | ||
| 231 | local _, _, s = find(z, "^(%.%.?%.?)", i) -- dots | ||
| 232 | r = s | ||
| 233 | -- (fall through) | ||
| 234 | ---------------------------------------------------- | ||
| 235 | else -- relational/logic | ||
| 236 | local _, _, s = find(z, "^(%p=?)", i) | ||
| 237 | r = s | ||
| 238 | -- (fall through) | ||
| 239 | end | ||
| 240 | end | ||
| 241 | I = i + len(r); return r -- for other symbols, fall through | ||
| 242 | end | ||
| 243 | ---------------------------------------------------------------- | ||
| 244 | local r = sub(z, i, i) | ||
| 245 | if r ~= "" then | ||
| 246 | if find(r, "%c") then -- invalid control char | ||
| 247 | self:errorline("invalid control char("..string.byte(r)..")") | ||
| 248 | end | ||
| 249 | I = i + 1; return r -- other single-char tokens | ||
| 250 | end | ||
| 251 | return EOF -- end of stream | ||
| 252 | ---------------------------------------------------------------- | ||
| 253 | end--while inner | ||
| 254 | end--while outer | ||
| 255 | end | ||
| 256 | -------------------------------------------------------------------- | ||
| 257 | -- initial processing (shbang handling) | ||
| 258 | -------------------------------------------------------------------- | ||
| 259 | local p, q, r = find(z, "^#[^\n]*(\n?)") | ||
| 260 | if p then -- skip first line | ||
| 261 | I = q + 1 | ||
| 262 | if r == "\n" then luaX.ln = luaX.ln + 1 end | ||
| 263 | end | ||
| 264 | return luaX | ||
| 265 | -------------------------------------------------------------------- | ||
| 266 | end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/llex_mk4.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/llex_mk4.lua deleted file mode 100644 index 42559a3..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/llex_mk4.lua +++ /dev/null | |||
| @@ -1,285 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | llex.lua | ||
| 4 | Lua 5 lexical analyzer in Lua | ||
| 5 | This file is part of Yueliang. | ||
| 6 | |||
| 7 | Copyright (c) 2006 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 | -- * a line-oriented version of mk3 | ||
| 18 | -- | ||
| 19 | -- local lex_init = require("llex.lua") | ||
| 20 | -- local llex = lex_init(z, source) | ||
| 21 | -- llex:chunkid() | ||
| 22 | -- * returns formatted name of chunk id | ||
| 23 | -- llex:errorline(s, line) | ||
| 24 | -- * throws an error with a formatted message | ||
| 25 | -- llex:lex() | ||
| 26 | -- * returns next lexical element (token, seminfo) | ||
| 27 | -- llex.ln | ||
| 28 | -- * line number | ||
| 29 | ----------------------------------------------------------------------]] | ||
| 30 | |||
| 31 | return | ||
| 32 | function(zio, source) | ||
| 33 | -------------------------------------------------------------------- | ||
| 34 | -- initialize variables | ||
| 35 | -- * I is the upvalue, i is the local version for space/efficiency | ||
| 36 | -------------------------------------------------------------------- | ||
| 37 | local string = string | ||
| 38 | local find, sub = string.find, string.sub | ||
| 39 | local EOF = "<eof>" | ||
| 40 | local luaX = { ln = 0 } | ||
| 41 | local I, z | ||
| 42 | -------------------------------------------------------------------- | ||
| 43 | -- initialize keyword list | ||
| 44 | -------------------------------------------------------------------- | ||
| 45 | local kw = {} | ||
| 46 | for v in string.gfind([[ | ||
| 47 | and break do else elseif end false for function if in | ||
| 48 | local nil not or repeat return then true until while]], "%S+") do | ||
| 49 | kw[v] = true | ||
| 50 | end | ||
| 51 | -------------------------------------------------------------------- | ||
| 52 | -- returns a chunk name or id | ||
| 53 | -------------------------------------------------------------------- | ||
| 54 | function luaX:chunkid() | ||
| 55 | if find(source, "^[=@]") then | ||
| 56 | return sub(source, 2) -- remove first char | ||
| 57 | end | ||
| 58 | return "[string]" | ||
| 59 | end | ||
| 60 | -------------------------------------------------------------------- | ||
| 61 | -- formats error message and throws error | ||
| 62 | -- * a simplified version, does not report what token was responsible | ||
| 63 | -------------------------------------------------------------------- | ||
| 64 | function luaX:errorline(s, line) | ||
| 65 | error(string.format("%s:%d: %s", self:chunkid(), line or self.ln, s)) | ||
| 66 | end | ||
| 67 | -------------------------------------------------------------------- | ||
| 68 | -- move on to next line | ||
| 69 | -------------------------------------------------------------------- | ||
| 70 | local function nextln() | ||
| 71 | local luaX = luaX | ||
| 72 | luaX.ln = luaX.ln + 1 | ||
| 73 | z = zio:getln() | ||
| 74 | I = 1 | ||
| 75 | end | ||
| 76 | ---------------------------------------------------------------------- | ||
| 77 | -- reads a long string or long comment | ||
| 78 | ---------------------------------------------------------------------- | ||
| 79 | local function read_long(i, is_str) | ||
| 80 | local luaX = luaX | ||
| 81 | local string = string | ||
| 82 | local buff = "" | ||
| 83 | local cont = 1 | ||
| 84 | if sub(z, i, i) == "\n" then | ||
| 85 | nextln(); i = 1 | ||
| 86 | end | ||
| 87 | while true do | ||
| 88 | local p, q, r = find(z, "([\n%[%]])", i) -- (long range) | ||
| 89 | if not p then | ||
| 90 | luaX:errorline(is_str and "unfinished long string" or | ||
| 91 | "unfinished long comment") | ||
| 92 | end | ||
| 93 | buff = buff..string.sub(z, i, p - 1) -- add a portion | ||
| 94 | i = p + 1 | ||
| 95 | if sub(z, i, i) == r then -- only [[ or ]] | ||
| 96 | i = i + 1 | ||
| 97 | if r == "[" then | ||
| 98 | cont = cont + 1 | ||
| 99 | else-- r == "]" then | ||
| 100 | if cont == 1 then break end -- last ]] found | ||
| 101 | cont = cont - 1 | ||
| 102 | end | ||
| 103 | buff = buff..r..r | ||
| 104 | else -- [ or ] or \n | ||
| 105 | buff = buff..r | ||
| 106 | if r == "\n" then | ||
| 107 | nextln(); i = 1 | ||
| 108 | end | ||
| 109 | end | ||
| 110 | end--while | ||
| 111 | I = i | ||
| 112 | return buff | ||
| 113 | end | ||
| 114 | ---------------------------------------------------------------------- | ||
| 115 | -- reads a string | ||
| 116 | ---------------------------------------------------------------------- | ||
| 117 | local function read_string(i, del) | ||
| 118 | local luaX = luaX | ||
| 119 | local string = string | ||
| 120 | local buff = "" | ||
| 121 | while true do | ||
| 122 | local p, q, r = find(z, "([\n\\\"\'])", i) -- (long range) | ||
| 123 | if p then | ||
| 124 | if r == "\n" then | ||
| 125 | luaX:errorline("unfinished string") | ||
| 126 | end | ||
| 127 | buff = buff..sub(z, i, p - 1) -- normal portions | ||
| 128 | i = p | ||
| 129 | if r == "\\" then -- handle escapes | ||
| 130 | i = i + 1 | ||
| 131 | r = sub(z, i, i) | ||
| 132 | if r == "" then break end -- (error) | ||
| 133 | p = find("\nabfnrtv", r, 1, 1) | ||
| 134 | ------------------------------------------------------ | ||
| 135 | if p then -- special escapes | ||
| 136 | r = sub("\n\a\b\f\n\r\t\v", p, p) | ||
| 137 | if p == 1 then | ||
| 138 | nextln(); i = 1 | ||
| 139 | else | ||
| 140 | i = i + 1 | ||
| 141 | end | ||
| 142 | ------------------------------------------------------ | ||
| 143 | elseif find(r, "%D") then -- other non-digits | ||
| 144 | i = i + 1 | ||
| 145 | ------------------------------------------------------ | ||
| 146 | else -- \xxx sequence | ||
| 147 | local p, q, s = find(z, "^(%d%d?%d?)", i) | ||
| 148 | i = q + 1 | ||
| 149 | if s + 1 > 256 then -- UCHAR_MAX | ||
| 150 | luaX:errorline("escape sequence too large") | ||
| 151 | end | ||
| 152 | r = string.char(s) | ||
| 153 | ------------------------------------------------------ | ||
| 154 | end--if p | ||
| 155 | else | ||
| 156 | i = i + 1 | ||
| 157 | if r == del then | ||
| 158 | I = i | ||
| 159 | return buff -- ending delimiter | ||
| 160 | end | ||
| 161 | end--if r | ||
| 162 | buff = buff..r | ||
| 163 | else | ||
| 164 | break -- (error) | ||
| 165 | end--if p | ||
| 166 | end--while | ||
| 167 | luaX:errorline("unfinished string") | ||
| 168 | end | ||
| 169 | ---------------------------------------------------------------------- | ||
| 170 | -- main lexer function | ||
| 171 | ---------------------------------------------------------------------- | ||
| 172 | function luaX:lex() | ||
| 173 | local string = string | ||
| 174 | local find, len = find, string.len | ||
| 175 | while true do--outer | ||
| 176 | local i = I | ||
| 177 | -- inner loop allows break to be used to nicely section tests | ||
| 178 | while true do--inner | ||
| 179 | ---------------------------------------------------------------- | ||
| 180 | local p, _, r = find(z, "^([_%a][_%w]*)", i) | ||
| 181 | if p then | ||
| 182 | I = i + len(r) | ||
| 183 | if kw[r] then return r end -- keyword | ||
| 184 | return "<name>", r -- identifier | ||
| 185 | end | ||
| 186 | ---------------------------------------------------------------- | ||
| 187 | local p, q, r = find(z, "^(%.?)%d", i) | ||
| 188 | if p then -- numeral | ||
| 189 | if r == "." then i = i + 1 end | ||
| 190 | local _, n, r, s = find(z, "^%d*(%.?%.?)%d*([eE]?)", i) | ||
| 191 | q = n | ||
| 192 | i = q + 1 | ||
| 193 | if len(r) == 2 then | ||
| 194 | self:errorline("ambiguous syntax (dots follows digits)") | ||
| 195 | end | ||
| 196 | if len(s) == 1 then -- optional exponent | ||
| 197 | local _, n = find(z, "^[%+%-]?%d*", i) -- optional sign | ||
| 198 | q = n | ||
| 199 | i = q + 1 | ||
| 200 | end | ||
| 201 | r = tonumber(sub(z, p, q)) | ||
| 202 | I = i | ||
| 203 | if not r then self:errorline("malformed number") end | ||
| 204 | return "<number>", r | ||
| 205 | end | ||
| 206 | ---------------------------------------------------------------- | ||
| 207 | local p, q, r = find(z, "^(%s)[ \t]*", i) | ||
| 208 | if p then | ||
| 209 | if r == "\n" then -- newline | ||
| 210 | nextln() | ||
| 211 | else | ||
| 212 | I = q + 1 -- whitespace | ||
| 213 | end | ||
| 214 | break -- (continue) | ||
| 215 | end | ||
| 216 | ---------------------------------------------------------------- | ||
| 217 | local p, _, r = find(z, "^(%p)", i) -- symbols/punctuation | ||
| 218 | if p then | ||
| 219 | local q = find("-[\"\'.=<>~", r, 1, 1) | ||
| 220 | if q then -- further processing for more complex symbols | ||
| 221 | ---------------------------------------------------- | ||
| 222 | if q <= 2 then | ||
| 223 | if q == 1 then -- minus | ||
| 224 | if find(z, "^%-%-", i) then | ||
| 225 | i = i + 2 | ||
| 226 | if find(z, "^%[%[", i) then -- long comment | ||
| 227 | read_long(i + 2) | ||
| 228 | else -- short comment | ||
| 229 | if find(z, "\n", i) then | ||
| 230 | nextln() | ||
| 231 | else | ||
| 232 | I = len(z) + 1 | ||
| 233 | end | ||
| 234 | end | ||
| 235 | break -- (continue) | ||
| 236 | end | ||
| 237 | -- (fall through for "-") | ||
| 238 | elseif q == 2 then -- [ or long string | ||
| 239 | if find(z, "^%[%[", i) then | ||
| 240 | return "<string>", read_long(i + 2, true) | ||
| 241 | end | ||
| 242 | -- (fall through for "[") | ||
| 243 | end | ||
| 244 | ---------------------------------------------------- | ||
| 245 | elseif q <= 5 then | ||
| 246 | if q < 5 then -- strings | ||
| 247 | return "<string>", read_string(i + 1, r) | ||
| 248 | end | ||
| 249 | local _, _, s = find(z, "^(%.%.?%.?)", i) -- dots | ||
| 250 | r = s | ||
| 251 | -- (fall through) | ||
| 252 | ---------------------------------------------------- | ||
| 253 | else -- relational/logic | ||
| 254 | local _, _, s = find(z, "^(%p=?)", i) | ||
| 255 | r = s | ||
| 256 | -- (fall through) | ||
| 257 | end | ||
| 258 | end | ||
| 259 | I = i + len(r); return r -- for other symbols, fall through | ||
| 260 | end | ||
| 261 | ---------------------------------------------------------------- | ||
| 262 | local r = sub(z, i, i) | ||
| 263 | if r ~= "" then | ||
| 264 | if find(r, "%c") then -- invalid control char | ||
| 265 | self:errorline("invalid control char("..string.byte(r)..")") | ||
| 266 | end | ||
| 267 | I = i + 1; return r -- other single-char tokens | ||
| 268 | end | ||
| 269 | return EOF -- end of stream | ||
| 270 | ---------------------------------------------------------------- | ||
| 271 | end--while inner | ||
| 272 | end--while outer | ||
| 273 | end | ||
| 274 | -------------------------------------------------------------------- | ||
| 275 | -- initial processing (shbang handling) | ||
| 276 | -------------------------------------------------------------------- | ||
| 277 | nextln() | ||
| 278 | local p, q, r = find(z, "^#[^\n]*(\n?)") | ||
| 279 | if p then -- skip first line | ||
| 280 | I = q + 1 | ||
| 281 | if r == "\n" then nextln() end | ||
| 282 | end | ||
| 283 | return luaX | ||
| 284 | -------------------------------------------------------------------- | ||
| 285 | end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/lparser_mk3.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/lparser_mk3.lua deleted file mode 100644 index 17d6f64..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/lparser_mk3.lua +++ /dev/null | |||
| @@ -1,1027 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | lparser.lua | ||
| 4 | Lua 5 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.0.x parser skeleton, for llex_mk3.lua lexer | ||
| 18 | -- * written as a module factory with recognizable lparser.c roots | ||
| 19 | -- * builds some data, performs logging for educational purposes | ||
| 20 | -- * target is to have relatively efficient and clear code | ||
| 21 | -- * needs one parameter, a lexer module that implements: | ||
| 22 | -- luaX:lex() - returns appropriate [token, semantic info] pairs | ||
| 23 | -- luaX.ln - current line number | ||
| 24 | -- luaX:errorline(s, [line]) - dies with error message | ||
| 25 | -- | ||
| 26 | -- Usage example: | ||
| 27 | -- lex_init = require("llex_mk3.lua") | ||
| 28 | -- parser_init = require("lparser_mk3.lua") | ||
| 29 | -- local luaX = lex_init(chunk, "=string") | ||
| 30 | -- local luaY = parser_init(luaX) | ||
| 31 | -- local fs = luaY:parser() | ||
| 32 | -- | ||
| 33 | -- Development notes: | ||
| 34 | -- * see test_parser-5.0.lua for grammar elements based on lparser.c | ||
| 35 | -- * lparser has a few extra items to help parsing/syntax checking | ||
| 36 | -- (a) line number (error reporting), lookahead token storage | ||
| 37 | -- (b) per-prototype states needs a storage list | ||
| 38 | -- (c) 'break' needs a per-block flag in a stack | ||
| 39 | -- (d) 'kind' (v.k) testing needed in expr_stat() and assignment() | ||
| 40 | -- for disambiguation, thus v.k manipulation is retained | ||
| 41 | -- (e) one line # var (lastln) for ambiguous (split line) function | ||
| 42 | -- call checking | ||
| 43 | -- (f) most line number function call args retained for future use | ||
| 44 | -- (g) Lua 4 compatibility code completely removed | ||
| 45 | -- (h) no variable management code! singlevar() always returns VLOCAL | ||
| 46 | -- * parsing starts from the end of this file in luaY:parser() | ||
| 47 | -- | ||
| 48 | ----------------------------------------------------------------------]] | ||
| 49 | |||
| 50 | return | ||
| 51 | function(luaX) | ||
| 52 | --[[-------------------------------------------------------------------- | ||
| 53 | -- structures and data initialization | ||
| 54 | ----------------------------------------------------------------------]] | ||
| 55 | |||
| 56 | local line -- start line # for error messages | ||
| 57 | local lastln -- last line # for ambiguous syntax chk | ||
| 58 | local tok, seminfo -- token, semantic info pair | ||
| 59 | local peek_tok, peek_sem -- ditto, for lookahead | ||
| 60 | local fs -- function state | ||
| 61 | local top_fs = {} -- top-level function state | ||
| 62 | local luaY = {} | ||
| 63 | -------------------------------------------------------------------- | ||
| 64 | local block_follow = {} -- lookahead check in chunk(), returnstat() | ||
| 65 | for v in string.gfind("else elseif end until <eof>", "%S+") do | ||
| 66 | block_follow[v] = true | ||
| 67 | end | ||
| 68 | -------------------------------------------------------------------- | ||
| 69 | local stat_call = {} -- lookup for calls in stat() | ||
| 70 | for v in string.gfind("if while do for repeat function local return break", "%S+") do | ||
| 71 | stat_call[v] = v.."_stat" | ||
| 72 | end | ||
| 73 | -------------------------------------------------------------------- | ||
| 74 | local binopr_left = {} -- binary operators, left priority | ||
| 75 | local binopr_right = {} -- binary operators, right priority | ||
| 76 | for op, lt, rt in string.gfind([[ | ||
| 77 | {+ 6 6}{- 6 6}{* 7 7}{/ 7 7}{^ 10 9}{.. 5 4} | ||
| 78 | {~= 3 3}{== 3 3}{< 3 3}{<= 3 3}{> 3 3}{>= 3 3} | ||
| 79 | {and 2 2}{or 1 1} | ||
| 80 | ]], "{(%S+)%s(%d+)%s(%d+)}") do | ||
| 81 | binopr_left[op] = lt + 0 | ||
| 82 | binopr_right[op] = rt + 0 | ||
| 83 | end | ||
| 84 | local unopr = { ["not"] = true, ["-"] = true, } -- unary operators | ||
| 85 | |||
| 86 | --[[-------------------------------------------------------------------- | ||
| 87 | -- logging: this logging function is for educational purposes | ||
| 88 | -- * logged data can be retrieved from the returned data structure | ||
| 89 | -- * or, replace self:log() instances with your custom code... | ||
| 90 | ----------------------------------------------------------------------]] | ||
| 91 | |||
| 92 | function luaY:log(msg) | ||
| 93 | local log = top_fs.log | ||
| 94 | if not log then log = {}; top_fs.log = log end | ||
| 95 | table.insert(top_fs.log, msg) | ||
| 96 | end | ||
| 97 | |||
| 98 | --[[-------------------------------------------------------------------- | ||
| 99 | -- support functions | ||
| 100 | ----------------------------------------------------------------------]] | ||
| 101 | |||
| 102 | -------------------------------------------------------------------- | ||
| 103 | -- reads in next token | ||
| 104 | -------------------------------------------------------------------- | ||
| 105 | function luaY:next() | ||
| 106 | lastln = luaX.ln | ||
| 107 | if peek_tok then -- is there a look-ahead token? if yes, use it | ||
| 108 | tok, seminfo = peek_tok, peek_sem | ||
| 109 | peek_tok = nil | ||
| 110 | else | ||
| 111 | tok, seminfo = luaX:lex() -- read next token | ||
| 112 | end | ||
| 113 | end | ||
| 114 | -------------------------------------------------------------------- | ||
| 115 | -- peek at next token (single lookahead for table constructor) | ||
| 116 | -------------------------------------------------------------------- | ||
| 117 | function luaY:lookahead() | ||
| 118 | peek_tok, peek_sem = luaX:lex() | ||
| 119 | return peek_tok | ||
| 120 | end | ||
| 121 | |||
| 122 | ------------------------------------------------------------------------ | ||
| 123 | -- throws a syntax error | ||
| 124 | ------------------------------------------------------------------------ | ||
| 125 | function luaY:syntaxerror(msg) | ||
| 126 | local tok = tok | ||
| 127 | if tok ~= "<number>" and tok ~= "<string>" then | ||
| 128 | if tok == "<name>" then tok = seminfo end | ||
| 129 | tok = "'"..tok.."'" | ||
| 130 | end | ||
| 131 | luaX:errorline(msg.." near "..tok) | ||
| 132 | end | ||
| 133 | -------------------------------------------------------------------- | ||
| 134 | -- throws a syntax error if token expected is not there | ||
| 135 | -------------------------------------------------------------------- | ||
| 136 | function luaY:error_expected(token) | ||
| 137 | self:syntaxerror("'"..token.."' expected") | ||
| 138 | end | ||
| 139 | |||
| 140 | -------------------------------------------------------------------- | ||
| 141 | -- verifies token conditions are met or else throw error | ||
| 142 | -------------------------------------------------------------------- | ||
| 143 | function luaY:check_match(what, who, where) | ||
| 144 | if not self:testnext(what) then | ||
| 145 | if where == luaX.ln then | ||
| 146 | self:error_expected(what) | ||
| 147 | else | ||
| 148 | self:syntaxerror("'"..what.."' expected (to close '"..who.."' at line "..where..")") | ||
| 149 | end | ||
| 150 | end | ||
| 151 | end | ||
| 152 | -------------------------------------------------------------------- | ||
| 153 | -- tests for a token, returns outcome | ||
| 154 | -- * return value changed to boolean | ||
| 155 | -------------------------------------------------------------------- | ||
| 156 | function luaY:testnext(c) | ||
| 157 | if tok == c then self:next(); return true end | ||
| 158 | end | ||
| 159 | -------------------------------------------------------------------- | ||
| 160 | -- throws error if condition not matched | ||
| 161 | -------------------------------------------------------------------- | ||
| 162 | function luaY:check_condition(c, msg) | ||
| 163 | if not c then self:syntaxerror(msg) end | ||
| 164 | end | ||
| 165 | -------------------------------------------------------------------- | ||
| 166 | -- check for existence of a token, throws error if not found | ||
| 167 | -------------------------------------------------------------------- | ||
| 168 | function luaY:check(c) | ||
| 169 | if not self:testnext(c) then self:error_expected(c) end | ||
| 170 | end | ||
| 171 | |||
| 172 | -------------------------------------------------------------------- | ||
| 173 | -- expect that token is a name, return the name | ||
| 174 | -------------------------------------------------------------------- | ||
| 175 | function luaY:str_checkname() | ||
| 176 | self:check_condition(tok == "<name>", "<name> expected") | ||
| 177 | local ts = seminfo | ||
| 178 | self:next() | ||
| 179 | self:log(" str_checkname: '"..ts.."'") | ||
| 180 | return ts | ||
| 181 | end | ||
| 182 | -------------------------------------------------------------------- | ||
| 183 | -- adds given string s in string pool, sets e as VK | ||
| 184 | -------------------------------------------------------------------- | ||
| 185 | function luaY:codestring(e, s) | ||
| 186 | e.k = "VK" | ||
| 187 | self:log(" codestring: "..string.format("%q", s)) | ||
| 188 | end | ||
| 189 | -------------------------------------------------------------------- | ||
| 190 | -- consume a name token, adds it to string pool | ||
| 191 | -------------------------------------------------------------------- | ||
| 192 | function luaY:checkname(e) | ||
| 193 | self:log(" checkname:") | ||
| 194 | self:codestring(e, self:str_checkname()) | ||
| 195 | end | ||
| 196 | |||
| 197 | --[[-------------------------------------------------------------------- | ||
| 198 | -- state management functions with open/close pairs | ||
| 199 | ----------------------------------------------------------------------]] | ||
| 200 | |||
| 201 | -------------------------------------------------------------------- | ||
| 202 | -- enters a code unit, initializes elements | ||
| 203 | -------------------------------------------------------------------- | ||
| 204 | function luaY:enterblock(isbreakable) | ||
| 205 | local bl = {} -- per-block state | ||
| 206 | bl.isbreakable = isbreakable | ||
| 207 | bl.prev = fs.bl | ||
| 208 | fs.bl = bl | ||
| 209 | self:log(">> enterblock(isbreakable="..tostring(isbreakable)..")") | ||
| 210 | end | ||
| 211 | -------------------------------------------------------------------- | ||
| 212 | -- leaves a code unit, close any upvalues | ||
| 213 | -------------------------------------------------------------------- | ||
| 214 | function luaY:leaveblock() | ||
| 215 | local bl = fs.bl | ||
| 216 | fs.bl = bl.prev | ||
| 217 | self:log("<< leaveblock") | ||
| 218 | end | ||
| 219 | -------------------------------------------------------------------- | ||
| 220 | -- opening of a function | ||
| 221 | -------------------------------------------------------------------- | ||
| 222 | function luaY:open_func() | ||
| 223 | local new_fs -- per-function state | ||
| 224 | if not fs then -- top_fs is created early | ||
| 225 | new_fs = top_fs | ||
| 226 | else | ||
| 227 | new_fs = {} | ||
| 228 | end | ||
| 229 | new_fs.prev = fs -- linked list of function states | ||
| 230 | new_fs.bl = nil | ||
| 231 | fs = new_fs | ||
| 232 | self:log(">> open_func") | ||
| 233 | end | ||
| 234 | -------------------------------------------------------------------- | ||
| 235 | -- closing of a function | ||
| 236 | -------------------------------------------------------------------- | ||
| 237 | function luaY:close_func() | ||
| 238 | fs = fs.prev | ||
| 239 | self:log("<< close_func") | ||
| 240 | end | ||
| 241 | |||
| 242 | --[[-------------------------------------------------------------------- | ||
| 243 | -- variable (global|local|upvalue) handling | ||
| 244 | -- * does nothing for now, always returns "VLOCAL" | ||
| 245 | ----------------------------------------------------------------------]] | ||
| 246 | |||
| 247 | -------------------------------------------------------------------- | ||
| 248 | -- consume a name token, creates a variable (global|local|upvalue) | ||
| 249 | -- * used in prefixexp(), funcname() | ||
| 250 | -------------------------------------------------------------------- | ||
| 251 | function luaY:singlevar(v) | ||
| 252 | local varname = self:str_checkname() | ||
| 253 | v.k = "VLOCAL" | ||
| 254 | self:log(" singlevar: name='"..varname.."'") | ||
| 255 | end | ||
| 256 | |||
| 257 | --[[-------------------------------------------------------------------- | ||
| 258 | -- other parsing functions | ||
| 259 | -- * for table constructor, parameter list, argument list | ||
| 260 | ----------------------------------------------------------------------]] | ||
| 261 | |||
| 262 | -------------------------------------------------------------------- | ||
| 263 | -- parse a function name suffix, for function call specifications | ||
| 264 | -- * used in primaryexp(), funcname() | ||
| 265 | -------------------------------------------------------------------- | ||
| 266 | function luaY:field(v) | ||
| 267 | -- field -> ['.' | ':'] NAME | ||
| 268 | local key = {} | ||
| 269 | self:log(" field: operator="..tok) | ||
| 270 | self:next() -- skip the dot or colon | ||
| 271 | self:checkname(key) | ||
| 272 | v.k = "VINDEXED" | ||
| 273 | end | ||
| 274 | -------------------------------------------------------------------- | ||
| 275 | -- parse a table indexing suffix, for constructors, expressions | ||
| 276 | -- * used in recfield(), primaryexp() | ||
| 277 | -------------------------------------------------------------------- | ||
| 278 | function luaY:index(v) | ||
| 279 | -- index -> '[' expr ']' | ||
| 280 | self:log(">> index: begin '['") | ||
| 281 | self:next() -- skip the '[' | ||
| 282 | self:expr(v) | ||
| 283 | self:check("]") | ||
| 284 | self:log("<< index: end ']'") | ||
| 285 | end | ||
| 286 | -------------------------------------------------------------------- | ||
| 287 | -- parse a table record (hash) field | ||
| 288 | -- * used in constructor() | ||
| 289 | -------------------------------------------------------------------- | ||
| 290 | function luaY:recfield(cc) | ||
| 291 | -- recfield -> (NAME | '['exp1']') = exp1 | ||
| 292 | local key, val = {}, {} | ||
| 293 | if tok == "<name>" then | ||
| 294 | self:log("recfield: name") | ||
| 295 | self:checkname(key) | ||
| 296 | else-- tok == '[' | ||
| 297 | self:log("recfield: [ exp1 ]") | ||
| 298 | self:index(key) | ||
| 299 | end | ||
| 300 | self:check("=") | ||
| 301 | self:expr(val) | ||
| 302 | end | ||
| 303 | -------------------------------------------------------------------- | ||
| 304 | -- emit a set list instruction if enough elements (LFIELDS_PER_FLUSH) | ||
| 305 | -- * note: retained in this skeleton because it modifies cc.v.k | ||
| 306 | -- * used in constructor() | ||
| 307 | -------------------------------------------------------------------- | ||
| 308 | function luaY:closelistfield(cc) | ||
| 309 | if cc.v.k == "VVOID" then return end -- there is no list item | ||
| 310 | cc.v.k = "VVOID" | ||
| 311 | end | ||
| 312 | -------------------------------------------------------------------- | ||
| 313 | -- parse a table list (array) field | ||
| 314 | -- * used in constructor() | ||
| 315 | -------------------------------------------------------------------- | ||
| 316 | function luaY:listfield(cc) | ||
| 317 | self:log("listfield: expr") | ||
| 318 | self:expr(cc.v) | ||
| 319 | end | ||
| 320 | -------------------------------------------------------------------- | ||
| 321 | -- parse a table constructor | ||
| 322 | -- * used in funcargs(), simpleexp() | ||
| 323 | -------------------------------------------------------------------- | ||
| 324 | function luaY:constructor(t) | ||
| 325 | -- constructor -> '{' [ field { fieldsep field } [ fieldsep ] ] '}' | ||
| 326 | -- field -> recfield | listfield | ||
| 327 | -- fieldsep -> ',' | ';' | ||
| 328 | self:log(">> constructor: begin") | ||
| 329 | local line = luaX.ln | ||
| 330 | local cc = {} | ||
| 331 | cc.v = {} | ||
| 332 | cc.t = t | ||
| 333 | t.k = "VRELOCABLE" | ||
| 334 | cc.v.k = "VVOID" | ||
| 335 | self:check("{") | ||
| 336 | repeat | ||
| 337 | self:testnext(";") -- compatibility only | ||
| 338 | if tok == "}" then break end | ||
| 339 | -- closelistfield(cc) here | ||
| 340 | local c = tok | ||
| 341 | if c == "<name>" then -- may be listfields or recfields | ||
| 342 | if self:lookahead() ~= "=" then -- look ahead: expression? | ||
| 343 | self:listfield(cc) | ||
| 344 | else | ||
| 345 | self:recfield(cc) | ||
| 346 | end | ||
| 347 | elseif c == "[" then -- constructor_item -> recfield | ||
| 348 | self:recfield(cc) | ||
| 349 | else -- constructor_part -> listfield | ||
| 350 | self:listfield(cc) | ||
| 351 | end | ||
| 352 | until not self:testnext(",") and not self:testnext(";") | ||
| 353 | self:check_match("}", "{", line) | ||
| 354 | -- lastlistfield(cc) here | ||
| 355 | self:log("<< constructor: end") | ||
| 356 | end | ||
| 357 | -------------------------------------------------------------------- | ||
| 358 | -- parse the arguments (parameters) of a function declaration | ||
| 359 | -- * used in body() | ||
| 360 | -------------------------------------------------------------------- | ||
| 361 | function luaY:parlist() | ||
| 362 | -- parlist -> [ param { ',' param } ] | ||
| 363 | self:log(">> parlist: begin") | ||
| 364 | local dots = false | ||
| 365 | if tok ~= ")" then -- is 'parlist' not empty? | ||
| 366 | repeat | ||
| 367 | local c = tok | ||
| 368 | if c == "..." then | ||
| 369 | self:log("parlist: ... (dots)") | ||
| 370 | dots = true | ||
| 371 | self:next() | ||
| 372 | elseif c == "<name>" then | ||
| 373 | local str = self:str_checkname() | ||
| 374 | else | ||
| 375 | self:syntaxerror("<name> or '...' expected") | ||
| 376 | end | ||
| 377 | until dots or not self:testnext(",") | ||
| 378 | end | ||
| 379 | self:log("<< parlist: end") | ||
| 380 | end | ||
| 381 | -------------------------------------------------------------------- | ||
| 382 | -- parse the parameters of a function call | ||
| 383 | -- * contrast with parlist(), used in function declarations | ||
| 384 | -- * used in primaryexp() | ||
| 385 | -------------------------------------------------------------------- | ||
| 386 | function luaY:funcargs(f) | ||
| 387 | local args = {} | ||
| 388 | local line = luaX.ln | ||
| 389 | local c = tok | ||
| 390 | if c == "(" then -- funcargs -> '(' [ explist1 ] ')' | ||
| 391 | self:log(">> funcargs: begin '('") | ||
| 392 | if line ~= lastln then | ||
| 393 | self:syntaxerror("ambiguous syntax (function call x new statement)") | ||
| 394 | end | ||
| 395 | self:next() | ||
| 396 | if tok == ")" then -- arg list is empty? | ||
| 397 | args.k = "VVOID" | ||
| 398 | else | ||
| 399 | self:explist1(args) | ||
| 400 | end | ||
| 401 | self:check_match(")", "(", line) | ||
| 402 | elseif c == "{" then -- funcargs -> constructor | ||
| 403 | self:log(">> funcargs: begin '{'") | ||
| 404 | self:constructor(args) | ||
| 405 | elseif c == "<string>" then -- funcargs -> STRING | ||
| 406 | self:log(">> funcargs: begin <string>") | ||
| 407 | self:codestring(args, seminfo) | ||
| 408 | self:next() -- must use 'seminfo' before 'next' | ||
| 409 | else | ||
| 410 | self:syntaxerror("function arguments expected") | ||
| 411 | return | ||
| 412 | end--if c | ||
| 413 | f.k = "VCALL" | ||
| 414 | self:log("<< funcargs: end -- expr is a VCALL") | ||
| 415 | end | ||
| 416 | |||
| 417 | --[[-------------------------------------------------------------------- | ||
| 418 | -- mostly expression functions | ||
| 419 | ----------------------------------------------------------------------]] | ||
| 420 | |||
| 421 | -------------------------------------------------------------------- | ||
| 422 | -- parses an expression in parentheses or a single variable | ||
| 423 | -- * used in primaryexp() | ||
| 424 | -------------------------------------------------------------------- | ||
| 425 | function luaY:prefixexp(v) | ||
| 426 | -- prefixexp -> NAME | '(' expr ')' | ||
| 427 | local c = tok | ||
| 428 | if c == "(" then | ||
| 429 | self:log(">> prefixexp: begin ( expr ) ") | ||
| 430 | local line = self.ln | ||
| 431 | self:next() | ||
| 432 | self:expr(v) | ||
| 433 | self:check_match(")", "(", line) | ||
| 434 | self:log("<< prefixexp: end ( expr ) ") | ||
| 435 | elseif c == "<name>" then | ||
| 436 | self:log("prefixexp: <name>") | ||
| 437 | self:singlevar(v) | ||
| 438 | else | ||
| 439 | self:syntaxerror("unexpected symbol") | ||
| 440 | end--if c | ||
| 441 | end | ||
| 442 | -------------------------------------------------------------------- | ||
| 443 | -- parses a prefixexp (an expression in parentheses or a single | ||
| 444 | -- variable) or a function call specification | ||
| 445 | -- * used in simpleexp(), assignment(), expr_stat() | ||
| 446 | -------------------------------------------------------------------- | ||
| 447 | function luaY:primaryexp(v) | ||
| 448 | -- primaryexp -> | ||
| 449 | -- prefixexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } | ||
| 450 | self:prefixexp(v) | ||
| 451 | while true do | ||
| 452 | local c = tok | ||
| 453 | if c == "." then -- field | ||
| 454 | self:log("primaryexp: '.' field") | ||
| 455 | self:field(v) | ||
| 456 | elseif c == "[" then -- '[' exp1 ']' | ||
| 457 | self:log("primaryexp: [ exp1 ]") | ||
| 458 | local key = {} | ||
| 459 | self:index(key) | ||
| 460 | elseif c == ":" then -- ':' NAME funcargs | ||
| 461 | self:log("primaryexp: :<name> funcargs") | ||
| 462 | local key = {} | ||
| 463 | self:next() | ||
| 464 | self:checkname(key) | ||
| 465 | self:funcargs(v) | ||
| 466 | elseif c == "(" or c == "<string>" or c == "{" then -- funcargs | ||
| 467 | self:log("primaryexp: "..c.." funcargs") | ||
| 468 | self:funcargs(v) | ||
| 469 | else | ||
| 470 | return | ||
| 471 | end--if c | ||
| 472 | end--while | ||
| 473 | end | ||
| 474 | -------------------------------------------------------------------- | ||
| 475 | -- parses general expression types, constants handled here | ||
| 476 | -- * used in subexpr() | ||
| 477 | -------------------------------------------------------------------- | ||
| 478 | function luaY:simpleexp(v) | ||
| 479 | -- simpleexp -> NUMBER | STRING | NIL | TRUE | FALSE | constructor | ||
| 480 | -- | FUNCTION body | primaryexp | ||
| 481 | local c = tok | ||
| 482 | if c == "<number>" then | ||
| 483 | self:log("simpleexp: <number>="..seminfo) | ||
| 484 | v.k = "VK" | ||
| 485 | self:next() -- must use 'seminfo' before 'next' | ||
| 486 | elseif c == "<string>" then | ||
| 487 | self:log("simpleexp: <string>="..seminfo) | ||
| 488 | self:codestring(v, seminfo) | ||
| 489 | self:next() -- must use 'seminfo' before 'next' | ||
| 490 | elseif c == "nil" then | ||
| 491 | self:log("simpleexp: nil") | ||
| 492 | v.k = "VNIL" | ||
| 493 | self:next() | ||
| 494 | elseif c == "true" then | ||
| 495 | self:log("simpleexp: true") | ||
| 496 | v.k = "VTRUE" | ||
| 497 | self:next() | ||
| 498 | elseif c == "false" then | ||
| 499 | self:log("simpleexp: false") | ||
| 500 | v.k = "VFALSE" | ||
| 501 | self:next() | ||
| 502 | elseif c == "{" then -- constructor | ||
| 503 | self:log("simpleexp: constructor") | ||
| 504 | self:constructor(v) | ||
| 505 | elseif c == "function" then | ||
| 506 | self:log("simpleexp: function") | ||
| 507 | self:next() | ||
| 508 | self:body(v, false, luaX.ln) | ||
| 509 | else | ||
| 510 | self:primaryexp(v) | ||
| 511 | end--if c | ||
| 512 | end | ||
| 513 | ------------------------------------------------------------------------ | ||
| 514 | -- Parse subexpressions. Includes handling of unary operators and binary | ||
| 515 | -- operators. A subexpr is given the rhs priority level of the operator | ||
| 516 | -- immediately left of it, if any (limit is -1 if none,) and if a binop | ||
| 517 | -- is found, limit is compared with the lhs priority level of the binop | ||
| 518 | -- in order to determine which executes first. | ||
| 519 | -- * recursively called | ||
| 520 | -- * used in expr() | ||
| 521 | ------------------------------------------------------------------------ | ||
| 522 | function luaY:subexpr(v, limit) | ||
| 523 | -- subexpr -> (simpleexp | unop subexpr) { binop subexpr } | ||
| 524 | -- * where 'binop' is any binary operator with a priority | ||
| 525 | -- higher than 'limit' | ||
| 526 | local op = tok | ||
| 527 | local uop = unopr[op] | ||
| 528 | if uop then | ||
| 529 | self:log(" subexpr: uop='"..op.."'") | ||
| 530 | self:next() | ||
| 531 | self:subexpr(v, 8) -- UNARY_PRIORITY | ||
| 532 | else | ||
| 533 | self:simpleexp(v) | ||
| 534 | end | ||
| 535 | -- expand while operators have priorities higher than 'limit' | ||
| 536 | op = tok | ||
| 537 | local binop = binopr_left[op] | ||
| 538 | while binop and binop > limit do | ||
| 539 | local v2 = {} | ||
| 540 | self:log(">> subexpr: binop='"..op.."'") | ||
| 541 | self:next() | ||
| 542 | -- read sub-expression with higher priority | ||
| 543 | local nextop = self:subexpr(v2, binopr_right[op]) | ||
| 544 | self:log("<< subexpr: -- evaluate") | ||
| 545 | op = nextop | ||
| 546 | binop = binopr_left[op] | ||
| 547 | end | ||
| 548 | return op -- return first untreated operator | ||
| 549 | end | ||
| 550 | -------------------------------------------------------------------- | ||
| 551 | -- Expression parsing starts here. Function subexpr is entered with the | ||
| 552 | -- left operator (which is non-existent) priority of -1, which is lower | ||
| 553 | -- than all actual operators. Expr information is returned in parm v. | ||
| 554 | -- * used in cond(), explist1(), index(), recfield(), listfield(), | ||
| 555 | -- prefixexp(), while_stat(), exp1() | ||
| 556 | -------------------------------------------------------------------- | ||
| 557 | function luaY:expr(v) | ||
| 558 | -- expr -> subexpr | ||
| 559 | self:log("expr:") | ||
| 560 | self:subexpr(v, -1) | ||
| 561 | end | ||
| 562 | |||
| 563 | --[[-------------------------------------------------------------------- | ||
| 564 | -- third level parsing functions | ||
| 565 | ----------------------------------------------------------------------]] | ||
| 566 | |||
| 567 | -------------------------------------------------------------------- | ||
| 568 | -- parse a variable assignment sequence | ||
| 569 | -- * recursively called | ||
| 570 | -- * used in expr_stat() | ||
| 571 | -------------------------------------------------------------------- | ||
| 572 | function luaY:assignment(v) | ||
| 573 | local e = {} | ||
| 574 | local c = v.v.k | ||
| 575 | self:check_condition(c == "VLOCAL" or c == "VUPVAL" or c == "VGLOBAL" | ||
| 576 | or c == "VINDEXED", "syntax error") | ||
| 577 | if self:testnext(",") then -- assignment -> ',' primaryexp assignment | ||
| 578 | local nv = {} -- expdesc | ||
| 579 | nv.v = {} | ||
| 580 | self:log("assignment: ',' -- next LHS element") | ||
| 581 | self:primaryexp(nv.v) | ||
| 582 | -- lparser.c deals with some register usage conflict here | ||
| 583 | self:assignment(nv) | ||
| 584 | else -- assignment -> '=' explist1 | ||
| 585 | self:check("=") | ||
| 586 | self:log("assignment: '=' -- RHS elements follows") | ||
| 587 | self:explist1(e) | ||
| 588 | return -- avoid default | ||
| 589 | end | ||
| 590 | e.k = "VNONRELOC" | ||
| 591 | end | ||
| 592 | -------------------------------------------------------------------- | ||
| 593 | -- parse a for loop body for both versions of the for loop | ||
| 594 | -- * used in fornum(), forlist() | ||
| 595 | -------------------------------------------------------------------- | ||
| 596 | function luaY:forbody(line, isnum) | ||
| 597 | self:check("do") | ||
| 598 | self:enterblock(true) -- loop block | ||
| 599 | self:block() | ||
| 600 | self:leaveblock() | ||
| 601 | end | ||
| 602 | -------------------------------------------------------------------- | ||
| 603 | -- parse a numerical for loop, calls forbody() | ||
| 604 | -- * used in for_stat() | ||
| 605 | -------------------------------------------------------------------- | ||
| 606 | function luaY:fornum(line) | ||
| 607 | -- fornum -> NAME = exp1, exp1 [, exp1] DO body | ||
| 608 | self:log(">> fornum: begin") | ||
| 609 | self:check("=") | ||
| 610 | self:log("fornum: index start") | ||
| 611 | self:exp1() -- initial value | ||
| 612 | self:check(",") | ||
| 613 | self:log("fornum: index stop") | ||
| 614 | self:exp1() -- limit | ||
| 615 | if self:testnext(",") then | ||
| 616 | self:log("fornum: index step") | ||
| 617 | self:exp1() -- optional step | ||
| 618 | else | ||
| 619 | -- default step = 1 | ||
| 620 | end | ||
| 621 | self:log("fornum: body") | ||
| 622 | self:forbody(line, true) | ||
| 623 | self:log("<< fornum: end") | ||
| 624 | end | ||
| 625 | -------------------------------------------------------------------- | ||
| 626 | -- parse a generic for loop, calls forbody() | ||
| 627 | -- * used in for_stat() | ||
| 628 | -------------------------------------------------------------------- | ||
| 629 | function luaY:forlist() | ||
| 630 | -- forlist -> NAME {, NAME} IN explist1 DO body | ||
| 631 | self:log(">> forlist: begin") | ||
| 632 | local e = {} | ||
| 633 | while self:testnext(",") do | ||
| 634 | self:str_checkname() | ||
| 635 | end | ||
| 636 | self:check("in") | ||
| 637 | local line = line | ||
| 638 | self:log("forlist: explist1") | ||
| 639 | self:explist1(e) | ||
| 640 | self:log("forlist: body") | ||
| 641 | self:forbody(line, false) | ||
| 642 | self:log("<< forlist: end") | ||
| 643 | end | ||
| 644 | -------------------------------------------------------------------- | ||
| 645 | -- parse a function name specification | ||
| 646 | -- * used in func_stat() | ||
| 647 | -------------------------------------------------------------------- | ||
| 648 | function luaY:funcname(v) | ||
| 649 | -- funcname -> NAME {field} [':' NAME] | ||
| 650 | self:log(">> funcname: begin") | ||
| 651 | local needself = false | ||
| 652 | self:singlevar(v) | ||
| 653 | while tok == "." do | ||
| 654 | self:log("funcname: -- '.' field") | ||
| 655 | self:field(v) | ||
| 656 | end | ||
| 657 | if tok == ":" then | ||
| 658 | self:log("funcname: -- ':' field") | ||
| 659 | needself = true | ||
| 660 | self:field(v) | ||
| 661 | end | ||
| 662 | self:log("<< funcname: end") | ||
| 663 | return needself | ||
| 664 | end | ||
| 665 | -------------------------------------------------------------------- | ||
| 666 | -- parse the single expressions needed in numerical for loops | ||
| 667 | -- * used in fornum() | ||
| 668 | -------------------------------------------------------------------- | ||
| 669 | function luaY:exp1() | ||
| 670 | -- exp1 -> expr | ||
| 671 | local e = {} | ||
| 672 | self:log(">> exp1: begin") | ||
| 673 | self:expr(e) | ||
| 674 | self:log("<< exp1: end") | ||
| 675 | end | ||
| 676 | -------------------------------------------------------------------- | ||
| 677 | -- parse condition in a repeat statement or an if control structure | ||
| 678 | -- * used in repeat_stat(), test_then_block() | ||
| 679 | -------------------------------------------------------------------- | ||
| 680 | function luaY:cond(v) | ||
| 681 | -- cond -> expr | ||
| 682 | self:log(">> cond: begin") | ||
| 683 | self:expr(v) -- read condition | ||
| 684 | self:log("<< cond: end") | ||
| 685 | end | ||
| 686 | -------------------------------------------------------------------- | ||
| 687 | -- parse part of an if control structure, including the condition | ||
| 688 | -- * used in if_stat() | ||
| 689 | -------------------------------------------------------------------- | ||
| 690 | function luaY:test_then_block(v) | ||
| 691 | -- test_then_block -> [IF | ELSEIF] cond THEN block | ||
| 692 | self:next() -- skip IF or ELSEIF | ||
| 693 | self:log("test_then_block: test condition") | ||
| 694 | self:cond(v) | ||
| 695 | self:check("then") | ||
| 696 | self:log("test_then_block: then block") | ||
| 697 | self:block() -- 'then' part | ||
| 698 | end | ||
| 699 | -------------------------------------------------------------------- | ||
| 700 | -- parse a local function statement | ||
| 701 | -- * used in local_stat() | ||
| 702 | -------------------------------------------------------------------- | ||
| 703 | function luaY:localfunc() | ||
| 704 | -- localfunc -> NAME body | ||
| 705 | local v, b = {} | ||
| 706 | self:log("localfunc: begin") | ||
| 707 | local str = self:str_checkname() | ||
| 708 | v.k = "VLOCAL" | ||
| 709 | self:log("localfunc: body") | ||
| 710 | self:body(b, false, luaX.ln) | ||
| 711 | self:log("localfunc: end") | ||
| 712 | end | ||
| 713 | -------------------------------------------------------------------- | ||
| 714 | -- parse a local variable declaration statement | ||
| 715 | -- * used in local_stat() | ||
| 716 | -------------------------------------------------------------------- | ||
| 717 | function luaY:localstat() | ||
| 718 | -- localstat -> NAME {',' NAME} ['=' explist1] | ||
| 719 | self:log(">> localstat: begin") | ||
| 720 | local e = {} | ||
| 721 | repeat | ||
| 722 | local str = self:str_checkname() | ||
| 723 | until not self:testnext(",") | ||
| 724 | if self:testnext("=") then | ||
| 725 | self:log("localstat: -- assignment") | ||
| 726 | self:explist1(e) | ||
| 727 | else | ||
| 728 | e.k = "VVOID" | ||
| 729 | end | ||
| 730 | self:log("<< localstat: end") | ||
| 731 | end | ||
| 732 | -------------------------------------------------------------------- | ||
| 733 | -- parse a list of comma-separated expressions | ||
| 734 | -- * used in return_stat(), localstat(), funcargs(), assignment(), | ||
| 735 | -- forlist() | ||
| 736 | -------------------------------------------------------------------- | ||
| 737 | function luaY:explist1(e) | ||
| 738 | -- explist1 -> expr { ',' expr } | ||
| 739 | self:log(">> explist1: begin") | ||
| 740 | self:expr(e) | ||
| 741 | while self:testnext(",") do | ||
| 742 | self:log("explist1: ',' -- continuation") | ||
| 743 | self:expr(e) | ||
| 744 | end | ||
| 745 | self:log("<< explist1: end") | ||
| 746 | end | ||
| 747 | -------------------------------------------------------------------- | ||
| 748 | -- parse function declaration body | ||
| 749 | -- * used in simpleexp(), localfunc(), func_stat() | ||
| 750 | -------------------------------------------------------------------- | ||
| 751 | function luaY:body(e, needself, line) | ||
| 752 | -- body -> '(' parlist ')' chunk END | ||
| 753 | self:open_func() | ||
| 754 | self:log("body: begin") | ||
| 755 | self:check("(") | ||
| 756 | if needself then | ||
| 757 | -- handle 'self' processing here | ||
| 758 | end | ||
| 759 | self:log("body: parlist") | ||
| 760 | self:parlist() | ||
| 761 | self:check(")") | ||
| 762 | self:log("body: chunk") | ||
| 763 | self:chunk() | ||
| 764 | self:check_match("end", "function", line) | ||
| 765 | self:log("body: end") | ||
| 766 | self:close_func() | ||
| 767 | end | ||
| 768 | -------------------------------------------------------------------- | ||
| 769 | -- parse a code block or unit | ||
| 770 | -- * used in do_stat(), while_stat(), repeat_stat(), forbody(), | ||
| 771 | -- test_then_block(), if_stat() | ||
| 772 | -------------------------------------------------------------------- | ||
| 773 | function luaY:block() | ||
| 774 | -- block -> chunk | ||
| 775 | self:log("block: begin") | ||
| 776 | self:enterblock(false) | ||
| 777 | self:chunk() | ||
| 778 | self:leaveblock() | ||
| 779 | self:log("block: end") | ||
| 780 | end | ||
| 781 | |||
| 782 | --[[-------------------------------------------------------------------- | ||
| 783 | -- second level parsing functions, all with '_stat' suffix | ||
| 784 | -- * stat() -> *_stat() | ||
| 785 | ----------------------------------------------------------------------]] | ||
| 786 | |||
| 787 | -------------------------------------------------------------------- | ||
| 788 | -- initial parsing for a for loop, calls fornum() or forlist() | ||
| 789 | -- * used in stat() | ||
| 790 | -------------------------------------------------------------------- | ||
| 791 | function luaY:for_stat() | ||
| 792 | -- stat -> for_stat -> fornum | forlist | ||
| 793 | local line = line | ||
| 794 | self:log("for_stat: begin") | ||
| 795 | self:enterblock(false) -- block to control variable scope | ||
| 796 | self:next() -- skip 'for' | ||
| 797 | local str = self:str_checkname() -- first variable name | ||
| 798 | local c = tok | ||
| 799 | if c == "=" then | ||
| 800 | self:log("for_stat: numerical loop") | ||
| 801 | self:fornum(line) | ||
| 802 | elseif c == "," or c == "in" then | ||
| 803 | self:log("for_stat: list-based loop") | ||
| 804 | self:forlist() | ||
| 805 | else | ||
| 806 | self:syntaxerror("'=' or 'in' expected") | ||
| 807 | end | ||
| 808 | self:check_match("end", "for", line) | ||
| 809 | self:leaveblock() | ||
| 810 | self:log("for_stat: end") | ||
| 811 | end | ||
| 812 | -------------------------------------------------------------------- | ||
| 813 | -- parse a while-do control structure, body processed by block() | ||
| 814 | -- * used in stat() | ||
| 815 | -------------------------------------------------------------------- | ||
| 816 | function luaY:while_stat() | ||
| 817 | -- stat -> while_stat -> WHILE cond DO block END | ||
| 818 | local line = line | ||
| 819 | local v = {} | ||
| 820 | self:next() -- skip WHILE | ||
| 821 | self:log("while_stat: begin/condition") | ||
| 822 | self:expr(v) -- parse condition | ||
| 823 | self:enterblock(true) | ||
| 824 | self:check("do") | ||
| 825 | self:log("while_stat: block") | ||
| 826 | self:block() | ||
| 827 | self:check_match("end", "while", line) | ||
| 828 | self:leaveblock() | ||
| 829 | self:log("while_stat: end") | ||
| 830 | end | ||
| 831 | -------------------------------------------------------------------- | ||
| 832 | -- parse a repeat-until control structure, body parsed by block() | ||
| 833 | -- * used in stat() | ||
| 834 | -------------------------------------------------------------------- | ||
| 835 | function luaY:repeat_stat() | ||
| 836 | -- stat -> repeat_stat -> REPEAT block UNTIL cond | ||
| 837 | local line = line | ||
| 838 | local v = {} | ||
| 839 | self:log("repeat_stat: begin") | ||
| 840 | self:enterblock(true) | ||
| 841 | self:next() | ||
| 842 | self:block() | ||
| 843 | self:check_match("until", "repeat", line) | ||
| 844 | self:log("repeat_stat: condition") | ||
| 845 | self:cond(v) | ||
| 846 | self:leaveblock() | ||
| 847 | self:log("repeat_stat: end") | ||
| 848 | end | ||
| 849 | -------------------------------------------------------------------- | ||
| 850 | -- parse an if control structure | ||
| 851 | -- * used in stat() | ||
| 852 | -------------------------------------------------------------------- | ||
| 853 | function luaY:if_stat() | ||
| 854 | -- stat -> if_stat -> IF cond THEN block | ||
| 855 | -- {ELSEIF cond THEN block} [ELSE block] END | ||
| 856 | local line = line | ||
| 857 | local v = {} | ||
| 858 | self:log("if_stat: if...then") | ||
| 859 | self:test_then_block(v) -- IF cond THEN block | ||
| 860 | while tok == "elseif" do | ||
| 861 | self:log("if_stat: elseif...then") | ||
| 862 | self:test_then_block(v) -- ELSEIF cond THEN block | ||
| 863 | end | ||
| 864 | if tok == "else" then | ||
| 865 | self:log("if_stat: else...") | ||
| 866 | self:next() -- skip ELSE | ||
| 867 | self:block() -- 'else' part | ||
| 868 | end | ||
| 869 | self:check_match("end", "if", line) | ||
| 870 | self:log("if_stat: end") | ||
| 871 | end | ||
| 872 | -------------------------------------------------------------------- | ||
| 873 | -- parse a return statement | ||
| 874 | -- * used in stat() | ||
| 875 | -------------------------------------------------------------------- | ||
| 876 | function luaY:return_stat() | ||
| 877 | -- stat -> return_stat -> RETURN explist | ||
| 878 | local e = {} | ||
| 879 | self:next() -- skip RETURN | ||
| 880 | local c = tok | ||
| 881 | if block_follow[c] or c == ";" then | ||
| 882 | -- return no values | ||
| 883 | self:log("return_stat: no return values") | ||
| 884 | else | ||
| 885 | self:log("return_stat: begin") | ||
| 886 | self:explist1(e) -- optional return values | ||
| 887 | self:log("return_stat: end") | ||
| 888 | end | ||
| 889 | end | ||
| 890 | -------------------------------------------------------------------- | ||
| 891 | -- parse a break statement | ||
| 892 | -- * used in stat() | ||
| 893 | -------------------------------------------------------------------- | ||
| 894 | function luaY:break_stat() | ||
| 895 | -- stat -> break_stat -> BREAK | ||
| 896 | local bl = fs.bl | ||
| 897 | self:next() -- skip BREAK | ||
| 898 | while bl and not bl.isbreakable do -- find a breakable block | ||
| 899 | bl = bl.prev | ||
| 900 | end | ||
| 901 | if not bl then | ||
| 902 | self:syntaxerror("no loop to break") | ||
| 903 | end | ||
| 904 | self:log("break_stat: -- break out of loop") | ||
| 905 | end | ||
| 906 | -------------------------------------------------------------------- | ||
| 907 | -- parse a function call with no returns or an assignment statement | ||
| 908 | -- * the struct with .prev is used for name searching in lparse.c, | ||
| 909 | -- so it is retained for now; present in assignment() also | ||
| 910 | -- * used in stat() | ||
| 911 | -------------------------------------------------------------------- | ||
| 912 | function luaY:expr_stat() | ||
| 913 | -- stat -> expr_stat -> func | assignment | ||
| 914 | local v = {} | ||
| 915 | v.v = {} | ||
| 916 | self:primaryexp(v.v) | ||
| 917 | if v.v.k == "VCALL" then -- stat -> func | ||
| 918 | -- call statement uses no results | ||
| 919 | self:log("expr_stat: function call k='"..v.v.k.."'") | ||
| 920 | else -- stat -> assignment | ||
| 921 | self:log("expr_stat: assignment k='"..v.v.k.."'") | ||
| 922 | v.prev = nil | ||
| 923 | self:assignment(v) | ||
| 924 | end | ||
| 925 | end | ||
| 926 | -------------------------------------------------------------------- | ||
| 927 | -- parse a function statement | ||
| 928 | -- * used in stat() | ||
| 929 | -------------------------------------------------------------------- | ||
| 930 | function luaY:function_stat() | ||
| 931 | -- stat -> function_stat -> FUNCTION funcname body | ||
| 932 | local line = line | ||
| 933 | local v, b = {}, {} | ||
| 934 | self:log("function_stat: begin") | ||
| 935 | self:next() -- skip FUNCTION | ||
| 936 | local needself = self:funcname(v) | ||
| 937 | self:log("function_stat: body needself='"..tostring(needself).."'") | ||
| 938 | self:body(b, needself, line) | ||
| 939 | self:log("function_stat: end") | ||
| 940 | end | ||
| 941 | -------------------------------------------------------------------- | ||
| 942 | -- parse a simple block enclosed by a DO..END pair | ||
| 943 | -- * used in stat() | ||
| 944 | -------------------------------------------------------------------- | ||
| 945 | function luaY:do_stat() | ||
| 946 | -- stat -> do_stat -> DO block END | ||
| 947 | self:next() -- skip DO | ||
| 948 | self:log("do_stat: begin") | ||
| 949 | self:block() | ||
| 950 | self:log("do_stat: end") | ||
| 951 | self:check_match("end", "do", line) | ||
| 952 | end | ||
| 953 | -------------------------------------------------------------------- | ||
| 954 | -- parse a statement starting with LOCAL | ||
| 955 | -- * used in stat() | ||
| 956 | -------------------------------------------------------------------- | ||
| 957 | function luaY:local_stat() | ||
| 958 | -- stat -> local_stat -> LOCAL FUNCTION localfunc | ||
| 959 | -- -> LOCAL localstat | ||
| 960 | self:next() -- skip LOCAL | ||
| 961 | if self:testnext("function") then -- local function? | ||
| 962 | self:log("local_stat: local function") | ||
| 963 | self:localfunc() | ||
| 964 | else | ||
| 965 | self:log("local_stat: local statement") | ||
| 966 | self:localstat() | ||
| 967 | end | ||
| 968 | end | ||
| 969 | |||
| 970 | --[[-------------------------------------------------------------------- | ||
| 971 | -- main function, top level parsing functions | ||
| 972 | -- * [entry] -> parser() -> chunk() -> stat() | ||
| 973 | ----------------------------------------------------------------------]] | ||
| 974 | |||
| 975 | -------------------------------------------------------------------- | ||
| 976 | -- initial parsing for statements, calls '_stat' suffixed functions | ||
| 977 | -- * used in chunk() | ||
| 978 | -------------------------------------------------------------------- | ||
| 979 | function luaY:stat() | ||
| 980 | line = luaX.ln | ||
| 981 | local c = tok | ||
| 982 | local fn = stat_call[c] | ||
| 983 | -- handles: if while do for repeat function local return break | ||
| 984 | if fn then | ||
| 985 | self:log("-- STATEMENT: begin '"..c.."' line="..line) | ||
| 986 | self[fn](self) | ||
| 987 | self:log("-- STATEMENT: end '"..c.."'") | ||
| 988 | -- return or break must be last statement | ||
| 989 | if c == "return" or c == "break" then return true end | ||
| 990 | else | ||
| 991 | self:log("-- STATEMENT: begin 'expr' line="..line) | ||
| 992 | self:expr_stat() | ||
| 993 | self:log("-- STATEMENT: end 'expr'") | ||
| 994 | end | ||
| 995 | self:log("") | ||
| 996 | return false | ||
| 997 | end | ||
| 998 | -------------------------------------------------------------------- | ||
| 999 | -- parse a chunk, which consists of a bunch of statements | ||
| 1000 | -- * used in parser(), body(), block() | ||
| 1001 | -------------------------------------------------------------------- | ||
| 1002 | function luaY:chunk() | ||
| 1003 | -- chunk -> { stat [';'] } | ||
| 1004 | self:log("chunk:") | ||
| 1005 | local islast = false | ||
| 1006 | while not islast and not block_follow[tok] do | ||
| 1007 | islast = self:stat() | ||
| 1008 | self:testnext(";") | ||
| 1009 | end | ||
| 1010 | end | ||
| 1011 | -------------------------------------------------------------------- | ||
| 1012 | -- performs parsing, returns parsed data structure | ||
| 1013 | -------------------------------------------------------------------- | ||
| 1014 | function luaY:parser() | ||
| 1015 | self:log("-- TOP: begin") | ||
| 1016 | self:open_func() | ||
| 1017 | self:log("") | ||
| 1018 | self:next() -- read first token | ||
| 1019 | self:chunk() | ||
| 1020 | self:check_condition(tok == "<eof>", "<eof> expected") | ||
| 1021 | self:close_func() | ||
| 1022 | self:log("-- TOP: end") | ||
| 1023 | return top_fs | ||
| 1024 | end | ||
| 1025 | -------------------------------------------------------------------- | ||
| 1026 | return luaY -- return actual module to user, done | ||
| 1027 | end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/lparser_mk3b.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/lparser_mk3b.lua deleted file mode 100644 index a46edc6..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/lparser_mk3b.lua +++ /dev/null | |||
| @@ -1,1121 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | lparser.lua | ||
| 4 | Lua 5 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.0.x parser skeleton, for llex_mk3.lua lexer | ||
| 18 | -- * written as a module factory with recognizable lparser.c roots | ||
| 19 | -- * builds some data, performs logging for educational purposes | ||
| 20 | -- * target is to have relatively efficient and clear code | ||
| 21 | -- * needs one parameter, a lexer module that implements: | ||
| 22 | -- luaX:lex() - returns appropriate [token, semantic info] pairs | ||
| 23 | -- luaX.ln - current line number | ||
| 24 | -- luaX:errorline(s, [line]) - dies with error message | ||
| 25 | -- | ||
| 26 | -- Usage example: | ||
| 27 | -- lex_init = require("llex_mk3.lua") | ||
| 28 | -- parser_init = require("lparser_mk3.lua") | ||
| 29 | -- local luaX = lex_init(chunk, "=string") | ||
| 30 | -- local luaY = parser_init(luaX) | ||
| 31 | -- local fs = luaY:parser() | ||
| 32 | -- | ||
| 33 | -- Development notes: | ||
| 34 | -- * see test_parser-5.0.lua for grammar elements based on lparser.c | ||
| 35 | -- * lparser has a few extra items to help parsing/syntax checking | ||
| 36 | -- (a) line number (error reporting), lookahead token storage | ||
| 37 | -- (b) per-prototype states needs a storage list | ||
| 38 | -- (c) 'break' needs a per-block flag in a stack | ||
| 39 | -- (d) 'kind' (v.k) testing needed in expr_stat() and assignment() | ||
| 40 | -- for disambiguation, thus v.k manipulation is retained | ||
| 41 | -- (e) one line # var (lastln) for ambiguous (split line) function | ||
| 42 | -- call checking | ||
| 43 | -- (f) most line number function call args retained for future use | ||
| 44 | -- (g) Lua 4 compatibility code completely removed | ||
| 45 | -- (h) minimal variable management code to differentiate each type | ||
| 46 | -- * parsing starts from the end of this file in luaY:parser() | ||
| 47 | -- | ||
| 48 | ----------------------------------------------------------------------]] | ||
| 49 | |||
| 50 | return | ||
| 51 | function(luaX) | ||
| 52 | --[[-------------------------------------------------------------------- | ||
| 53 | -- structures and data initialization | ||
| 54 | ----------------------------------------------------------------------]] | ||
| 55 | |||
| 56 | local line -- start line # for error messages | ||
| 57 | local lastln -- last line # for ambiguous syntax chk | ||
| 58 | local tok, seminfo -- token, semantic info pair | ||
| 59 | local peek_tok, peek_sem -- ditto, for lookahead | ||
| 60 | local fs -- function state | ||
| 61 | local top_fs = {} -- top-level function state | ||
| 62 | local luaY = {} | ||
| 63 | -------------------------------------------------------------------- | ||
| 64 | local block_follow = {} -- lookahead check in chunk(), returnstat() | ||
| 65 | for v in string.gfind("else elseif end until <eof>", "%S+") do | ||
| 66 | block_follow[v] = true | ||
| 67 | end | ||
| 68 | -------------------------------------------------------------------- | ||
| 69 | local stat_call = {} -- lookup for calls in stat() | ||
| 70 | for v in string.gfind("if while do for repeat function local return break", "%S+") do | ||
| 71 | stat_call[v] = v.."_stat" | ||
| 72 | end | ||
| 73 | -------------------------------------------------------------------- | ||
| 74 | local binopr_left = {} -- binary operators, left priority | ||
| 75 | local binopr_right = {} -- binary operators, right priority | ||
| 76 | for op, lt, rt in string.gfind([[ | ||
| 77 | {+ 6 6}{- 6 6}{* 7 7}{/ 7 7}{^ 10 9}{.. 5 4} | ||
| 78 | {~= 3 3}{== 3 3}{< 3 3}{<= 3 3}{> 3 3}{>= 3 3} | ||
| 79 | {and 2 2}{or 1 1} | ||
| 80 | ]], "{(%S+)%s(%d+)%s(%d+)}") do | ||
| 81 | binopr_left[op] = lt + 0 | ||
| 82 | binopr_right[op] = rt + 0 | ||
| 83 | end | ||
| 84 | local unopr = { ["not"] = true, ["-"] = true, } -- unary operators | ||
| 85 | |||
| 86 | --[[-------------------------------------------------------------------- | ||
| 87 | -- logging: this logging function is for educational purposes | ||
| 88 | -- * logged data can be retrieved from the returned data structure | ||
| 89 | -- * or, replace self:log() instances with your custom code... | ||
| 90 | ----------------------------------------------------------------------]] | ||
| 91 | |||
| 92 | function luaY:log(msg) | ||
| 93 | local log = top_fs.log | ||
| 94 | if not log then log = {}; top_fs.log = log end | ||
| 95 | table.insert(top_fs.log, msg) | ||
| 96 | end | ||
| 97 | |||
| 98 | --[[-------------------------------------------------------------------- | ||
| 99 | -- support functions | ||
| 100 | ----------------------------------------------------------------------]] | ||
| 101 | |||
| 102 | -------------------------------------------------------------------- | ||
| 103 | -- reads in next token | ||
| 104 | -------------------------------------------------------------------- | ||
| 105 | function luaY:next() | ||
| 106 | lastln = luaX.ln | ||
| 107 | if peek_tok then -- is there a look-ahead token? if yes, use it | ||
| 108 | tok, seminfo = peek_tok, peek_sem | ||
| 109 | peek_tok = nil | ||
| 110 | else | ||
| 111 | tok, seminfo = luaX:lex() -- read next token | ||
| 112 | end | ||
| 113 | end | ||
| 114 | -------------------------------------------------------------------- | ||
| 115 | -- peek at next token (single lookahead for table constructor) | ||
| 116 | -------------------------------------------------------------------- | ||
| 117 | function luaY:lookahead() | ||
| 118 | peek_tok, peek_sem = luaX:lex() | ||
| 119 | return peek_tok | ||
| 120 | end | ||
| 121 | |||
| 122 | ------------------------------------------------------------------------ | ||
| 123 | -- throws a syntax error | ||
| 124 | ------------------------------------------------------------------------ | ||
| 125 | function luaY:syntaxerror(msg) | ||
| 126 | local tok = tok | ||
| 127 | if tok ~= "<number>" and tok ~= "<string>" then | ||
| 128 | if tok == "<name>" then tok = seminfo end | ||
| 129 | tok = "'"..tok.."'" | ||
| 130 | end | ||
| 131 | luaX:errorline(msg.." near "..tok) | ||
| 132 | end | ||
| 133 | -------------------------------------------------------------------- | ||
| 134 | -- throws a syntax error if token expected is not there | ||
| 135 | -------------------------------------------------------------------- | ||
| 136 | function luaY:error_expected(token) | ||
| 137 | self:syntaxerror("'"..token.."' expected") | ||
| 138 | end | ||
| 139 | |||
| 140 | -------------------------------------------------------------------- | ||
| 141 | -- verifies token conditions are met or else throw error | ||
| 142 | -------------------------------------------------------------------- | ||
| 143 | function luaY:check_match(what, who, where) | ||
| 144 | if not self:testnext(what) then | ||
| 145 | if where == luaX.ln then | ||
| 146 | self:error_expected(what) | ||
| 147 | else | ||
| 148 | self:syntaxerror("'"..what.."' expected (to close '"..who.."' at line "..where..")") | ||
| 149 | end | ||
| 150 | end | ||
| 151 | end | ||
| 152 | -------------------------------------------------------------------- | ||
| 153 | -- tests for a token, returns outcome | ||
| 154 | -- * return value changed to boolean | ||
| 155 | -------------------------------------------------------------------- | ||
| 156 | function luaY:testnext(c) | ||
| 157 | if tok == c then self:next(); return true end | ||
| 158 | end | ||
| 159 | -------------------------------------------------------------------- | ||
| 160 | -- throws error if condition not matched | ||
| 161 | -------------------------------------------------------------------- | ||
| 162 | function luaY:check_condition(c, msg) | ||
| 163 | if not c then self:syntaxerror(msg) end | ||
| 164 | end | ||
| 165 | -------------------------------------------------------------------- | ||
| 166 | -- check for existence of a token, throws error if not found | ||
| 167 | -------------------------------------------------------------------- | ||
| 168 | function luaY:check(c) | ||
| 169 | if not self:testnext(c) then self:error_expected(c) end | ||
| 170 | end | ||
| 171 | |||
| 172 | -------------------------------------------------------------------- | ||
| 173 | -- expect that token is a name, return the name | ||
| 174 | -------------------------------------------------------------------- | ||
| 175 | function luaY:str_checkname() | ||
| 176 | self:check_condition(tok == "<name>", "<name> expected") | ||
| 177 | local ts = seminfo | ||
| 178 | self:next() | ||
| 179 | self:log(" str_checkname: '"..ts.."'") | ||
| 180 | return ts | ||
| 181 | end | ||
| 182 | -------------------------------------------------------------------- | ||
| 183 | -- adds given string s in string pool, sets e as VK | ||
| 184 | -------------------------------------------------------------------- | ||
| 185 | function luaY:codestring(e, s) | ||
| 186 | e.k = "VK" | ||
| 187 | self:log(" codestring: "..string.format("%q", s)) | ||
| 188 | end | ||
| 189 | -------------------------------------------------------------------- | ||
| 190 | -- consume a name token, adds it to string pool | ||
| 191 | -------------------------------------------------------------------- | ||
| 192 | function luaY:checkname(e) | ||
| 193 | self:log(" checkname:") | ||
| 194 | self:codestring(e, self:str_checkname()) | ||
| 195 | end | ||
| 196 | |||
| 197 | --[[-------------------------------------------------------------------- | ||
| 198 | -- state management functions with open/close pairs | ||
| 199 | ----------------------------------------------------------------------]] | ||
| 200 | |||
| 201 | -------------------------------------------------------------------- | ||
| 202 | -- enters a code unit, initializes elements | ||
| 203 | -------------------------------------------------------------------- | ||
| 204 | function luaY:enterblock(isbreakable) | ||
| 205 | local bl = {} -- per-block state | ||
| 206 | bl.isbreakable = isbreakable | ||
| 207 | bl.prev = fs.bl | ||
| 208 | bl.locallist = {} | ||
| 209 | fs.bl = bl | ||
| 210 | self:log(">> enterblock(isbreakable="..tostring(isbreakable)..")") | ||
| 211 | end | ||
| 212 | -------------------------------------------------------------------- | ||
| 213 | -- leaves a code unit, close any upvalues | ||
| 214 | -------------------------------------------------------------------- | ||
| 215 | function luaY:leaveblock() | ||
| 216 | local bl = fs.bl | ||
| 217 | fs.bl = bl.prev | ||
| 218 | self:log("<< leaveblock") | ||
| 219 | end | ||
| 220 | -------------------------------------------------------------------- | ||
| 221 | -- opening of a function | ||
| 222 | -------------------------------------------------------------------- | ||
| 223 | function luaY:open_func() | ||
| 224 | local new_fs -- per-function state | ||
| 225 | if not fs then -- top_fs is created early | ||
| 226 | new_fs = top_fs | ||
| 227 | else | ||
| 228 | new_fs = {} | ||
| 229 | end | ||
| 230 | new_fs.prev = fs -- linked list of function states | ||
| 231 | new_fs.bl = nil | ||
| 232 | new_fs.locallist = {} | ||
| 233 | fs = new_fs | ||
| 234 | self:log(">> open_func") | ||
| 235 | end | ||
| 236 | -------------------------------------------------------------------- | ||
| 237 | -- closing of a function | ||
| 238 | -------------------------------------------------------------------- | ||
| 239 | function luaY:close_func() | ||
| 240 | fs = fs.prev | ||
| 241 | self:log("<< close_func") | ||
| 242 | end | ||
| 243 | |||
| 244 | --[[-------------------------------------------------------------------- | ||
| 245 | -- variable (global|local|upvalue) handling | ||
| 246 | -- * a pure parser does not really need this, but if we want to produce | ||
| 247 | -- useful output, might as well write minimal code to manage this... | ||
| 248 | -- * entry point is singlevar() for variable lookups | ||
| 249 | -- * three entry points for local variable creation, in order to keep | ||
| 250 | -- to original C calls, but the extra arguments such as positioning | ||
| 251 | -- are removed as we are not allocating registers -- we are only | ||
| 252 | -- doing simple classification | ||
| 253 | -- * lookup tables (bl.locallist) are maintained awkwardly in the basic | ||
| 254 | -- block data structures, PLUS the function data structure (this is | ||
| 255 | -- an inelegant hack, since bl is nil for the top level of a function) | ||
| 256 | ----------------------------------------------------------------------]] | ||
| 257 | |||
| 258 | -------------------------------------------------------------------- | ||
| 259 | -- register a local variable, set in active variable list | ||
| 260 | -- * used in new_localvarstr(), parlist(), fornum(), forlist(), | ||
| 261 | -- localfunc(), localstat() | ||
| 262 | -------------------------------------------------------------------- | ||
| 263 | function luaY:new_localvar(name) | ||
| 264 | local bl = fs.bl | ||
| 265 | local locallist | ||
| 266 | if bl then | ||
| 267 | locallist = bl.locallist | ||
| 268 | else | ||
| 269 | locallist = fs.locallist | ||
| 270 | end | ||
| 271 | locallist[name] = true | ||
| 272 | self:log(" new_localvar: '"..name.."'") | ||
| 273 | end | ||
| 274 | -------------------------------------------------------------------- | ||
| 275 | -- creates a new local variable given a name | ||
| 276 | -- * used in fornum(), forlist() for loop variables; in create_local() | ||
| 277 | -------------------------------------------------------------------- | ||
| 278 | function luaY:new_localvarstr(name) | ||
| 279 | self:new_localvar(name) | ||
| 280 | end | ||
| 281 | -------------------------------------------------------------------- | ||
| 282 | -- creates a single local variable and activates it | ||
| 283 | -- * used only in code_params() for "arg", body() for "self" | ||
| 284 | -------------------------------------------------------------------- | ||
| 285 | function luaY:create_local(name) | ||
| 286 | self:new_localvarstr(name) | ||
| 287 | end | ||
| 288 | |||
| 289 | -------------------------------------------------------------------- | ||
| 290 | -- search the local variable namespace of the given fs for a match | ||
| 291 | -- * a simple lookup only, no active variable list kept, so no useful | ||
| 292 | -- index value can be returned by this function | ||
| 293 | -- * used only in singlevaraux() | ||
| 294 | -------------------------------------------------------------------- | ||
| 295 | function luaY:searchvar(fs, n) | ||
| 296 | local bl = fs.bl | ||
| 297 | if bl then | ||
| 298 | locallist = bl.locallist | ||
| 299 | while locallist do | ||
| 300 | if locallist[n] then return 1 end -- found | ||
| 301 | bl = bl.prev | ||
| 302 | locallist = bl and bl.locallist | ||
| 303 | end | ||
| 304 | end | ||
| 305 | locallist = fs.locallist | ||
| 306 | if locallist[n] then return 1 end -- found | ||
| 307 | return -1 -- not found | ||
| 308 | end | ||
| 309 | -------------------------------------------------------------------- | ||
| 310 | -- handle locals, globals and upvalues and related processing | ||
| 311 | -- * search mechanism is recursive, calls itself to search parents | ||
| 312 | -- * used only in singlevar() | ||
| 313 | -------------------------------------------------------------------- | ||
| 314 | function luaY:singlevaraux(fs, n, var, base) | ||
| 315 | if fs == nil then -- no more levels? | ||
| 316 | var.k = "VGLOBAL" -- default is global variable | ||
| 317 | else | ||
| 318 | local v = self:searchvar(fs, n) -- look up at current level | ||
| 319 | if v >= 0 then | ||
| 320 | var.k = "VLOCAL" | ||
| 321 | else -- not found at current level; try upper one | ||
| 322 | self:singlevaraux(fs.prev, n, var, 0) | ||
| 323 | if var.k == "VGLOBAL" then | ||
| 324 | -- handle global var processing here | ||
| 325 | else -- LOCAL or UPVAL | ||
| 326 | var.k = "VUPVAL" | ||
| 327 | end | ||
| 328 | end--if v | ||
| 329 | end--if fs | ||
| 330 | end | ||
| 331 | -------------------------------------------------------------------- | ||
| 332 | -- consume a name token, creates a variable (global|local|upvalue) | ||
| 333 | -- * used in prefixexp(), funcname() | ||
| 334 | -------------------------------------------------------------------- | ||
| 335 | function luaY:singlevar(v) | ||
| 336 | local varname = self:str_checkname() | ||
| 337 | self:singlevaraux(fs, varname, v, 1) | ||
| 338 | self:log(" singlevar(kind): '"..v.k.."'") | ||
| 339 | end | ||
| 340 | |||
| 341 | --[[-------------------------------------------------------------------- | ||
| 342 | -- other parsing functions | ||
| 343 | -- * for table constructor, parameter list, argument list | ||
| 344 | ----------------------------------------------------------------------]] | ||
| 345 | |||
| 346 | -------------------------------------------------------------------- | ||
| 347 | -- parse a function name suffix, for function call specifications | ||
| 348 | -- * used in primaryexp(), funcname() | ||
| 349 | -------------------------------------------------------------------- | ||
| 350 | function luaY:field(v) | ||
| 351 | -- field -> ['.' | ':'] NAME | ||
| 352 | local key = {} | ||
| 353 | self:log(" field: operator="..tok) | ||
| 354 | self:next() -- skip the dot or colon | ||
| 355 | self:checkname(key) | ||
| 356 | v.k = "VINDEXED" | ||
| 357 | end | ||
| 358 | -------------------------------------------------------------------- | ||
| 359 | -- parse a table indexing suffix, for constructors, expressions | ||
| 360 | -- * used in recfield(), primaryexp() | ||
| 361 | -------------------------------------------------------------------- | ||
| 362 | function luaY:index(v) | ||
| 363 | -- index -> '[' expr ']' | ||
| 364 | self:log(">> index: begin '['") | ||
| 365 | self:next() -- skip the '[' | ||
| 366 | self:expr(v) | ||
| 367 | self:check("]") | ||
| 368 | self:log("<< index: end ']'") | ||
| 369 | end | ||
| 370 | -------------------------------------------------------------------- | ||
| 371 | -- parse a table record (hash) field | ||
| 372 | -- * used in constructor() | ||
| 373 | -------------------------------------------------------------------- | ||
| 374 | function luaY:recfield(cc) | ||
| 375 | -- recfield -> (NAME | '['exp1']') = exp1 | ||
| 376 | local key, val = {}, {} | ||
| 377 | if tok == "<name>" then | ||
| 378 | self:log("recfield: name") | ||
| 379 | self:checkname(key) | ||
| 380 | else-- tok == '[' | ||
| 381 | self:log("recfield: [ exp1 ]") | ||
| 382 | self:index(key) | ||
| 383 | end | ||
| 384 | self:check("=") | ||
| 385 | self:expr(val) | ||
| 386 | end | ||
| 387 | -------------------------------------------------------------------- | ||
| 388 | -- emit a set list instruction if enough elements (LFIELDS_PER_FLUSH) | ||
| 389 | -- * note: retained in this skeleton because it modifies cc.v.k | ||
| 390 | -- * used in constructor() | ||
| 391 | -------------------------------------------------------------------- | ||
| 392 | function luaY:closelistfield(cc) | ||
| 393 | if cc.v.k == "VVOID" then return end -- there is no list item | ||
| 394 | cc.v.k = "VVOID" | ||
| 395 | end | ||
| 396 | -------------------------------------------------------------------- | ||
| 397 | -- parse a table list (array) field | ||
| 398 | -- * used in constructor() | ||
| 399 | -------------------------------------------------------------------- | ||
| 400 | function luaY:listfield(cc) | ||
| 401 | self:log("listfield: expr") | ||
| 402 | self:expr(cc.v) | ||
| 403 | end | ||
| 404 | -------------------------------------------------------------------- | ||
| 405 | -- parse a table constructor | ||
| 406 | -- * used in funcargs(), simpleexp() | ||
| 407 | -------------------------------------------------------------------- | ||
| 408 | function luaY:constructor(t) | ||
| 409 | -- constructor -> '{' [ field { fieldsep field } [ fieldsep ] ] '}' | ||
| 410 | -- field -> recfield | listfield | ||
| 411 | -- fieldsep -> ',' | ';' | ||
| 412 | self:log(">> constructor: begin") | ||
| 413 | local line = luaX.ln | ||
| 414 | local cc = {} | ||
| 415 | cc.v = {} | ||
| 416 | cc.t = t | ||
| 417 | t.k = "VRELOCABLE" | ||
| 418 | cc.v.k = "VVOID" | ||
| 419 | self:check("{") | ||
| 420 | repeat | ||
| 421 | self:testnext(";") -- compatibility only | ||
| 422 | if tok == "}" then break end | ||
| 423 | -- closelistfield(cc) here | ||
| 424 | local c = tok | ||
| 425 | if c == "<name>" then -- may be listfields or recfields | ||
| 426 | if self:lookahead() ~= "=" then -- look ahead: expression? | ||
| 427 | self:listfield(cc) | ||
| 428 | else | ||
| 429 | self:recfield(cc) | ||
| 430 | end | ||
| 431 | elseif c == "[" then -- constructor_item -> recfield | ||
| 432 | self:recfield(cc) | ||
| 433 | else -- constructor_part -> listfield | ||
| 434 | self:listfield(cc) | ||
| 435 | end | ||
| 436 | until not self:testnext(",") and not self:testnext(";") | ||
| 437 | self:check_match("}", "{", line) | ||
| 438 | -- lastlistfield(cc) here | ||
| 439 | self:log("<< constructor: end") | ||
| 440 | end | ||
| 441 | -------------------------------------------------------------------- | ||
| 442 | -- parse the arguments (parameters) of a function declaration | ||
| 443 | -- * used in body() | ||
| 444 | -------------------------------------------------------------------- | ||
| 445 | function luaY:parlist() | ||
| 446 | -- parlist -> [ param { ',' param } ] | ||
| 447 | self:log(">> parlist: begin") | ||
| 448 | local dots = false | ||
| 449 | if tok ~= ")" then -- is 'parlist' not empty? | ||
| 450 | repeat | ||
| 451 | local c = tok | ||
| 452 | if c == "..." then | ||
| 453 | self:log("parlist: ... (dots)") | ||
| 454 | dots = true | ||
| 455 | self:next() | ||
| 456 | elseif c == "<name>" then | ||
| 457 | self:new_localvar(self:str_checkname()) | ||
| 458 | else | ||
| 459 | self:syntaxerror("<name> or '...' expected") | ||
| 460 | end | ||
| 461 | until dots or not self:testnext(",") | ||
| 462 | end | ||
| 463 | -- was code_params() | ||
| 464 | if dots then | ||
| 465 | self:create_local("arg") | ||
| 466 | end | ||
| 467 | self:log("<< parlist: end") | ||
| 468 | end | ||
| 469 | -------------------------------------------------------------------- | ||
| 470 | -- parse the parameters of a function call | ||
| 471 | -- * contrast with parlist(), used in function declarations | ||
| 472 | -- * used in primaryexp() | ||
| 473 | -------------------------------------------------------------------- | ||
| 474 | function luaY:funcargs(f) | ||
| 475 | local args = {} | ||
| 476 | local line = luaX.ln | ||
| 477 | local c = tok | ||
| 478 | if c == "(" then -- funcargs -> '(' [ explist1 ] ')' | ||
| 479 | self:log(">> funcargs: begin '('") | ||
| 480 | if line ~= lastln then | ||
| 481 | self:syntaxerror("ambiguous syntax (function call x new statement)") | ||
| 482 | end | ||
| 483 | self:next() | ||
| 484 | if tok == ")" then -- arg list is empty? | ||
| 485 | args.k = "VVOID" | ||
| 486 | else | ||
| 487 | self:explist1(args) | ||
| 488 | end | ||
| 489 | self:check_match(")", "(", line) | ||
| 490 | elseif c == "{" then -- funcargs -> constructor | ||
| 491 | self:log(">> funcargs: begin '{'") | ||
| 492 | self:constructor(args) | ||
| 493 | elseif c == "<string>" then -- funcargs -> STRING | ||
| 494 | self:log(">> funcargs: begin <string>") | ||
| 495 | self:codestring(args, seminfo) | ||
| 496 | self:next() -- must use 'seminfo' before 'next' | ||
| 497 | else | ||
| 498 | self:syntaxerror("function arguments expected") | ||
| 499 | return | ||
| 500 | end--if c | ||
| 501 | f.k = "VCALL" | ||
| 502 | self:log("<< funcargs: end -- expr is a VCALL") | ||
| 503 | end | ||
| 504 | |||
| 505 | --[[-------------------------------------------------------------------- | ||
| 506 | -- mostly expression functions | ||
| 507 | ----------------------------------------------------------------------]] | ||
| 508 | |||
| 509 | -------------------------------------------------------------------- | ||
| 510 | -- parses an expression in parentheses or a single variable | ||
| 511 | -- * used in primaryexp() | ||
| 512 | -------------------------------------------------------------------- | ||
| 513 | function luaY:prefixexp(v) | ||
| 514 | -- prefixexp -> NAME | '(' expr ')' | ||
| 515 | local c = tok | ||
| 516 | if c == "(" then | ||
| 517 | self:log(">> prefixexp: begin ( expr ) ") | ||
| 518 | local line = self.ln | ||
| 519 | self:next() | ||
| 520 | self:expr(v) | ||
| 521 | self:check_match(")", "(", line) | ||
| 522 | self:log("<< prefixexp: end ( expr ) ") | ||
| 523 | elseif c == "<name>" then | ||
| 524 | self:log("prefixexp: <name>") | ||
| 525 | self:singlevar(v) | ||
| 526 | else | ||
| 527 | self:syntaxerror("unexpected symbol") | ||
| 528 | end--if c | ||
| 529 | end | ||
| 530 | -------------------------------------------------------------------- | ||
| 531 | -- parses a prefixexp (an expression in parentheses or a single | ||
| 532 | -- variable) or a function call specification | ||
| 533 | -- * used in simpleexp(), assignment(), expr_stat() | ||
| 534 | -------------------------------------------------------------------- | ||
| 535 | function luaY:primaryexp(v) | ||
| 536 | -- primaryexp -> | ||
| 537 | -- prefixexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } | ||
| 538 | self:prefixexp(v) | ||
| 539 | while true do | ||
| 540 | local c = tok | ||
| 541 | if c == "." then -- field | ||
| 542 | self:log("primaryexp: '.' field") | ||
| 543 | self:field(v) | ||
| 544 | elseif c == "[" then -- '[' exp1 ']' | ||
| 545 | self:log("primaryexp: [ exp1 ]") | ||
| 546 | local key = {} | ||
| 547 | self:index(key) | ||
| 548 | elseif c == ":" then -- ':' NAME funcargs | ||
| 549 | self:log("primaryexp: :<name> funcargs") | ||
| 550 | local key = {} | ||
| 551 | self:next() | ||
| 552 | self:checkname(key) | ||
| 553 | self:funcargs(v) | ||
| 554 | elseif c == "(" or c == "<string>" or c == "{" then -- funcargs | ||
| 555 | self:log("primaryexp: "..c.." funcargs") | ||
| 556 | self:funcargs(v) | ||
| 557 | else | ||
| 558 | return | ||
| 559 | end--if c | ||
| 560 | end--while | ||
| 561 | end | ||
| 562 | -------------------------------------------------------------------- | ||
| 563 | -- parses general expression types, constants handled here | ||
| 564 | -- * used in subexpr() | ||
| 565 | -------------------------------------------------------------------- | ||
| 566 | function luaY:simpleexp(v) | ||
| 567 | -- simpleexp -> NUMBER | STRING | NIL | TRUE | FALSE | constructor | ||
| 568 | -- | FUNCTION body | primaryexp | ||
| 569 | local c = tok | ||
| 570 | if c == "<number>" then | ||
| 571 | self:log("simpleexp: <number>="..seminfo) | ||
| 572 | v.k = "VK" | ||
| 573 | self:next() -- must use 'seminfo' before 'next' | ||
| 574 | elseif c == "<string>" then | ||
| 575 | self:log("simpleexp: <string>="..seminfo) | ||
| 576 | self:codestring(v, seminfo) | ||
| 577 | self:next() -- must use 'seminfo' before 'next' | ||
| 578 | elseif c == "nil" then | ||
| 579 | self:log("simpleexp: nil") | ||
| 580 | v.k = "VNIL" | ||
| 581 | self:next() | ||
| 582 | elseif c == "true" then | ||
| 583 | self:log("simpleexp: true") | ||
| 584 | v.k = "VTRUE" | ||
| 585 | self:next() | ||
| 586 | elseif c == "false" then | ||
| 587 | self:log("simpleexp: false") | ||
| 588 | v.k = "VFALSE" | ||
| 589 | self:next() | ||
| 590 | elseif c == "{" then -- constructor | ||
| 591 | self:log("simpleexp: constructor") | ||
| 592 | self:constructor(v) | ||
| 593 | elseif c == "function" then | ||
| 594 | self:log("simpleexp: function") | ||
| 595 | self:next() | ||
| 596 | self:body(v, false, luaX.ln) | ||
| 597 | else | ||
| 598 | self:primaryexp(v) | ||
| 599 | end--if c | ||
| 600 | end | ||
| 601 | ------------------------------------------------------------------------ | ||
| 602 | -- Parse subexpressions. Includes handling of unary operators and binary | ||
| 603 | -- operators. A subexpr is given the rhs priority level of the operator | ||
| 604 | -- immediately left of it, if any (limit is -1 if none,) and if a binop | ||
| 605 | -- is found, limit is compared with the lhs priority level of the binop | ||
| 606 | -- in order to determine which executes first. | ||
| 607 | -- * recursively called | ||
| 608 | -- * used in expr() | ||
| 609 | ------------------------------------------------------------------------ | ||
| 610 | function luaY:subexpr(v, limit) | ||
| 611 | -- subexpr -> (simpleexp | unop subexpr) { binop subexpr } | ||
| 612 | -- * where 'binop' is any binary operator with a priority | ||
| 613 | -- higher than 'limit' | ||
| 614 | local op = tok | ||
| 615 | local uop = unopr[op] | ||
| 616 | if uop then | ||
| 617 | self:log(" subexpr: uop='"..op.."'") | ||
| 618 | self:next() | ||
| 619 | self:subexpr(v, 8) -- UNARY_PRIORITY | ||
| 620 | else | ||
| 621 | self:simpleexp(v) | ||
| 622 | end | ||
| 623 | -- expand while operators have priorities higher than 'limit' | ||
| 624 | op = tok | ||
| 625 | local binop = binopr_left[op] | ||
| 626 | while binop and binop > limit do | ||
| 627 | local v2 = {} | ||
| 628 | self:log(">> subexpr: binop='"..op.."'") | ||
| 629 | self:next() | ||
| 630 | -- read sub-expression with higher priority | ||
| 631 | local nextop = self:subexpr(v2, binopr_right[op]) | ||
| 632 | self:log("<< subexpr: -- evaluate") | ||
| 633 | op = nextop | ||
| 634 | binop = binopr_left[op] | ||
| 635 | end | ||
| 636 | return op -- return first untreated operator | ||
| 637 | end | ||
| 638 | -------------------------------------------------------------------- | ||
| 639 | -- Expression parsing starts here. Function subexpr is entered with the | ||
| 640 | -- left operator (which is non-existent) priority of -1, which is lower | ||
| 641 | -- than all actual operators. Expr information is returned in parm v. | ||
| 642 | -- * used in cond(), explist1(), index(), recfield(), listfield(), | ||
| 643 | -- prefixexp(), while_stat(), exp1() | ||
| 644 | -------------------------------------------------------------------- | ||
| 645 | function luaY:expr(v) | ||
| 646 | -- expr -> subexpr | ||
| 647 | self:log("expr:") | ||
| 648 | self:subexpr(v, -1) | ||
| 649 | end | ||
| 650 | |||
| 651 | --[[-------------------------------------------------------------------- | ||
| 652 | -- third level parsing functions | ||
| 653 | ----------------------------------------------------------------------]] | ||
| 654 | |||
| 655 | -------------------------------------------------------------------- | ||
| 656 | -- parse a variable assignment sequence | ||
| 657 | -- * recursively called | ||
| 658 | -- * used in expr_stat() | ||
| 659 | -------------------------------------------------------------------- | ||
| 660 | function luaY:assignment(v) | ||
| 661 | local e = {} | ||
| 662 | local c = v.v.k | ||
| 663 | self:check_condition(c == "VLOCAL" or c == "VUPVAL" or c == "VGLOBAL" | ||
| 664 | or c == "VINDEXED", "syntax error") | ||
| 665 | if self:testnext(",") then -- assignment -> ',' primaryexp assignment | ||
| 666 | local nv = {} -- expdesc | ||
| 667 | nv.v = {} | ||
| 668 | self:log("assignment: ',' -- next LHS element") | ||
| 669 | self:primaryexp(nv.v) | ||
| 670 | -- lparser.c deals with some register usage conflict here | ||
| 671 | self:assignment(nv) | ||
| 672 | else -- assignment -> '=' explist1 | ||
| 673 | self:check("=") | ||
| 674 | self:log("assignment: '=' -- RHS elements follows") | ||
| 675 | self:explist1(e) | ||
| 676 | return -- avoid default | ||
| 677 | end | ||
| 678 | e.k = "VNONRELOC" | ||
| 679 | end | ||
| 680 | -------------------------------------------------------------------- | ||
| 681 | -- parse a for loop body for both versions of the for loop | ||
| 682 | -- * used in fornum(), forlist() | ||
| 683 | -------------------------------------------------------------------- | ||
| 684 | function luaY:forbody(line, isnum) | ||
| 685 | self:check("do") | ||
| 686 | self:enterblock(true) -- loop block | ||
| 687 | self:block() | ||
| 688 | self:leaveblock() | ||
| 689 | end | ||
| 690 | -------------------------------------------------------------------- | ||
| 691 | -- parse a numerical for loop, calls forbody() | ||
| 692 | -- * used in for_stat() | ||
| 693 | -------------------------------------------------------------------- | ||
| 694 | function luaY:fornum(varname, line) | ||
| 695 | -- fornum -> NAME = exp1, exp1 [, exp1] DO body | ||
| 696 | self:new_localvar(varname) | ||
| 697 | self:new_localvarstr("(for limit)") | ||
| 698 | self:new_localvarstr("(for step)") | ||
| 699 | self:log(">> fornum: begin") | ||
| 700 | self:check("=") | ||
| 701 | self:log("fornum: index start") | ||
| 702 | self:exp1() -- initial value | ||
| 703 | self:check(",") | ||
| 704 | self:log("fornum: index stop") | ||
| 705 | self:exp1() -- limit | ||
| 706 | if self:testnext(",") then | ||
| 707 | self:log("fornum: index step") | ||
| 708 | self:exp1() -- optional step | ||
| 709 | else | ||
| 710 | -- default step = 1 | ||
| 711 | end | ||
| 712 | self:log("fornum: body") | ||
| 713 | self:forbody(line, true) | ||
| 714 | self:log("<< fornum: end") | ||
| 715 | end | ||
| 716 | -------------------------------------------------------------------- | ||
| 717 | -- parse a generic for loop, calls forbody() | ||
| 718 | -- * used in for_stat() | ||
| 719 | -------------------------------------------------------------------- | ||
| 720 | function luaY:forlist(indexname) | ||
| 721 | -- forlist -> NAME {, NAME} IN explist1 DO body | ||
| 722 | self:log(">> forlist: begin") | ||
| 723 | local e = {} | ||
| 724 | self:new_localvarstr("(for generator)") | ||
| 725 | self:new_localvarstr("(for state)") | ||
| 726 | self:new_localvar(indexname) | ||
| 727 | while self:testnext(",") do | ||
| 728 | self:new_localvar(self:str_checkname()) | ||
| 729 | end | ||
| 730 | self:check("in") | ||
| 731 | local line = line | ||
| 732 | self:log("forlist: explist1") | ||
| 733 | self:explist1(e) | ||
| 734 | self:log("forlist: body") | ||
| 735 | self:forbody(line, false) | ||
| 736 | self:log("<< forlist: end") | ||
| 737 | end | ||
| 738 | -------------------------------------------------------------------- | ||
| 739 | -- parse a function name specification | ||
| 740 | -- * used in func_stat() | ||
| 741 | -------------------------------------------------------------------- | ||
| 742 | function luaY:funcname(v) | ||
| 743 | -- funcname -> NAME {field} [':' NAME] | ||
| 744 | self:log(">> funcname: begin") | ||
| 745 | local needself = false | ||
| 746 | self:singlevar(v) | ||
| 747 | while tok == "." do | ||
| 748 | self:log("funcname: -- '.' field") | ||
| 749 | self:field(v) | ||
| 750 | end | ||
| 751 | if tok == ":" then | ||
| 752 | self:log("funcname: -- ':' field") | ||
| 753 | needself = true | ||
| 754 | self:field(v) | ||
| 755 | end | ||
| 756 | self:log("<< funcname: end") | ||
| 757 | return needself | ||
| 758 | end | ||
| 759 | -------------------------------------------------------------------- | ||
| 760 | -- parse the single expressions needed in numerical for loops | ||
| 761 | -- * used in fornum() | ||
| 762 | -------------------------------------------------------------------- | ||
| 763 | function luaY:exp1() | ||
| 764 | -- exp1 -> expr | ||
| 765 | local e = {} | ||
| 766 | self:log(">> exp1: begin") | ||
| 767 | self:expr(e) | ||
| 768 | self:log("<< exp1: end") | ||
| 769 | end | ||
| 770 | -------------------------------------------------------------------- | ||
| 771 | -- parse condition in a repeat statement or an if control structure | ||
| 772 | -- * used in repeat_stat(), test_then_block() | ||
| 773 | -------------------------------------------------------------------- | ||
| 774 | function luaY:cond(v) | ||
| 775 | -- cond -> expr | ||
| 776 | self:log(">> cond: begin") | ||
| 777 | self:expr(v) -- read condition | ||
| 778 | self:log("<< cond: end") | ||
| 779 | end | ||
| 780 | -------------------------------------------------------------------- | ||
| 781 | -- parse part of an if control structure, including the condition | ||
| 782 | -- * used in if_stat() | ||
| 783 | -------------------------------------------------------------------- | ||
| 784 | function luaY:test_then_block(v) | ||
| 785 | -- test_then_block -> [IF | ELSEIF] cond THEN block | ||
| 786 | self:next() -- skip IF or ELSEIF | ||
| 787 | self:log("test_then_block: test condition") | ||
| 788 | self:cond(v) | ||
| 789 | self:check("then") | ||
| 790 | self:log("test_then_block: then block") | ||
| 791 | self:block() -- 'then' part | ||
| 792 | end | ||
| 793 | -------------------------------------------------------------------- | ||
| 794 | -- parse a local function statement | ||
| 795 | -- * used in local_stat() | ||
| 796 | -------------------------------------------------------------------- | ||
| 797 | function luaY:localfunc() | ||
| 798 | -- localfunc -> NAME body | ||
| 799 | local v, b = {} | ||
| 800 | self:log("localfunc: begin") | ||
| 801 | self:new_localvar(self:str_checkname()) | ||
| 802 | v.k = "VLOCAL" | ||
| 803 | self:log("localfunc: body") | ||
| 804 | self:body(b, false, luaX.ln) | ||
| 805 | self:log("localfunc: end") | ||
| 806 | end | ||
| 807 | -------------------------------------------------------------------- | ||
| 808 | -- parse a local variable declaration statement | ||
| 809 | -- * used in local_stat() | ||
| 810 | -------------------------------------------------------------------- | ||
| 811 | function luaY:localstat() | ||
| 812 | -- localstat -> NAME {',' NAME} ['=' explist1] | ||
| 813 | self:log(">> localstat: begin") | ||
| 814 | local e = {} | ||
| 815 | repeat | ||
| 816 | self:new_localvar(self:str_checkname()) | ||
| 817 | until not self:testnext(",") | ||
| 818 | if self:testnext("=") then | ||
| 819 | self:log("localstat: -- assignment") | ||
| 820 | self:explist1(e) | ||
| 821 | else | ||
| 822 | e.k = "VVOID" | ||
| 823 | end | ||
| 824 | self:log("<< localstat: end") | ||
| 825 | end | ||
| 826 | -------------------------------------------------------------------- | ||
| 827 | -- parse a list of comma-separated expressions | ||
| 828 | -- * used in return_stat(), localstat(), funcargs(), assignment(), | ||
| 829 | -- forlist() | ||
| 830 | -------------------------------------------------------------------- | ||
| 831 | function luaY:explist1(e) | ||
| 832 | -- explist1 -> expr { ',' expr } | ||
| 833 | self:log(">> explist1: begin") | ||
| 834 | self:expr(e) | ||
| 835 | while self:testnext(",") do | ||
| 836 | self:log("explist1: ',' -- continuation") | ||
| 837 | self:expr(e) | ||
| 838 | end | ||
| 839 | self:log("<< explist1: end") | ||
| 840 | end | ||
| 841 | -------------------------------------------------------------------- | ||
| 842 | -- parse function declaration body | ||
| 843 | -- * used in simpleexp(), localfunc(), func_stat() | ||
| 844 | -------------------------------------------------------------------- | ||
| 845 | function luaY:body(e, needself, line) | ||
| 846 | -- body -> '(' parlist ')' chunk END | ||
| 847 | self:open_func() | ||
| 848 | self:log("body: begin") | ||
| 849 | self:check("(") | ||
| 850 | if needself then | ||
| 851 | self:create_local("self") | ||
| 852 | end | ||
| 853 | self:log("body: parlist") | ||
| 854 | self:parlist() | ||
| 855 | self:check(")") | ||
| 856 | self:log("body: chunk") | ||
| 857 | self:chunk() | ||
| 858 | self:check_match("end", "function", line) | ||
| 859 | self:log("body: end") | ||
| 860 | self:close_func() | ||
| 861 | end | ||
| 862 | -------------------------------------------------------------------- | ||
| 863 | -- parse a code block or unit | ||
| 864 | -- * used in do_stat(), while_stat(), repeat_stat(), forbody(), | ||
| 865 | -- test_then_block(), if_stat() | ||
| 866 | -------------------------------------------------------------------- | ||
| 867 | function luaY:block() | ||
| 868 | -- block -> chunk | ||
| 869 | self:log("block: begin") | ||
| 870 | self:enterblock(false) | ||
| 871 | self:chunk() | ||
| 872 | self:leaveblock() | ||
| 873 | self:log("block: end") | ||
| 874 | end | ||
| 875 | |||
| 876 | --[[-------------------------------------------------------------------- | ||
| 877 | -- second level parsing functions, all with '_stat' suffix | ||
| 878 | -- * stat() -> *_stat() | ||
| 879 | ----------------------------------------------------------------------]] | ||
| 880 | |||
| 881 | -------------------------------------------------------------------- | ||
| 882 | -- initial parsing for a for loop, calls fornum() or forlist() | ||
| 883 | -- * used in stat() | ||
| 884 | -------------------------------------------------------------------- | ||
| 885 | function luaY:for_stat() | ||
| 886 | -- stat -> for_stat -> fornum | forlist | ||
| 887 | local line = line | ||
| 888 | self:log("for_stat: begin") | ||
| 889 | self:enterblock(false) -- block to control variable scope | ||
| 890 | self:next() -- skip 'for' | ||
| 891 | local varname = self:str_checkname() -- first variable name | ||
| 892 | local c = tok | ||
| 893 | if c == "=" then | ||
| 894 | self:log("for_stat: numerical loop") | ||
| 895 | self:fornum(varname, line) | ||
| 896 | elseif c == "," or c == "in" then | ||
| 897 | self:log("for_stat: list-based loop") | ||
| 898 | self:forlist(varname) | ||
| 899 | else | ||
| 900 | self:syntaxerror("'=' or 'in' expected") | ||
| 901 | end | ||
| 902 | self:check_match("end", "for", line) | ||
| 903 | self:leaveblock() | ||
| 904 | self:log("for_stat: end") | ||
| 905 | end | ||
| 906 | -------------------------------------------------------------------- | ||
| 907 | -- parse a while-do control structure, body processed by block() | ||
| 908 | -- * used in stat() | ||
| 909 | -------------------------------------------------------------------- | ||
| 910 | function luaY:while_stat() | ||
| 911 | -- stat -> while_stat -> WHILE cond DO block END | ||
| 912 | local line = line | ||
| 913 | local v = {} | ||
| 914 | self:next() -- skip WHILE | ||
| 915 | self:log("while_stat: begin/condition") | ||
| 916 | self:expr(v) -- parse condition | ||
| 917 | self:enterblock(true) | ||
| 918 | self:check("do") | ||
| 919 | self:log("while_stat: block") | ||
| 920 | self:block() | ||
| 921 | self:check_match("end", "while", line) | ||
| 922 | self:leaveblock() | ||
| 923 | self:log("while_stat: end") | ||
| 924 | end | ||
| 925 | -------------------------------------------------------------------- | ||
| 926 | -- parse a repeat-until control structure, body parsed by block() | ||
| 927 | -- * used in stat() | ||
| 928 | -------------------------------------------------------------------- | ||
| 929 | function luaY:repeat_stat() | ||
| 930 | -- stat -> repeat_stat -> REPEAT block UNTIL cond | ||
| 931 | local line = line | ||
| 932 | local v = {} | ||
| 933 | self:log("repeat_stat: begin") | ||
| 934 | self:enterblock(true) | ||
| 935 | self:next() | ||
| 936 | self:block() | ||
| 937 | self:check_match("until", "repeat", line) | ||
| 938 | self:log("repeat_stat: condition") | ||
| 939 | self:cond(v) | ||
| 940 | self:leaveblock() | ||
| 941 | self:log("repeat_stat: end") | ||
| 942 | end | ||
| 943 | -------------------------------------------------------------------- | ||
| 944 | -- parse an if control structure | ||
| 945 | -- * used in stat() | ||
| 946 | -------------------------------------------------------------------- | ||
| 947 | function luaY:if_stat() | ||
| 948 | -- stat -> if_stat -> IF cond THEN block | ||
| 949 | -- {ELSEIF cond THEN block} [ELSE block] END | ||
| 950 | local line = line | ||
| 951 | local v = {} | ||
| 952 | self:log("if_stat: if...then") | ||
| 953 | self:test_then_block(v) -- IF cond THEN block | ||
| 954 | while tok == "elseif" do | ||
| 955 | self:log("if_stat: elseif...then") | ||
| 956 | self:test_then_block(v) -- ELSEIF cond THEN block | ||
| 957 | end | ||
| 958 | if tok == "else" then | ||
| 959 | self:log("if_stat: else...") | ||
| 960 | self:next() -- skip ELSE | ||
| 961 | self:block() -- 'else' part | ||
| 962 | end | ||
| 963 | self:check_match("end", "if", line) | ||
| 964 | self:log("if_stat: end") | ||
| 965 | end | ||
| 966 | -------------------------------------------------------------------- | ||
| 967 | -- parse a return statement | ||
| 968 | -- * used in stat() | ||
| 969 | -------------------------------------------------------------------- | ||
| 970 | function luaY:return_stat() | ||
| 971 | -- stat -> return_stat -> RETURN explist | ||
| 972 | local e = {} | ||
| 973 | self:next() -- skip RETURN | ||
| 974 | local c = tok | ||
| 975 | if block_follow[c] or c == ";" then | ||
| 976 | -- return no values | ||
| 977 | self:log("return_stat: no return values") | ||
| 978 | else | ||
| 979 | self:log("return_stat: begin") | ||
| 980 | self:explist1(e) -- optional return values | ||
| 981 | self:log("return_stat: end") | ||
| 982 | end | ||
| 983 | end | ||
| 984 | -------------------------------------------------------------------- | ||
| 985 | -- parse a break statement | ||
| 986 | -- * used in stat() | ||
| 987 | -------------------------------------------------------------------- | ||
| 988 | function luaY:break_stat() | ||
| 989 | -- stat -> break_stat -> BREAK | ||
| 990 | local bl = fs.bl | ||
| 991 | self:next() -- skip BREAK | ||
| 992 | while bl and not bl.isbreakable do -- find a breakable block | ||
| 993 | bl = bl.prev | ||
| 994 | end | ||
| 995 | if not bl then | ||
| 996 | self:syntaxerror("no loop to break") | ||
| 997 | end | ||
| 998 | self:log("break_stat: -- break out of loop") | ||
| 999 | end | ||
| 1000 | -------------------------------------------------------------------- | ||
| 1001 | -- parse a function call with no returns or an assignment statement | ||
| 1002 | -- * the struct with .prev is used for name searching in lparse.c, | ||
| 1003 | -- so it is retained for now; present in assignment() also | ||
| 1004 | -- * used in stat() | ||
| 1005 | -------------------------------------------------------------------- | ||
| 1006 | function luaY:expr_stat() | ||
| 1007 | -- stat -> expr_stat -> func | assignment | ||
| 1008 | local v = {} | ||
| 1009 | v.v = {} | ||
| 1010 | self:primaryexp(v.v) | ||
| 1011 | if v.v.k == "VCALL" then -- stat -> func | ||
| 1012 | -- call statement uses no results | ||
| 1013 | self:log("expr_stat: function call k='"..v.v.k.."'") | ||
| 1014 | else -- stat -> assignment | ||
| 1015 | self:log("expr_stat: assignment k='"..v.v.k.."'") | ||
| 1016 | v.prev = nil | ||
| 1017 | self:assignment(v) | ||
| 1018 | end | ||
| 1019 | end | ||
| 1020 | -------------------------------------------------------------------- | ||
| 1021 | -- parse a function statement | ||
| 1022 | -- * used in stat() | ||
| 1023 | -------------------------------------------------------------------- | ||
| 1024 | function luaY:function_stat() | ||
| 1025 | -- stat -> function_stat -> FUNCTION funcname body | ||
| 1026 | local line = line | ||
| 1027 | local v, b = {}, {} | ||
| 1028 | self:log("function_stat: begin") | ||
| 1029 | self:next() -- skip FUNCTION | ||
| 1030 | local needself = self:funcname(v) | ||
| 1031 | self:log("function_stat: body needself='"..tostring(needself).."'") | ||
| 1032 | self:body(b, needself, line) | ||
| 1033 | self:log("function_stat: end") | ||
| 1034 | end | ||
| 1035 | -------------------------------------------------------------------- | ||
| 1036 | -- parse a simple block enclosed by a DO..END pair | ||
| 1037 | -- * used in stat() | ||
| 1038 | -------------------------------------------------------------------- | ||
| 1039 | function luaY:do_stat() | ||
| 1040 | -- stat -> do_stat -> DO block END | ||
| 1041 | self:next() -- skip DO | ||
| 1042 | self:log("do_stat: begin") | ||
| 1043 | self:block() | ||
| 1044 | self:log("do_stat: end") | ||
| 1045 | self:check_match("end", "do", line) | ||
| 1046 | end | ||
| 1047 | -------------------------------------------------------------------- | ||
| 1048 | -- parse a statement starting with LOCAL | ||
| 1049 | -- * used in stat() | ||
| 1050 | -------------------------------------------------------------------- | ||
| 1051 | function luaY:local_stat() | ||
| 1052 | -- stat -> local_stat -> LOCAL FUNCTION localfunc | ||
| 1053 | -- -> LOCAL localstat | ||
| 1054 | self:next() -- skip LOCAL | ||
| 1055 | if self:testnext("function") then -- local function? | ||
| 1056 | self:log("local_stat: local function") | ||
| 1057 | self:localfunc() | ||
| 1058 | else | ||
| 1059 | self:log("local_stat: local statement") | ||
| 1060 | self:localstat() | ||
| 1061 | end | ||
| 1062 | end | ||
| 1063 | |||
| 1064 | --[[-------------------------------------------------------------------- | ||
| 1065 | -- main function, top level parsing functions | ||
| 1066 | -- * [entry] -> parser() -> chunk() -> stat() | ||
| 1067 | ----------------------------------------------------------------------]] | ||
| 1068 | |||
| 1069 | -------------------------------------------------------------------- | ||
| 1070 | -- initial parsing for statements, calls '_stat' suffixed functions | ||
| 1071 | -- * used in chunk() | ||
| 1072 | -------------------------------------------------------------------- | ||
| 1073 | function luaY:stat() | ||
| 1074 | line = luaX.ln | ||
| 1075 | local c = tok | ||
| 1076 | local fn = stat_call[c] | ||
| 1077 | -- handles: if while do for repeat function local return break | ||
| 1078 | if fn then | ||
| 1079 | self:log("-- STATEMENT: begin '"..c.."' line="..line) | ||
| 1080 | self[fn](self) | ||
| 1081 | self:log("-- STATEMENT: end '"..c.."'") | ||
| 1082 | -- return or break must be last statement | ||
| 1083 | if c == "return" or c == "break" then return true end | ||
| 1084 | else | ||
| 1085 | self:log("-- STATEMENT: begin 'expr' line="..line) | ||
| 1086 | self:expr_stat() | ||
| 1087 | self:log("-- STATEMENT: end 'expr'") | ||
| 1088 | end | ||
| 1089 | self:log("") | ||
| 1090 | return false | ||
| 1091 | end | ||
| 1092 | -------------------------------------------------------------------- | ||
| 1093 | -- parse a chunk, which consists of a bunch of statements | ||
| 1094 | -- * used in parser(), body(), block() | ||
| 1095 | -------------------------------------------------------------------- | ||
| 1096 | function luaY:chunk() | ||
| 1097 | -- chunk -> { stat [';'] } | ||
| 1098 | self:log("chunk:") | ||
| 1099 | local islast = false | ||
| 1100 | while not islast and not block_follow[tok] do | ||
| 1101 | islast = self:stat() | ||
| 1102 | self:testnext(";") | ||
| 1103 | end | ||
| 1104 | end | ||
| 1105 | -------------------------------------------------------------------- | ||
| 1106 | -- performs parsing, returns parsed data structure | ||
| 1107 | -------------------------------------------------------------------- | ||
| 1108 | function luaY:parser() | ||
| 1109 | self:log("-- TOP: begin") | ||
| 1110 | self:open_func() | ||
| 1111 | self:log("") | ||
| 1112 | self:next() -- read first token | ||
| 1113 | self:chunk() | ||
| 1114 | self:check_condition(tok == "<eof>", "<eof> expected") | ||
| 1115 | self:close_func() | ||
| 1116 | self:log("-- TOP: end") | ||
| 1117 | return top_fs | ||
| 1118 | end | ||
| 1119 | -------------------------------------------------------------------- | ||
| 1120 | return luaY -- return actual module to user, done | ||
| 1121 | end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/lzio_mk2.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/lzio_mk2.lua deleted file mode 100644 index 6378366..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/lzio_mk2.lua +++ /dev/null | |||
| @@ -1,106 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | lzio.lua | ||
| 4 | Lua 5 buffered streams in Lua | ||
| 5 | This file is part of Yueliang. | ||
| 6 | |||
| 7 | Copyright (c) 2005-2006 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 | -- * | ||
| 18 | ----------------------------------------------------------------------]] | ||
| 19 | |||
| 20 | --[[-------------------------------------------------------------------- | ||
| 21 | -- local zio_init = require("lzio.lua") | ||
| 22 | -- local z = zio_init("@<filename>") | ||
| 23 | -- local z = zio_init("<string>") | ||
| 24 | -- z:getc() | ||
| 25 | -- * get next character from input stream | ||
| 26 | -- z:fill() | ||
| 27 | -- * fills an empty stream buffer | ||
| 28 | -- z.name | ||
| 29 | -- * name of the chunk, "@<filename>" or "=string" | ||
| 30 | ----------------------------------------------------------------------]] | ||
| 31 | |||
| 32 | --[[-------------------------------------------------------------------- | ||
| 33 | -- Format of z structure (ZIO) | ||
| 34 | -- z.n -- bytes still unread | ||
| 35 | -- z.p -- last read position in buffer | ||
| 36 | -- z.reader -- chunk reader function | ||
| 37 | -- z.data -- data buffer | ||
| 38 | -- z.name -- name of stream | ||
| 39 | ----------------------------------------------------------------------]] | ||
| 40 | |||
| 41 | return | ||
| 42 | function(buff) | ||
| 43 | --[[-------------------------------------------------------------------- | ||
| 44 | -- initialize reader | ||
| 45 | -- * reader should return a string, or nil if nothing else to parse | ||
| 46 | ----------------------------------------------------------------------]] | ||
| 47 | local reader | ||
| 48 | local z = {} | ||
| 49 | if string.sub(buff, 1, 1) == "@" then | ||
| 50 | ---------------------------------------------------------------- | ||
| 51 | -- create a chunk reader function from a source file | ||
| 52 | ---------------------------------------------------------------- | ||
| 53 | z.name = buff | ||
| 54 | local BUFFERSIZE = 512 | ||
| 55 | local h = io.open(string.sub(buff, 2), "r") | ||
| 56 | if not h then return nil end | ||
| 57 | reader = function() | ||
| 58 | if not h or io.type(h) == "closed file" then return nil end | ||
| 59 | local buff = h:read(BUFFERSIZE) | ||
| 60 | if not buff then h:close(); h = nil end | ||
| 61 | return buff | ||
| 62 | end | ||
| 63 | else | ||
| 64 | ---------------------------------------------------------------- | ||
| 65 | -- create a chunk reader function from a source string | ||
| 66 | ---------------------------------------------------------------- | ||
| 67 | z.name = "=string" | ||
| 68 | reader = function() | ||
| 69 | if not buff then return nil end | ||
| 70 | local data = buff | ||
| 71 | buff = nil | ||
| 72 | return data | ||
| 73 | end | ||
| 74 | end | ||
| 75 | --[[-------------------------------------------------------------------- | ||
| 76 | -- fills an empty stream buffer, returns first character | ||
| 77 | ----------------------------------------------------------------------]] | ||
| 78 | function z:fill() | ||
| 79 | local data = z.reader() | ||
| 80 | z.data = data | ||
| 81 | if not data or data == "" then return "EOZ" end | ||
| 82 | z.n, z.p = string.len(data) - 1, 1 | ||
| 83 | return string.sub(data, 1, 1) | ||
| 84 | end | ||
| 85 | --[[-------------------------------------------------------------------- | ||
| 86 | -- get next character, fills buffer if characters needed | ||
| 87 | ----------------------------------------------------------------------]] | ||
| 88 | function z:getc() | ||
| 89 | local n, p = z.n, z.p + 1 | ||
| 90 | if n > 0 then | ||
| 91 | z.n, z.p = n - 1, p | ||
| 92 | return string.sub(z.data, p, p) | ||
| 93 | else | ||
| 94 | return self:fill() | ||
| 95 | end | ||
| 96 | end | ||
| 97 | --[[-------------------------------------------------------------------- | ||
| 98 | -- initialize input stream object | ||
| 99 | ----------------------------------------------------------------------]] | ||
| 100 | if not reader then return end | ||
| 101 | z.reader = reader | ||
| 102 | z.data = "" | ||
| 103 | z.n, z.p = 0, 0 | ||
| 104 | return z | ||
| 105 | --[[------------------------------------------------------------------]] | ||
| 106 | end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/lzio_mk4.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/lzio_mk4.lua deleted file mode 100644 index d97c795..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/lzio_mk4.lua +++ /dev/null | |||
| @@ -1,82 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | lzio.lua | ||
| 4 | Lua 5 buffered streams in Lua | ||
| 5 | This file is part of Yueliang. | ||
| 6 | |||
| 7 | Copyright (c) 2006 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 line-based input streamer for the MK4 lexer | ||
| 18 | -- * all EOL (end-of-line) characters are translated to "\n" | ||
| 19 | -- * if last line in a file does not have an EOL character, this | ||
| 20 | -- streamer adds one, the ambiguity is due to "*l" stripping | ||
| 21 | -- * EOF uses an empty string to simplify testing in lexer | ||
| 22 | ----------------------------------------------------------------------]] | ||
| 23 | |||
| 24 | --[[-------------------------------------------------------------------- | ||
| 25 | -- local zio_init = require("lzio.lua") | ||
| 26 | -- local z = zio_init("@<filename>") | ||
| 27 | -- local z = zio_init("<string>") | ||
| 28 | -- z:getln() | ||
| 29 | -- * get next line from input stream | ||
| 30 | -- z.name | ||
| 31 | -- * name of the chunk, "@<filename>" or "=string" | ||
| 32 | ----------------------------------------------------------------------]] | ||
| 33 | |||
| 34 | --[[-------------------------------------------------------------------- | ||
| 35 | -- Format of z structure (ZIO) | ||
| 36 | -- z.getln -- chunk reader function, reads line-by-line | ||
| 37 | -- z.name -- name of stream | ||
| 38 | ----------------------------------------------------------------------]] | ||
| 39 | |||
| 40 | return | ||
| 41 | function(buff) | ||
| 42 | --[[-------------------------------------------------------------------- | ||
| 43 | -- initialize reader | ||
| 44 | -- * reader should return a string with an EOL character, or an empty | ||
| 45 | -- string if there is nothing else to parse | ||
| 46 | ----------------------------------------------------------------------]] | ||
| 47 | local reader | ||
| 48 | local z = {} | ||
| 49 | if string.sub(buff, 1, 1) == "@" then | ||
| 50 | ---------------------------------------------------------------- | ||
| 51 | -- create a chunk reader function from a source file | ||
| 52 | ---------------------------------------------------------------- | ||
| 53 | z.name = buff | ||
| 54 | local h = io.open(string.sub(buff, 2), "r") | ||
| 55 | if not h then return nil end | ||
| 56 | reader = function() | ||
| 57 | if not h or io.type(h) == "closed file" then return nil end | ||
| 58 | local data = h:read("*l") | ||
| 59 | if not data then h:close(); return "" end | ||
| 60 | return data.."\n" | ||
| 61 | end | ||
| 62 | else | ||
| 63 | ---------------------------------------------------------------- | ||
| 64 | -- create a chunk reader function from a source string | ||
| 65 | ---------------------------------------------------------------- | ||
| 66 | z.name = "=string" | ||
| 67 | reader = function() | ||
| 68 | if not buff then return nil end | ||
| 69 | local p, q, data, eol = string.find(buff, "([^\r\n]*)(\r?\n?)") | ||
| 70 | buff = string.sub(buff, q + 1) | ||
| 71 | if data == "" and eol == "" then return "" end | ||
| 72 | return data..eol | ||
| 73 | end | ||
| 74 | end | ||
| 75 | --[[-------------------------------------------------------------------- | ||
| 76 | -- initialize input stream object | ||
| 77 | ----------------------------------------------------------------------]] | ||
| 78 | if not reader then return end | ||
| 79 | z.getln = reader | ||
| 80 | return z | ||
| 81 | --[[------------------------------------------------------------------]] | ||
| 82 | end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/bench_llex_mk2.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/bench_llex_mk2.lua deleted file mode 100644 index 873afd1..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/bench_llex_mk2.lua +++ /dev/null | |||
| @@ -1,94 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | bench_llex.lua | ||
| 4 | Benchmark test for llex.lua | ||
| 5 | This file is part of Yueliang. | ||
| 6 | |||
| 7 | Copyright (c) 2006 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 | local zio_init = require("../lzio_mk2") | ||
| 16 | local lex_init = require("../llex_mk2") | ||
| 17 | |||
| 18 | ------------------------------------------------------------------------ | ||
| 19 | -- load in a standard set of sample files | ||
| 20 | -- * file set is 5.0.3 front end set sans luac.lua | ||
| 21 | ------------------------------------------------------------------------ | ||
| 22 | |||
| 23 | local fileset, totalsize = {}, 0 | ||
| 24 | for fn in string.gfind([[ | ||
| 25 | ../../orig-5.0.3/lcode.lua | ||
| 26 | ../../orig-5.0.3/ldump.lua | ||
| 27 | ../../orig-5.0.3/llex.lua | ||
| 28 | ../../orig-5.0.3/lopcodes.lua | ||
| 29 | ../../orig-5.0.3/lparser.lua | ||
| 30 | ../../orig-5.0.3/lzio.lua | ||
| 31 | ]], "%S+") do | ||
| 32 | table.insert(fileset, fn) | ||
| 33 | end | ||
| 34 | |||
| 35 | for i = 1, table.getn(fileset) do | ||
| 36 | local fn = fileset[i] | ||
| 37 | local inf = io.open(fn, "rb") | ||
| 38 | if not inf then | ||
| 39 | error("failed to open "..fn.." for reading") | ||
| 40 | end | ||
| 41 | local data = inf:read("*a") | ||
| 42 | local data_sz = string.len(data) | ||
| 43 | inf:close() | ||
| 44 | if not data or data_sz == 0 then | ||
| 45 | error("failed to read data from "..fn.." or file is zero-length") | ||
| 46 | end | ||
| 47 | totalsize = totalsize + data_sz | ||
| 48 | fileset[i] = data | ||
| 49 | end | ||
| 50 | |||
| 51 | ------------------------------------------------------------------------ | ||
| 52 | -- benchmark tester | ||
| 53 | ------------------------------------------------------------------------ | ||
| 54 | |||
| 55 | local DURATION = 5 -- how long the benchmark should run | ||
| 56 | |||
| 57 | local time = os.time | ||
| 58 | local lexedsize = 0 | ||
| 59 | local tnow, elapsed = time(), 0 | ||
| 60 | |||
| 61 | while time() == tnow do end -- wait for second to click over | ||
| 62 | tnow = time() | ||
| 63 | |||
| 64 | while true do | ||
| 65 | for i = 1, table.getn(fileset) do | ||
| 66 | ------------------------------------------------------------ | ||
| 67 | local chunk = fileset[i] | ||
| 68 | local z = zio_init(chunk) | ||
| 69 | local luaX = lex_init(z, "=string") | ||
| 70 | while true do | ||
| 71 | local tok, seminfo = luaX:lex() | ||
| 72 | if tok == "<eof>" then break end | ||
| 73 | end | ||
| 74 | ------------------------------------------------------------ | ||
| 75 | lexedsize = lexedsize + string.len(chunk) | ||
| 76 | if time() > tnow then | ||
| 77 | tnow = time() | ||
| 78 | elapsed = elapsed + 1 | ||
| 79 | if elapsed >= DURATION then | ||
| 80 | -- report performance of lexer | ||
| 81 | lexedsize = lexedsize / 1024 | ||
| 82 | local speed = lexedsize / DURATION | ||
| 83 | print("Lexer performance:") | ||
| 84 | print("Size of data lexed (KB): "..string.format("%.1f", lexedsize)) | ||
| 85 | print("Speed of lexer (KB/s): "..string.format("%.1f", speed)) | ||
| 86 | -- repeat until user breaks program | ||
| 87 | elapsed = 0 | ||
| 88 | end | ||
| 89 | end | ||
| 90 | ------------------------------------------------------------ | ||
| 91 | end--for | ||
| 92 | end--while | ||
| 93 | |||
| 94 | -- end of script | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/bench_llex_mk3.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/bench_llex_mk3.lua deleted file mode 100644 index 6b2a4a6..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/bench_llex_mk3.lua +++ /dev/null | |||
| @@ -1,92 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | bench_llex.lua | ||
| 4 | Benchmark test for llex.lua | ||
| 5 | This file is part of Yueliang. | ||
| 6 | |||
| 7 | Copyright (c) 2006 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 | local lex_init = require("../llex_mk3") | ||
| 16 | |||
| 17 | ------------------------------------------------------------------------ | ||
| 18 | -- load in a standard set of sample files | ||
| 19 | -- * file set is 5.0.3 front end set sans luac.lua | ||
| 20 | ------------------------------------------------------------------------ | ||
| 21 | |||
| 22 | local fileset, totalsize = {}, 0 | ||
| 23 | for fn in string.gfind([[ | ||
| 24 | ../../orig-5.0.3/lcode.lua | ||
| 25 | ../../orig-5.0.3/ldump.lua | ||
| 26 | ../../orig-5.0.3/llex.lua | ||
| 27 | ../../orig-5.0.3/lopcodes.lua | ||
| 28 | ../../orig-5.0.3/lparser.lua | ||
| 29 | ../../orig-5.0.3/lzio.lua | ||
| 30 | ]], "%S+") do | ||
| 31 | table.insert(fileset, fn) | ||
| 32 | end | ||
| 33 | |||
| 34 | for i = 1, table.getn(fileset) do | ||
| 35 | local fn = fileset[i] | ||
| 36 | local inf = io.open(fn, "rb") | ||
| 37 | if not inf then | ||
| 38 | error("failed to open "..fn.." for reading") | ||
| 39 | end | ||
| 40 | local data = inf:read("*a") | ||
| 41 | local data_sz = string.len(data) | ||
| 42 | inf:close() | ||
| 43 | if not data or data_sz == 0 then | ||
| 44 | error("failed to read data from "..fn.." or file is zero-length") | ||
| 45 | end | ||
| 46 | totalsize = totalsize + data_sz | ||
| 47 | fileset[i] = data | ||
| 48 | end | ||
| 49 | |||
| 50 | ------------------------------------------------------------------------ | ||
| 51 | -- benchmark tester | ||
| 52 | ------------------------------------------------------------------------ | ||
| 53 | |||
| 54 | local DURATION = 5 -- how long the benchmark should run | ||
| 55 | |||
| 56 | local time = os.time | ||
| 57 | local lexedsize = 0 | ||
| 58 | local tnow, elapsed = time(), 0 | ||
| 59 | |||
| 60 | while time() == tnow do end -- wait for second to click over | ||
| 61 | tnow = time() | ||
| 62 | |||
| 63 | while true do | ||
| 64 | for i = 1, table.getn(fileset) do | ||
| 65 | ------------------------------------------------------------ | ||
| 66 | local chunk = fileset[i] | ||
| 67 | local luaX = lex_init(chunk, "=string") | ||
| 68 | while true do | ||
| 69 | local tok, seminfo = luaX:lex() | ||
| 70 | if tok == "<eof>" then break end | ||
| 71 | end | ||
| 72 | ------------------------------------------------------------ | ||
| 73 | lexedsize = lexedsize + string.len(chunk) | ||
| 74 | if time() > tnow then | ||
| 75 | tnow = time() | ||
| 76 | elapsed = elapsed + 1 | ||
| 77 | if elapsed >= DURATION then | ||
| 78 | -- report performance of lexer | ||
| 79 | lexedsize = lexedsize / 1024 | ||
| 80 | local speed = lexedsize / DURATION | ||
| 81 | print("Lexer performance:") | ||
| 82 | print("Size of data lexed (KB): "..string.format("%.1f", lexedsize)) | ||
| 83 | print("Speed of lexer (KB/s): "..string.format("%.1f", speed)) | ||
| 84 | -- repeat until user breaks program | ||
| 85 | elapsed = 0 | ||
| 86 | end | ||
| 87 | end | ||
| 88 | ------------------------------------------------------------ | ||
| 89 | end--for | ||
| 90 | end--while | ||
| 91 | |||
| 92 | -- end of script | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/bench_llex_mk4.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/bench_llex_mk4.lua deleted file mode 100644 index b94386b..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/bench_llex_mk4.lua +++ /dev/null | |||
| @@ -1,94 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | bench_llex.lua | ||
| 4 | Benchmark test for llex.lua | ||
| 5 | This file is part of Yueliang. | ||
| 6 | |||
| 7 | Copyright (c) 2006 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 | local zio_init = require("../lzio_mk4") | ||
| 16 | local lex_init = require("../llex_mk4") | ||
| 17 | |||
| 18 | ------------------------------------------------------------------------ | ||
| 19 | -- load in a standard set of sample files | ||
| 20 | -- * file set is 5.0.3 front end set sans luac.lua | ||
| 21 | ------------------------------------------------------------------------ | ||
| 22 | |||
| 23 | local fileset, totalsize = {}, 0 | ||
| 24 | for fn in string.gfind([[ | ||
| 25 | ../../orig-5.0.3/lcode.lua | ||
| 26 | ../../orig-5.0.3/ldump.lua | ||
| 27 | ../../orig-5.0.3/llex.lua | ||
| 28 | ../../orig-5.0.3/lopcodes.lua | ||
| 29 | ../../orig-5.0.3/lparser.lua | ||
| 30 | ../../orig-5.0.3/lzio.lua | ||
| 31 | ]], "%S+") do | ||
| 32 | table.insert(fileset, fn) | ||
| 33 | end | ||
| 34 | |||
| 35 | for i = 1, table.getn(fileset) do | ||
| 36 | local fn = fileset[i] | ||
| 37 | local inf = io.open(fn, "rb") | ||
| 38 | if not inf then | ||
| 39 | error("failed to open "..fn.." for reading") | ||
| 40 | end | ||
| 41 | local data = inf:read("*a") | ||
| 42 | local data_sz = string.len(data) | ||
| 43 | inf:close() | ||
| 44 | if not data or data_sz == 0 then | ||
| 45 | error("failed to read data from "..fn.." or file is zero-length") | ||
| 46 | end | ||
| 47 | totalsize = totalsize + data_sz | ||
| 48 | fileset[i] = data | ||
| 49 | end | ||
| 50 | |||
| 51 | ------------------------------------------------------------------------ | ||
| 52 | -- benchmark tester | ||
| 53 | ------------------------------------------------------------------------ | ||
| 54 | |||
| 55 | local DURATION = 5 -- how long the benchmark should run | ||
| 56 | |||
| 57 | local time = os.time | ||
| 58 | local lexedsize = 0 | ||
| 59 | local tnow, elapsed = time(), 0 | ||
| 60 | |||
| 61 | while time() == tnow do end -- wait for second to click over | ||
| 62 | tnow = time() | ||
| 63 | |||
| 64 | while true do | ||
| 65 | for i = 1, table.getn(fileset) do | ||
| 66 | ------------------------------------------------------------ | ||
| 67 | local chunk = fileset[i] | ||
| 68 | local z = zio_init(chunk) | ||
| 69 | local luaX = lex_init(z, "=string") | ||
| 70 | while true do | ||
| 71 | local tok, seminfo = luaX:lex() | ||
| 72 | if tok == "<eof>" then break end | ||
| 73 | end | ||
| 74 | ------------------------------------------------------------ | ||
| 75 | lexedsize = lexedsize + string.len(chunk) | ||
| 76 | if time() > tnow then | ||
| 77 | tnow = time() | ||
| 78 | elapsed = elapsed + 1 | ||
| 79 | if elapsed >= DURATION then | ||
| 80 | -- report performance of lexer | ||
| 81 | lexedsize = lexedsize / 1024 | ||
| 82 | local speed = lexedsize / DURATION | ||
| 83 | print("Lexer performance:") | ||
| 84 | print("Size of data lexed (KB): "..string.format("%.1f", lexedsize)) | ||
| 85 | print("Speed of lexer (KB/s): "..string.format("%.1f", speed)) | ||
| 86 | -- repeat until user breaks program | ||
| 87 | elapsed = 0 | ||
| 88 | end | ||
| 89 | end | ||
| 90 | ------------------------------------------------------------ | ||
| 91 | end--for | ||
| 92 | end--while | ||
| 93 | |||
| 94 | -- end of script | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_01.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_01.lua deleted file mode 100644 index 379cc9d..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.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.0.3/test/parser_log/sample_02.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_02.lua deleted file mode 100644 index 13eb2e6..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.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.0.3/test/parser_log/sample_03.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_03.lua deleted file mode 100644 index 33df29c..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_03.lua +++ /dev/null | |||
| @@ -1,21 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | do | ||
| 3 | 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 | close_func | ||
| 21 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_04.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_04.lua deleted file mode 100644 index d0fefbc..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_04.lua +++ /dev/null | |||
| @@ -1,31 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | do end | ||
| 3 | do 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.0.3/test/parser_log/sample_05.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_05.lua deleted file mode 100644 index 8d6f962..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_05.lua +++ /dev/null | |||
| @@ -1,129 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | foo() | ||
| 3 | foo{} | ||
| 4 | foo"" | ||
| 5 | foo:bar() | ||
| 6 | foo=false | ||
| 7 | foo.bar=true | ||
| 8 | foo[true]=nil | ||
| 9 | foo,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: name='foo' | ||
| 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: name='foo' | ||
| 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: name='foo' | ||
| 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: name='foo' | ||
| 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: name='foo' | ||
| 66 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 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: name='foo' | ||
| 95 | primaryexp: [ exp1 ] | ||
| 96 | index: begin '[' | ||
| 97 | expr: | ||
| 98 | simpleexp: true | ||
| 99 | index: end ']' | ||
| 100 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 112 | expr_stat: assignment k='VLOCAL' | ||
| 113 | assignment: ',' -- next LHS element | ||
| 114 | prefixexp: <name> | ||
| 115 | str_checkname: 'bar' | ||
| 116 | singlevar: name='bar' | ||
| 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.0.3/test/parser_log/sample_06.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_06.lua deleted file mode 100644 index ca7776e..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_06.lua +++ /dev/null | |||
| @@ -1,132 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | foo=true | ||
| 3 | foo=false | ||
| 4 | foo=nil | ||
| 5 | foo=1.23e45 | ||
| 6 | foo=-1 | ||
| 7 | foo=(0) | ||
| 8 | foo=1+2 | ||
| 9 | foo=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: name='foo' | ||
| 20 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 32 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 44 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 56 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 68 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 81 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 96 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 111 | expr_stat: assignment k='VLOCAL' | ||
| 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.0.3/test/parser_log/sample_07.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_07.lua deleted file mode 100644 index 8c0a738..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_07.lua +++ /dev/null | |||
| @@ -1,147 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | if foo then foo=1 end | ||
| 3 | if foo then foo=1 else foo=0 end | ||
| 4 | if 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: name='foo' | ||
| 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: name='foo' | ||
| 28 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 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: name='foo' | ||
| 58 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 76 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 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: name='foo' | ||
| 106 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 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: name='foo' | ||
| 133 | expr_stat: assignment k='VLOCAL' | ||
| 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.0.3/test/parser_log/sample_08.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_08.lua deleted file mode 100644 index d086c98..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_08.lua +++ /dev/null | |||
| @@ -1,66 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | do return end | ||
| 3 | do return 123 end | ||
| 4 | do 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.0.3/test/parser_log/sample_09.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_09.lua deleted file mode 100644 index 2236388..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_09.lua +++ /dev/null | |||
| @@ -1,97 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | while true do foo=not foo end | ||
| 3 | while foo~=42 do foo=foo-1 end | ||
| 4 | while 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 | expr: | ||
| 14 | simpleexp: true | ||
| 15 | enterblock(isbreakable=true) | ||
| 16 | while_stat: block | ||
| 17 | block: begin | ||
| 18 | enterblock(isbreakable=false) | ||
| 19 | chunk: | ||
| 20 | -- STATEMENT: begin 'expr' line=1 | ||
| 21 | prefixexp: <name> | ||
| 22 | str_checkname: 'foo' | ||
| 23 | singlevar: name='foo' | ||
| 24 | expr_stat: assignment k='VLOCAL' | ||
| 25 | assignment: '=' -- RHS elements follows | ||
| 26 | explist1: begin | ||
| 27 | expr: | ||
| 28 | subexpr: uop='not' | ||
| 29 | prefixexp: <name> | ||
| 30 | str_checkname: 'foo' | ||
| 31 | singlevar: name='foo' | ||
| 32 | explist1: end | ||
| 33 | -- STATEMENT: end 'expr' | ||
| 34 | |||
| 35 | leaveblock | ||
| 36 | block: end | ||
| 37 | leaveblock | ||
| 38 | while_stat: end | ||
| 39 | -- STATEMENT: end 'while' | ||
| 40 | |||
| 41 | -- STATEMENT: begin 'while' line=2 | ||
| 42 | while_stat: begin/condition | ||
| 43 | expr: | ||
| 44 | prefixexp: <name> | ||
| 45 | str_checkname: 'foo' | ||
| 46 | singlevar: name='foo' | ||
| 47 | subexpr: binop='~=' | ||
| 48 | simpleexp: <number>=42 | ||
| 49 | subexpr: -- evaluate | ||
| 50 | enterblock(isbreakable=true) | ||
| 51 | while_stat: block | ||
| 52 | block: begin | ||
| 53 | enterblock(isbreakable=false) | ||
| 54 | chunk: | ||
| 55 | -- STATEMENT: begin 'expr' line=2 | ||
| 56 | prefixexp: <name> | ||
| 57 | str_checkname: 'foo' | ||
| 58 | singlevar: name='foo' | ||
| 59 | expr_stat: assignment k='VLOCAL' | ||
| 60 | assignment: '=' -- RHS elements follows | ||
| 61 | explist1: begin | ||
| 62 | expr: | ||
| 63 | prefixexp: <name> | ||
| 64 | str_checkname: 'foo' | ||
| 65 | singlevar: name='foo' | ||
| 66 | subexpr: binop='-' | ||
| 67 | simpleexp: <number>=1 | ||
| 68 | subexpr: -- evaluate | ||
| 69 | explist1: end | ||
| 70 | -- STATEMENT: end 'expr' | ||
| 71 | |||
| 72 | leaveblock | ||
| 73 | block: end | ||
| 74 | leaveblock | ||
| 75 | while_stat: end | ||
| 76 | -- STATEMENT: end 'while' | ||
| 77 | |||
| 78 | -- STATEMENT: begin 'while' line=3 | ||
| 79 | while_stat: begin/condition | ||
| 80 | expr: | ||
| 81 | simpleexp: true | ||
| 82 | enterblock(isbreakable=true) | ||
| 83 | while_stat: block | ||
| 84 | block: begin | ||
| 85 | enterblock(isbreakable=false) | ||
| 86 | chunk: | ||
| 87 | -- STATEMENT: begin 'break' line=3 | ||
| 88 | break_stat: -- break out of loop | ||
| 89 | -- STATEMENT: end 'break' | ||
| 90 | leaveblock | ||
| 91 | block: end | ||
| 92 | leaveblock | ||
| 93 | while_stat: end | ||
| 94 | -- STATEMENT: end 'while' | ||
| 95 | |||
| 96 | close_func | ||
| 97 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_10.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_10.lua deleted file mode 100644 index 72f7ae3..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_10.lua +++ /dev/null | |||
| @@ -1,106 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | repeat foo=foo.."bar" until false | ||
| 3 | repeat foo=foo/2 until foo<1 | ||
| 4 | repeat 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 | block: begin | ||
| 15 | enterblock(isbreakable=false) | ||
| 16 | chunk: | ||
| 17 | -- STATEMENT: begin 'expr' line=1 | ||
| 18 | prefixexp: <name> | ||
| 19 | str_checkname: 'foo' | ||
| 20 | singlevar: name='foo' | ||
| 21 | expr_stat: assignment k='VLOCAL' | ||
| 22 | assignment: '=' -- RHS elements follows | ||
| 23 | explist1: begin | ||
| 24 | expr: | ||
| 25 | prefixexp: <name> | ||
| 26 | str_checkname: 'foo' | ||
| 27 | singlevar: name='foo' | ||
| 28 | subexpr: binop='..' | ||
| 29 | simpleexp: <string>=bar | ||
| 30 | codestring: "bar" | ||
| 31 | subexpr: -- evaluate | ||
| 32 | explist1: end | ||
| 33 | -- STATEMENT: end 'expr' | ||
| 34 | |||
| 35 | leaveblock | ||
| 36 | block: end | ||
| 37 | repeat_stat: condition | ||
| 38 | cond: begin | ||
| 39 | expr: | ||
| 40 | simpleexp: false | ||
| 41 | cond: end | ||
| 42 | leaveblock | ||
| 43 | repeat_stat: end | ||
| 44 | -- STATEMENT: end 'repeat' | ||
| 45 | |||
| 46 | -- STATEMENT: begin 'repeat' line=2 | ||
| 47 | repeat_stat: begin | ||
| 48 | enterblock(isbreakable=true) | ||
| 49 | block: begin | ||
| 50 | enterblock(isbreakable=false) | ||
| 51 | chunk: | ||
| 52 | -- STATEMENT: begin 'expr' line=2 | ||
| 53 | prefixexp: <name> | ||
| 54 | str_checkname: 'foo' | ||
| 55 | singlevar: name='foo' | ||
| 56 | expr_stat: assignment k='VLOCAL' | ||
| 57 | assignment: '=' -- RHS elements follows | ||
| 58 | explist1: begin | ||
| 59 | expr: | ||
| 60 | prefixexp: <name> | ||
| 61 | str_checkname: 'foo' | ||
| 62 | singlevar: name='foo' | ||
| 63 | subexpr: binop='/' | ||
| 64 | simpleexp: <number>=2 | ||
| 65 | subexpr: -- evaluate | ||
| 66 | explist1: end | ||
| 67 | -- STATEMENT: end 'expr' | ||
| 68 | |||
| 69 | leaveblock | ||
| 70 | block: end | ||
| 71 | repeat_stat: condition | ||
| 72 | cond: begin | ||
| 73 | expr: | ||
| 74 | prefixexp: <name> | ||
| 75 | str_checkname: 'foo' | ||
| 76 | singlevar: name='foo' | ||
| 77 | subexpr: binop='<' | ||
| 78 | simpleexp: <number>=1 | ||
| 79 | subexpr: -- evaluate | ||
| 80 | cond: end | ||
| 81 | leaveblock | ||
| 82 | repeat_stat: end | ||
| 83 | -- STATEMENT: end 'repeat' | ||
| 84 | |||
| 85 | -- STATEMENT: begin 'repeat' line=3 | ||
| 86 | repeat_stat: begin | ||
| 87 | enterblock(isbreakable=true) | ||
| 88 | block: begin | ||
| 89 | enterblock(isbreakable=false) | ||
| 90 | chunk: | ||
| 91 | -- STATEMENT: begin 'break' line=3 | ||
| 92 | break_stat: -- break out of loop | ||
| 93 | -- STATEMENT: end 'break' | ||
| 94 | leaveblock | ||
| 95 | block: end | ||
| 96 | repeat_stat: condition | ||
| 97 | cond: begin | ||
| 98 | expr: | ||
| 99 | simpleexp: false | ||
| 100 | cond: end | ||
| 101 | leaveblock | ||
| 102 | repeat_stat: end | ||
| 103 | -- STATEMENT: end 'repeat' | ||
| 104 | |||
| 105 | close_func | ||
| 106 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_11.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_11.lua deleted file mode 100644 index 8af611b..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_11.lua +++ /dev/null | |||
| @@ -1,175 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | for i=1,10 do foo=i end | ||
| 3 | for i=1,10,2 do break end | ||
| 4 | for i in foo do bar=0 end | ||
| 5 | for 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=false) | ||
| 15 | str_checkname: 'i' | ||
| 16 | for_stat: numerical loop | ||
| 17 | fornum: begin | ||
| 18 | fornum: index start | ||
| 19 | exp1: begin | ||
| 20 | expr: | ||
| 21 | simpleexp: <number>=1 | ||
| 22 | exp1: end | ||
| 23 | fornum: index stop | ||
| 24 | exp1: begin | ||
| 25 | expr: | ||
| 26 | simpleexp: <number>=10 | ||
| 27 | exp1: end | ||
| 28 | fornum: body | ||
| 29 | enterblock(isbreakable=true) | ||
| 30 | block: begin | ||
| 31 | enterblock(isbreakable=false) | ||
| 32 | chunk: | ||
| 33 | -- STATEMENT: begin 'expr' line=1 | ||
| 34 | prefixexp: <name> | ||
| 35 | str_checkname: 'foo' | ||
| 36 | singlevar: name='foo' | ||
| 37 | expr_stat: assignment k='VLOCAL' | ||
| 38 | assignment: '=' -- RHS elements follows | ||
| 39 | explist1: begin | ||
| 40 | expr: | ||
| 41 | prefixexp: <name> | ||
| 42 | str_checkname: 'i' | ||
| 43 | singlevar: name='i' | ||
| 44 | explist1: end | ||
| 45 | -- STATEMENT: end 'expr' | ||
| 46 | |||
| 47 | leaveblock | ||
| 48 | block: end | ||
| 49 | leaveblock | ||
| 50 | fornum: end | ||
| 51 | leaveblock | ||
| 52 | for_stat: end | ||
| 53 | -- STATEMENT: end 'for' | ||
| 54 | |||
| 55 | -- STATEMENT: begin 'for' line=2 | ||
| 56 | for_stat: begin | ||
| 57 | enterblock(isbreakable=false) | ||
| 58 | str_checkname: 'i' | ||
| 59 | for_stat: numerical loop | ||
| 60 | fornum: begin | ||
| 61 | fornum: index start | ||
| 62 | exp1: begin | ||
| 63 | expr: | ||
| 64 | simpleexp: <number>=1 | ||
| 65 | exp1: end | ||
| 66 | fornum: index stop | ||
| 67 | exp1: begin | ||
| 68 | expr: | ||
| 69 | simpleexp: <number>=10 | ||
| 70 | exp1: end | ||
| 71 | fornum: index step | ||
| 72 | exp1: begin | ||
| 73 | expr: | ||
| 74 | simpleexp: <number>=2 | ||
| 75 | exp1: end | ||
| 76 | fornum: body | ||
| 77 | enterblock(isbreakable=true) | ||
| 78 | block: begin | ||
| 79 | enterblock(isbreakable=false) | ||
| 80 | chunk: | ||
| 81 | -- STATEMENT: begin 'break' line=2 | ||
| 82 | break_stat: -- break out of loop | ||
| 83 | -- STATEMENT: end 'break' | ||
| 84 | leaveblock | ||
| 85 | block: end | ||
| 86 | leaveblock | ||
| 87 | fornum: end | ||
| 88 | leaveblock | ||
| 89 | for_stat: end | ||
| 90 | -- STATEMENT: end 'for' | ||
| 91 | |||
| 92 | -- STATEMENT: begin 'for' line=3 | ||
| 93 | for_stat: begin | ||
| 94 | enterblock(isbreakable=false) | ||
| 95 | str_checkname: 'i' | ||
| 96 | for_stat: list-based loop | ||
| 97 | forlist: begin | ||
| 98 | forlist: explist1 | ||
| 99 | explist1: begin | ||
| 100 | expr: | ||
| 101 | prefixexp: <name> | ||
| 102 | str_checkname: 'foo' | ||
| 103 | singlevar: name='foo' | ||
| 104 | explist1: end | ||
| 105 | forlist: body | ||
| 106 | enterblock(isbreakable=true) | ||
| 107 | block: begin | ||
| 108 | enterblock(isbreakable=false) | ||
| 109 | chunk: | ||
| 110 | -- STATEMENT: begin 'expr' line=3 | ||
| 111 | prefixexp: <name> | ||
| 112 | str_checkname: 'bar' | ||
| 113 | singlevar: name='bar' | ||
| 114 | expr_stat: assignment k='VLOCAL' | ||
| 115 | assignment: '=' -- RHS elements follows | ||
| 116 | explist1: begin | ||
| 117 | expr: | ||
| 118 | simpleexp: <number>=0 | ||
| 119 | explist1: end | ||
| 120 | -- STATEMENT: end 'expr' | ||
| 121 | |||
| 122 | leaveblock | ||
| 123 | block: end | ||
| 124 | leaveblock | ||
| 125 | forlist: end | ||
| 126 | leaveblock | ||
| 127 | for_stat: end | ||
| 128 | -- STATEMENT: end 'for' | ||
| 129 | |||
| 130 | -- STATEMENT: begin 'for' line=4 | ||
| 131 | for_stat: begin | ||
| 132 | enterblock(isbreakable=false) | ||
| 133 | str_checkname: 'i' | ||
| 134 | for_stat: list-based loop | ||
| 135 | forlist: begin | ||
| 136 | str_checkname: 'j' | ||
| 137 | forlist: explist1 | ||
| 138 | explist1: begin | ||
| 139 | expr: | ||
| 140 | prefixexp: <name> | ||
| 141 | str_checkname: 'foo' | ||
| 142 | singlevar: name='foo' | ||
| 143 | explist1: ',' -- continuation | ||
| 144 | expr: | ||
| 145 | prefixexp: <name> | ||
| 146 | str_checkname: 'bar' | ||
| 147 | singlevar: name='bar' | ||
| 148 | explist1: end | ||
| 149 | forlist: body | ||
| 150 | enterblock(isbreakable=true) | ||
| 151 | block: begin | ||
| 152 | enterblock(isbreakable=false) | ||
| 153 | chunk: | ||
| 154 | -- STATEMENT: begin 'expr' line=4 | ||
| 155 | prefixexp: <name> | ||
| 156 | str_checkname: 'baz' | ||
| 157 | singlevar: name='baz' | ||
| 158 | expr_stat: assignment k='VLOCAL' | ||
| 159 | assignment: '=' -- RHS elements follows | ||
| 160 | explist1: begin | ||
| 161 | expr: | ||
| 162 | simpleexp: <number>=0 | ||
| 163 | explist1: end | ||
| 164 | -- STATEMENT: end 'expr' | ||
| 165 | |||
| 166 | leaveblock | ||
| 167 | block: end | ||
| 168 | leaveblock | ||
| 169 | forlist: end | ||
| 170 | leaveblock | ||
| 171 | for_stat: end | ||
| 172 | -- STATEMENT: end 'for' | ||
| 173 | |||
| 174 | close_func | ||
| 175 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_12.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_12.lua deleted file mode 100644 index 916fc7f..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_12.lua +++ /dev/null | |||
| @@ -1,46 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | local foo | ||
| 3 | local foo,bar,baz | ||
| 4 | local 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 | localstat: end | ||
| 16 | -- STATEMENT: end 'local' | ||
| 17 | |||
| 18 | -- STATEMENT: begin 'local' line=2 | ||
| 19 | local_stat: local statement | ||
| 20 | localstat: begin | ||
| 21 | str_checkname: 'foo' | ||
| 22 | str_checkname: 'bar' | ||
| 23 | str_checkname: 'baz' | ||
| 24 | localstat: end | ||
| 25 | -- STATEMENT: end 'local' | ||
| 26 | |||
| 27 | -- STATEMENT: begin 'local' line=3 | ||
| 28 | local_stat: local statement | ||
| 29 | localstat: begin | ||
| 30 | str_checkname: 'foo' | ||
| 31 | str_checkname: 'bar' | ||
| 32 | localstat: -- assignment | ||
| 33 | explist1: begin | ||
| 34 | expr: | ||
| 35 | simpleexp: <string>=foo | ||
| 36 | codestring: "foo" | ||
| 37 | explist1: ',' -- continuation | ||
| 38 | expr: | ||
| 39 | simpleexp: <string>=bar | ||
| 40 | codestring: "bar" | ||
| 41 | explist1: end | ||
| 42 | localstat: end | ||
| 43 | -- STATEMENT: end 'local' | ||
| 44 | |||
| 45 | close_func | ||
| 46 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_13.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_13.lua deleted file mode 100644 index 8ddd3ea..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_13.lua +++ /dev/null | |||
| @@ -1,99 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | local function foo() return end | ||
| 3 | local function foo(a) return end | ||
| 4 | local function foo(x,y,z) return end | ||
| 5 | local 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 | localfunc: body | ||
| 17 | open_func | ||
| 18 | body: begin | ||
| 19 | body: parlist | ||
| 20 | parlist: begin | ||
| 21 | parlist: end | ||
| 22 | body: chunk | ||
| 23 | chunk: | ||
| 24 | -- STATEMENT: begin 'return' line=1 | ||
| 25 | return_stat: no return values | ||
| 26 | -- STATEMENT: end 'return' | ||
| 27 | body: end | ||
| 28 | close_func | ||
| 29 | localfunc: end | ||
| 30 | -- STATEMENT: end 'local' | ||
| 31 | |||
| 32 | -- STATEMENT: begin 'local' line=2 | ||
| 33 | local_stat: local function | ||
| 34 | localfunc: begin | ||
| 35 | str_checkname: 'foo' | ||
| 36 | localfunc: body | ||
| 37 | open_func | ||
| 38 | body: begin | ||
| 39 | body: parlist | ||
| 40 | parlist: begin | ||
| 41 | str_checkname: 'a' | ||
| 42 | parlist: end | ||
| 43 | body: chunk | ||
| 44 | chunk: | ||
| 45 | -- STATEMENT: begin 'return' line=2 | ||
| 46 | return_stat: no return values | ||
| 47 | -- STATEMENT: end 'return' | ||
| 48 | body: end | ||
| 49 | close_func | ||
| 50 | localfunc: end | ||
| 51 | -- STATEMENT: end 'local' | ||
| 52 | |||
| 53 | -- STATEMENT: begin 'local' line=3 | ||
| 54 | local_stat: local function | ||
| 55 | localfunc: begin | ||
| 56 | str_checkname: 'foo' | ||
| 57 | localfunc: body | ||
| 58 | open_func | ||
| 59 | body: begin | ||
| 60 | body: parlist | ||
| 61 | parlist: begin | ||
| 62 | str_checkname: 'x' | ||
| 63 | str_checkname: 'y' | ||
| 64 | str_checkname: 'z' | ||
| 65 | parlist: end | ||
| 66 | body: chunk | ||
| 67 | chunk: | ||
| 68 | -- STATEMENT: begin 'return' line=3 | ||
| 69 | return_stat: no return values | ||
| 70 | -- STATEMENT: end 'return' | ||
| 71 | body: end | ||
| 72 | close_func | ||
| 73 | localfunc: end | ||
| 74 | -- STATEMENT: end 'local' | ||
| 75 | |||
| 76 | -- STATEMENT: begin 'local' line=4 | ||
| 77 | local_stat: local function | ||
| 78 | localfunc: begin | ||
| 79 | str_checkname: 'foo' | ||
| 80 | localfunc: body | ||
| 81 | open_func | ||
| 82 | body: begin | ||
| 83 | body: parlist | ||
| 84 | parlist: begin | ||
| 85 | str_checkname: 'x' | ||
| 86 | parlist: ... (dots) | ||
| 87 | parlist: end | ||
| 88 | body: chunk | ||
| 89 | chunk: | ||
| 90 | -- STATEMENT: begin 'return' line=4 | ||
| 91 | return_stat: no return values | ||
| 92 | -- STATEMENT: end 'return' | ||
| 93 | body: end | ||
| 94 | close_func | ||
| 95 | localfunc: end | ||
| 96 | -- STATEMENT: end 'local' | ||
| 97 | |||
| 98 | close_func | ||
| 99 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_14.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_14.lua deleted file mode 100644 index aa0069a..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_14.lua +++ /dev/null | |||
| @@ -1,107 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | function foo() return end | ||
| 3 | function foo(a) return end | ||
| 4 | function foo(x,y,z) return end | ||
| 5 | function 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: name='foo' | ||
| 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: name='foo' | ||
| 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 | parlist: end | ||
| 47 | body: chunk | ||
| 48 | chunk: | ||
| 49 | -- STATEMENT: begin 'return' line=2 | ||
| 50 | return_stat: no return values | ||
| 51 | -- STATEMENT: end 'return' | ||
| 52 | body: end | ||
| 53 | close_func | ||
| 54 | function_stat: end | ||
| 55 | -- STATEMENT: end 'function' | ||
| 56 | |||
| 57 | -- STATEMENT: begin 'function' line=3 | ||
| 58 | function_stat: begin | ||
| 59 | funcname: begin | ||
| 60 | str_checkname: 'foo' | ||
| 61 | singlevar: name='foo' | ||
| 62 | funcname: end | ||
| 63 | function_stat: body needself='false' | ||
| 64 | open_func | ||
| 65 | body: begin | ||
| 66 | body: parlist | ||
| 67 | parlist: begin | ||
| 68 | str_checkname: 'x' | ||
| 69 | str_checkname: 'y' | ||
| 70 | str_checkname: 'z' | ||
| 71 | parlist: end | ||
| 72 | body: chunk | ||
| 73 | chunk: | ||
| 74 | -- STATEMENT: begin 'return' line=3 | ||
| 75 | return_stat: no return values | ||
| 76 | -- STATEMENT: end 'return' | ||
| 77 | body: end | ||
| 78 | close_func | ||
| 79 | function_stat: end | ||
| 80 | -- STATEMENT: end 'function' | ||
| 81 | |||
| 82 | -- STATEMENT: begin 'function' line=4 | ||
| 83 | function_stat: begin | ||
| 84 | funcname: begin | ||
| 85 | str_checkname: 'foo' | ||
| 86 | singlevar: name='foo' | ||
| 87 | funcname: end | ||
| 88 | function_stat: body needself='false' | ||
| 89 | open_func | ||
| 90 | body: begin | ||
| 91 | body: parlist | ||
| 92 | parlist: begin | ||
| 93 | str_checkname: 'x' | ||
| 94 | parlist: ... (dots) | ||
| 95 | parlist: end | ||
| 96 | body: chunk | ||
| 97 | chunk: | ||
| 98 | -- STATEMENT: begin 'return' line=4 | ||
| 99 | return_stat: no return values | ||
| 100 | -- STATEMENT: end 'return' | ||
| 101 | body: end | ||
| 102 | close_func | ||
| 103 | function_stat: end | ||
| 104 | -- STATEMENT: end 'function' | ||
| 105 | |||
| 106 | close_func | ||
| 107 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_15.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_15.lua deleted file mode 100644 index 73cdac3..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_15.lua +++ /dev/null | |||
| @@ -1,135 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | function foo.bar(p) return end | ||
| 3 | function foo.bar.baz(p) return end | ||
| 4 | function foo:bar(p) return end | ||
| 5 | function 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: name='foo' | ||
| 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 | parlist: end | ||
| 30 | body: chunk | ||
| 31 | chunk: | ||
| 32 | -- STATEMENT: begin 'return' line=1 | ||
| 33 | return_stat: no return values | ||
| 34 | -- STATEMENT: end 'return' | ||
| 35 | body: end | ||
| 36 | close_func | ||
| 37 | function_stat: end | ||
| 38 | -- STATEMENT: end 'function' | ||
| 39 | |||
| 40 | -- STATEMENT: begin 'function' line=2 | ||
| 41 | function_stat: begin | ||
| 42 | funcname: begin | ||
| 43 | str_checkname: 'foo' | ||
| 44 | singlevar: name='foo' | ||
| 45 | funcname: -- '.' field | ||
| 46 | field: operator=. | ||
| 47 | checkname: | ||
| 48 | str_checkname: 'bar' | ||
| 49 | codestring: "bar" | ||
| 50 | funcname: -- '.' field | ||
| 51 | field: operator=. | ||
| 52 | checkname: | ||
| 53 | str_checkname: 'baz' | ||
| 54 | codestring: "baz" | ||
| 55 | funcname: end | ||
| 56 | function_stat: body needself='false' | ||
| 57 | open_func | ||
| 58 | body: begin | ||
| 59 | body: parlist | ||
| 60 | parlist: begin | ||
| 61 | str_checkname: 'p' | ||
| 62 | parlist: end | ||
| 63 | body: chunk | ||
| 64 | chunk: | ||
| 65 | -- STATEMENT: begin 'return' line=2 | ||
| 66 | return_stat: no return values | ||
| 67 | -- STATEMENT: end 'return' | ||
| 68 | body: end | ||
| 69 | close_func | ||
| 70 | function_stat: end | ||
| 71 | -- STATEMENT: end 'function' | ||
| 72 | |||
| 73 | -- STATEMENT: begin 'function' line=3 | ||
| 74 | function_stat: begin | ||
| 75 | funcname: begin | ||
| 76 | str_checkname: 'foo' | ||
| 77 | singlevar: name='foo' | ||
| 78 | funcname: -- ':' field | ||
| 79 | field: operator=: | ||
| 80 | checkname: | ||
| 81 | str_checkname: 'bar' | ||
| 82 | codestring: "bar" | ||
| 83 | funcname: end | ||
| 84 | function_stat: body needself='true' | ||
| 85 | open_func | ||
| 86 | body: begin | ||
| 87 | body: parlist | ||
| 88 | parlist: begin | ||
| 89 | str_checkname: 'p' | ||
| 90 | parlist: end | ||
| 91 | body: chunk | ||
| 92 | chunk: | ||
| 93 | -- STATEMENT: begin 'return' line=3 | ||
| 94 | return_stat: no return values | ||
| 95 | -- STATEMENT: end 'return' | ||
| 96 | body: end | ||
| 97 | close_func | ||
| 98 | function_stat: end | ||
| 99 | -- STATEMENT: end 'function' | ||
| 100 | |||
| 101 | -- STATEMENT: begin 'function' line=4 | ||
| 102 | function_stat: begin | ||
| 103 | funcname: begin | ||
| 104 | str_checkname: 'foo' | ||
| 105 | singlevar: name='foo' | ||
| 106 | funcname: -- '.' field | ||
| 107 | field: operator=. | ||
| 108 | checkname: | ||
| 109 | str_checkname: 'bar' | ||
| 110 | codestring: "bar" | ||
| 111 | funcname: -- '.' field | ||
| 112 | field: operator=. | ||
| 113 | checkname: | ||
| 114 | str_checkname: 'baz' | ||
| 115 | codestring: "baz" | ||
| 116 | funcname: end | ||
| 117 | function_stat: body needself='false' | ||
| 118 | open_func | ||
| 119 | body: begin | ||
| 120 | body: parlist | ||
| 121 | parlist: begin | ||
| 122 | str_checkname: 'p' | ||
| 123 | parlist: end | ||
| 124 | body: chunk | ||
| 125 | chunk: | ||
| 126 | -- STATEMENT: begin 'return' line=4 | ||
| 127 | return_stat: no return values | ||
| 128 | -- STATEMENT: end 'return' | ||
| 129 | body: end | ||
| 130 | close_func | ||
| 131 | function_stat: end | ||
| 132 | -- STATEMENT: end 'function' | ||
| 133 | |||
| 134 | close_func | ||
| 135 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_16.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_16.lua deleted file mode 100644 index b53b2fb..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_16.lua +++ /dev/null | |||
| @@ -1,87 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | foo = function() return end | ||
| 3 | foo = function(x,y) return end | ||
| 4 | foo = function(...) return end | ||
| 5 | -- END OF SOURCE -- | ||
| 6 | |||
| 7 | -- TOP: begin | ||
| 8 | open_func | ||
| 9 | |||
| 10 | chunk: | ||
| 11 | -- STATEMENT: begin 'expr' line=1 | ||
| 12 | prefixexp: <name> | ||
| 13 | str_checkname: 'foo' | ||
| 14 | singlevar: name='foo' | ||
| 15 | expr_stat: assignment k='VLOCAL' | ||
| 16 | assignment: '=' -- RHS elements follows | ||
| 17 | explist1: begin | ||
| 18 | expr: | ||
| 19 | simpleexp: function | ||
| 20 | open_func | ||
| 21 | body: begin | ||
| 22 | body: parlist | ||
| 23 | parlist: begin | ||
| 24 | parlist: end | ||
| 25 | body: chunk | ||
| 26 | chunk: | ||
| 27 | -- STATEMENT: begin 'return' line=1 | ||
| 28 | return_stat: no return values | ||
| 29 | -- STATEMENT: end 'return' | ||
| 30 | body: end | ||
| 31 | close_func | ||
| 32 | explist1: end | ||
| 33 | -- STATEMENT: end 'expr' | ||
| 34 | |||
| 35 | -- STATEMENT: begin 'expr' line=2 | ||
| 36 | prefixexp: <name> | ||
| 37 | str_checkname: 'foo' | ||
| 38 | singlevar: name='foo' | ||
| 39 | expr_stat: assignment k='VLOCAL' | ||
| 40 | assignment: '=' -- RHS elements follows | ||
| 41 | explist1: begin | ||
| 42 | expr: | ||
| 43 | simpleexp: function | ||
| 44 | open_func | ||
| 45 | body: begin | ||
| 46 | body: parlist | ||
| 47 | parlist: begin | ||
| 48 | str_checkname: 'x' | ||
| 49 | str_checkname: 'y' | ||
| 50 | parlist: end | ||
| 51 | body: chunk | ||
| 52 | chunk: | ||
| 53 | -- STATEMENT: begin 'return' line=2 | ||
| 54 | return_stat: no return values | ||
| 55 | -- STATEMENT: end 'return' | ||
| 56 | body: end | ||
| 57 | close_func | ||
| 58 | explist1: end | ||
| 59 | -- STATEMENT: end 'expr' | ||
| 60 | |||
| 61 | -- STATEMENT: begin 'expr' line=3 | ||
| 62 | prefixexp: <name> | ||
| 63 | str_checkname: 'foo' | ||
| 64 | singlevar: name='foo' | ||
| 65 | expr_stat: assignment k='VLOCAL' | ||
| 66 | assignment: '=' -- RHS elements follows | ||
| 67 | explist1: begin | ||
| 68 | expr: | ||
| 69 | simpleexp: function | ||
| 70 | open_func | ||
| 71 | body: begin | ||
| 72 | body: parlist | ||
| 73 | parlist: begin | ||
| 74 | parlist: ... (dots) | ||
| 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 | explist1: end | ||
| 84 | -- STATEMENT: end 'expr' | ||
| 85 | |||
| 86 | close_func | ||
| 87 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_17.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_17.lua deleted file mode 100644 index 87634d3..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_17.lua +++ /dev/null | |||
| @@ -1,110 +0,0 @@ | |||
| 1 | -- START OF SOURCE -- | ||
| 2 | foo = {} | ||
| 3 | foo = { 1,2,3; "foo"; } | ||
| 4 | foo = { bar=77, baz=88, } | ||
| 5 | foo = { ["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: name='foo' | ||
| 16 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 30 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 57 | expr_stat: assignment k='VLOCAL' | ||
| 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: name='foo' | ||
| 83 | expr_stat: assignment k='VLOCAL' | ||
| 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.0.3/test/parser_log/sample_b_01.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_01.lua deleted file mode 100644 index 732b4d6..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_01.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.0.3/test/parser_log/sample_b_02.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_02.lua deleted file mode 100644 index 9863b4a..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_02.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.0.3/test/parser_log/sample_b_03.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_03.lua deleted file mode 100644 index bc37280..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_03.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.0.3/test/parser_log/sample_b_04.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_04.lua deleted file mode 100644 index b2bac4b..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_04.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.0.3/test/parser_log/sample_b_05.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_05.lua deleted file mode 100644 index 6885f01..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_05.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.0.3/test/parser_log/sample_b_06.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_06.lua deleted file mode 100644 index eb658ed..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_06.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.0.3/test/parser_log/sample_b_07.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_07.lua deleted file mode 100644 index 6403234..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_07.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.0.3/test/parser_log/sample_b_08.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_08.lua deleted file mode 100644 index 594e267..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_08.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.0.3/test/parser_log/sample_b_09.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_09.lua deleted file mode 100644 index bfa3920..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_09.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.0.3/test/parser_log/sample_b_10.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_10.lua deleted file mode 100644 index 9a38883..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_10.lua +++ /dev/null | |||
| @@ -1,49 +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 | new_localvar: 'arg' | ||
| 24 | parlist: end | ||
| 25 | body: chunk | ||
| 26 | chunk: | ||
| 27 | -- STATEMENT: begin 'expr' line=2 | ||
| 28 | prefixexp: <name> | ||
| 29 | str_checkname: 'print' | ||
| 30 | singlevar(kind): 'VGLOBAL' | ||
| 31 | primaryexp: ( funcargs | ||
| 32 | funcargs: begin '(' | ||
| 33 | explist1: begin | ||
| 34 | expr: | ||
| 35 | prefixexp: <name> | ||
| 36 | str_checkname: 'arg' | ||
| 37 | singlevar(kind): 'VLOCAL' | ||
| 38 | explist1: end | ||
| 39 | funcargs: end -- expr is a VCALL | ||
| 40 | expr_stat: function call k='VCALL' | ||
| 41 | -- STATEMENT: end 'expr' | ||
| 42 | |||
| 43 | body: end | ||
| 44 | close_func | ||
| 45 | function_stat: end | ||
| 46 | -- STATEMENT: end 'function' | ||
| 47 | |||
| 48 | close_func | ||
| 49 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_11.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_11.lua deleted file mode 100644 index e4c9e21..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_11.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.0.3/test/parser_log/sample_b_12.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_12.lua deleted file mode 100644 index b278ba2..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_12.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.0.3/test/parser_log/sample_b_13.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_13.lua deleted file mode 100644 index 6e4850c..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_13.lua +++ /dev/null | |||
| @@ -1,117 +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=false) | ||
| 17 | str_checkname: 'i' | ||
| 18 | for_stat: numerical loop | ||
| 19 | new_localvar: 'i' | ||
| 20 | new_localvar: '(for limit)' | ||
| 21 | new_localvar: '(for step)' | ||
| 22 | fornum: begin | ||
| 23 | fornum: index start | ||
| 24 | exp1: begin | ||
| 25 | expr: | ||
| 26 | simpleexp: <number>=1 | ||
| 27 | exp1: end | ||
| 28 | fornum: index stop | ||
| 29 | exp1: begin | ||
| 30 | expr: | ||
| 31 | simpleexp: <number>=10 | ||
| 32 | exp1: end | ||
| 33 | fornum: body | ||
| 34 | enterblock(isbreakable=true) | ||
| 35 | block: begin | ||
| 36 | enterblock(isbreakable=false) | ||
| 37 | chunk: | ||
| 38 | -- STATEMENT: begin 'expr' line=2 | ||
| 39 | prefixexp: <name> | ||
| 40 | str_checkname: 'print' | ||
| 41 | singlevar(kind): 'VGLOBAL' | ||
| 42 | primaryexp: ( funcargs | ||
| 43 | funcargs: begin '(' | ||
| 44 | explist1: begin | ||
| 45 | expr: | ||
| 46 | prefixexp: <name> | ||
| 47 | str_checkname: 'i' | ||
| 48 | singlevar(kind): 'VLOCAL' | ||
| 49 | explist1: end | ||
| 50 | funcargs: end -- expr is a VCALL | ||
| 51 | expr_stat: function call k='VCALL' | ||
| 52 | -- STATEMENT: end 'expr' | ||
| 53 | |||
| 54 | leaveblock | ||
| 55 | block: end | ||
| 56 | leaveblock | ||
| 57 | fornum: end | ||
| 58 | leaveblock | ||
| 59 | for_stat: end | ||
| 60 | -- STATEMENT: end 'for' | ||
| 61 | |||
| 62 | -- STATEMENT: begin 'for' line=4 | ||
| 63 | for_stat: begin | ||
| 64 | enterblock(isbreakable=false) | ||
| 65 | str_checkname: 'i' | ||
| 66 | for_stat: numerical loop | ||
| 67 | new_localvar: 'i' | ||
| 68 | new_localvar: '(for limit)' | ||
| 69 | new_localvar: '(for step)' | ||
| 70 | fornum: begin | ||
| 71 | fornum: index start | ||
| 72 | exp1: begin | ||
| 73 | expr: | ||
| 74 | simpleexp: <number>=1 | ||
| 75 | exp1: end | ||
| 76 | fornum: index stop | ||
| 77 | exp1: begin | ||
| 78 | expr: | ||
| 79 | simpleexp: <number>=10 | ||
| 80 | exp1: end | ||
| 81 | fornum: index step | ||
| 82 | exp1: begin | ||
| 83 | expr: | ||
| 84 | subexpr: uop='-' | ||
| 85 | simpleexp: <number>=2 | ||
| 86 | exp1: end | ||
| 87 | fornum: body | ||
| 88 | enterblock(isbreakable=true) | ||
| 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: 'i' | ||
| 102 | singlevar(kind): 'VLOCAL' | ||
| 103 | explist1: end | ||
| 104 | funcargs: end -- expr is a VCALL | ||
| 105 | expr_stat: function call k='VCALL' | ||
| 106 | -- STATEMENT: end 'expr' | ||
| 107 | |||
| 108 | leaveblock | ||
| 109 | block: end | ||
| 110 | leaveblock | ||
| 111 | fornum: end | ||
| 112 | leaveblock | ||
| 113 | for_stat: end | ||
| 114 | -- STATEMENT: end 'for' | ||
| 115 | |||
| 116 | close_func | ||
| 117 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_14.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_14.lua deleted file mode 100644 index f80c33f..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/parser_log/sample_b_14.lua +++ /dev/null | |||
| @@ -1,125 +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=false) | ||
| 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: 'foo' | ||
| 23 | forlist: explist1 | ||
| 24 | explist1: begin | ||
| 25 | expr: | ||
| 26 | prefixexp: <name> | ||
| 27 | str_checkname: 'bar' | ||
| 28 | singlevar(kind): 'VGLOBAL' | ||
| 29 | primaryexp: ( funcargs | ||
| 30 | funcargs: begin '(' | ||
| 31 | funcargs: end -- expr is a VCALL | ||
| 32 | explist1: end | ||
| 33 | forlist: body | ||
| 34 | enterblock(isbreakable=true) | ||
| 35 | block: begin | ||
| 36 | enterblock(isbreakable=false) | ||
| 37 | chunk: | ||
| 38 | -- STATEMENT: begin 'expr' line=2 | ||
| 39 | prefixexp: <name> | ||
| 40 | str_checkname: 'print' | ||
| 41 | singlevar(kind): 'VGLOBAL' | ||
| 42 | primaryexp: ( funcargs | ||
| 43 | funcargs: begin '(' | ||
| 44 | explist1: begin | ||
| 45 | expr: | ||
| 46 | prefixexp: <name> | ||
| 47 | str_checkname: 'foo' | ||
| 48 | singlevar(kind): 'VLOCAL' | ||
| 49 | explist1: end | ||
| 50 | funcargs: end -- expr is a VCALL | ||
| 51 | expr_stat: function call k='VCALL' | ||
| 52 | -- STATEMENT: end 'expr' | ||
| 53 | |||
| 54 | leaveblock | ||
| 55 | block: end | ||
| 56 | leaveblock | ||
| 57 | forlist: end | ||
| 58 | leaveblock | ||
| 59 | for_stat: end | ||
| 60 | -- STATEMENT: end 'for' | ||
| 61 | |||
| 62 | -- STATEMENT: begin 'for' line=4 | ||
| 63 | for_stat: begin | ||
| 64 | enterblock(isbreakable=false) | ||
| 65 | str_checkname: 'foo' | ||
| 66 | for_stat: list-based loop | ||
| 67 | forlist: begin | ||
| 68 | new_localvar: '(for generator)' | ||
| 69 | new_localvar: '(for state)' | ||
| 70 | new_localvar: 'foo' | ||
| 71 | str_checkname: 'bar' | ||
| 72 | new_localvar: 'bar' | ||
| 73 | str_checkname: 'baz' | ||
| 74 | new_localvar: 'baz' | ||
| 75 | forlist: explist1 | ||
| 76 | explist1: begin | ||
| 77 | expr: | ||
| 78 | prefixexp: <name> | ||
| 79 | str_checkname: 'spring' | ||
| 80 | singlevar(kind): 'VGLOBAL' | ||
| 81 | primaryexp: ( funcargs | ||
| 82 | funcargs: begin '(' | ||
| 83 | funcargs: end -- expr is a VCALL | ||
| 84 | explist1: end | ||
| 85 | forlist: body | ||
| 86 | enterblock(isbreakable=true) | ||
| 87 | block: begin | ||
| 88 | enterblock(isbreakable=false) | ||
| 89 | chunk: | ||
| 90 | -- STATEMENT: begin 'expr' line=5 | ||
| 91 | prefixexp: <name> | ||
| 92 | str_checkname: 'print' | ||
| 93 | singlevar(kind): 'VGLOBAL' | ||
| 94 | primaryexp: ( funcargs | ||
| 95 | funcargs: begin '(' | ||
| 96 | explist1: begin | ||
| 97 | expr: | ||
| 98 | prefixexp: <name> | ||
| 99 | str_checkname: 'foo' | ||
| 100 | singlevar(kind): 'VLOCAL' | ||
| 101 | explist1: ',' -- continuation | ||
| 102 | expr: | ||
| 103 | prefixexp: <name> | ||
| 104 | str_checkname: 'bar' | ||
| 105 | singlevar(kind): 'VLOCAL' | ||
| 106 | explist1: ',' -- continuation | ||
| 107 | expr: | ||
| 108 | prefixexp: <name> | ||
| 109 | str_checkname: 'baz' | ||
| 110 | singlevar(kind): 'VLOCAL' | ||
| 111 | explist1: end | ||
| 112 | funcargs: end -- expr is a VCALL | ||
| 113 | expr_stat: function call k='VCALL' | ||
| 114 | -- STATEMENT: end 'expr' | ||
| 115 | |||
| 116 | leaveblock | ||
| 117 | block: end | ||
| 118 | leaveblock | ||
| 119 | forlist: end | ||
| 120 | leaveblock | ||
| 121 | for_stat: end | ||
| 122 | -- STATEMENT: end 'for' | ||
| 123 | |||
| 124 | close_func | ||
| 125 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/sample.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/sample.lua deleted file mode 100644 index dc6eaee..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/sample.lua +++ /dev/null | |||
| @@ -1,3 +0,0 @@ | |||
| 1 | local a = 47 | ||
| 2 | local b = "hello, world!" | ||
| 3 | print(a, b) | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_llex_mk2.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_llex_mk2.lua deleted file mode 100644 index ff8cec5..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_llex_mk2.lua +++ /dev/null | |||
| @@ -1,499 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | test_llex.lua | ||
| 4 | Test for llex.lua | ||
| 5 | This file is part of Yueliang. | ||
| 6 | |||
| 7 | Copyright (c) 2005-2006 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 | ------------------------------------------------------------------------ | ||
| 18 | BRIEF = true -- if set to true, messages are less verbose | ||
| 19 | |||
| 20 | local zio_init = require("../lzio_mk2") | ||
| 21 | local lex_init = require("../llex_mk2") | ||
| 22 | |||
| 23 | ------------------------------------------------------------------------ | ||
| 24 | -- simple manual tests | ||
| 25 | ------------------------------------------------------------------------ | ||
| 26 | |||
| 27 | --[[ | ||
| 28 | local function dump(z, source) | ||
| 29 | local luaX = lex_init(z, source) | ||
| 30 | while true do | ||
| 31 | local tok, seminfo = luaX:lex() | ||
| 32 | if tok == "<name>" then | ||
| 33 | seminfo = " "..seminfo | ||
| 34 | elseif tok == "<number>" then | ||
| 35 | seminfo = " "..seminfo | ||
| 36 | elseif tok == "<string>" then | ||
| 37 | seminfo = " '"..seminfo.."'" | ||
| 38 | else | ||
| 39 | seminfo = "" | ||
| 40 | end | ||
| 41 | io.stdout:write(tok..seminfo.."\n") | ||
| 42 | if tok == "<eof>" then break end | ||
| 43 | end | ||
| 44 | end | ||
| 45 | |||
| 46 | local function try_string(chunk) | ||
| 47 | dump(zio_init(chunk), "=string") | ||
| 48 | end | ||
| 49 | local function try_file(filename) | ||
| 50 | local f = "@"..filename | ||
| 51 | dump(zio_init(f), f) | ||
| 52 | end | ||
| 53 | |||
| 54 | z = try_string("local c = z:getc()") | ||
| 55 | z = try_file("test_lzio_mk2.lua") | ||
| 56 | z = try_file("test_llex_mk2.lua") | ||
| 57 | os.exit() | ||
| 58 | --]] | ||
| 59 | |||
| 60 | ------------------------------------------------------------------------ | ||
| 61 | -- auto-testing of simple test cases to validate lexer behaviour: | ||
| 62 | -- * NOTE coverage has not been checked; not comprehensive | ||
| 63 | -- * only test cases with non-empty comments are processed | ||
| 64 | -- * if no result, then the output is displayed for manual decision | ||
| 65 | -- (output may be used to set expected success or fail text) | ||
| 66 | -- * cases expected to be successful may be a partial match | ||
| 67 | -- * cases expected to fail may also be a partial match | ||
| 68 | ------------------------------------------------------------------------ | ||
| 69 | |||
| 70 | -- [[ | ||
| 71 | local function auto_test() | ||
| 72 | local PASS, FAIL = true, false | ||
| 73 | ------------------------------------------------------------------ | ||
| 74 | -- table of test cases | ||
| 75 | ------------------------------------------------------------------ | ||
| 76 | local test_cases = | ||
| 77 | { | ||
| 78 | ------------------------------------------------------------- | ||
| 79 | --{ "comment", -- comment about the test | ||
| 80 | -- "chunk", -- chunk to test | ||
| 81 | -- PASS, -- PASS or FAIL outcome | ||
| 82 | -- "output", -- output to compare against | ||
| 83 | --}, | ||
| 84 | ------------------------------------------------------------- | ||
| 85 | { "empty chunk string, test EOS", | ||
| 86 | "", | ||
| 87 | PASS, "1 <eof>", | ||
| 88 | }, | ||
| 89 | ------------------------------------------------------------- | ||
| 90 | { "line number counting", | ||
| 91 | "\n\n\r\n", | ||
| 92 | PASS, "4 <eof>", | ||
| 93 | }, | ||
| 94 | ------------------------------------------------------------- | ||
| 95 | { "various whitespaces", | ||
| 96 | " \n\t\t\n \t \t \n\n", | ||
| 97 | PASS, "5 <eof>", | ||
| 98 | }, | ||
| 99 | ------------------------------------------------------------- | ||
| 100 | { "short comment ending in EOS", | ||
| 101 | "-- moo moo", | ||
| 102 | PASS, "1 <eof>", | ||
| 103 | }, | ||
| 104 | ------------------------------------------------------------- | ||
| 105 | { "short comment ending in newline", | ||
| 106 | "-- moo moo\n", | ||
| 107 | PASS, "2 <eof>", | ||
| 108 | }, | ||
| 109 | ------------------------------------------------------------- | ||
| 110 | { "several lines of short comments", | ||
| 111 | "--moo\n-- moo moo\n\n--\tmoo\n", | ||
| 112 | PASS, "5 <eof>", | ||
| 113 | }, | ||
| 114 | ------------------------------------------------------------- | ||
| 115 | { "basic block comment", | ||
| 116 | "--[[bovine]]", | ||
| 117 | PASS, "1 <eof>", | ||
| 118 | }, | ||
| 119 | ------------------------------------------------------------- | ||
| 120 | { "unterminated block comment 1", | ||
| 121 | "--[[bovine", | ||
| 122 | FAIL, ":1: unfinished long comment near '<eof>'", | ||
| 123 | }, | ||
| 124 | ------------------------------------------------------------- | ||
| 125 | { "unterminated block comment 2", | ||
| 126 | "--[[bovine]", | ||
| 127 | FAIL, ":1: unfinished long comment near '<eof>'", | ||
| 128 | }, | ||
| 129 | ------------------------------------------------------------- | ||
| 130 | { "unterminated block comment 3", | ||
| 131 | "--[[bovine\nmoo moo\nwoof", | ||
| 132 | FAIL, ":3: unfinished long comment near '<eof>'", | ||
| 133 | }, | ||
| 134 | ------------------------------------------------------------- | ||
| 135 | { "basic long string", | ||
| 136 | "\n[[bovine]]\n", | ||
| 137 | PASS, "2 <string> = bovine\n3 <eof>", | ||
| 138 | }, | ||
| 139 | ------------------------------------------------------------- | ||
| 140 | { "first newline consumed in long string", | ||
| 141 | "[[\nmoo]]", | ||
| 142 | PASS, "2 <string> = moo\n2 <eof>", | ||
| 143 | }, | ||
| 144 | ------------------------------------------------------------- | ||
| 145 | { "multiline long string", | ||
| 146 | "[[moo\nmoo moo\n]]", | ||
| 147 | PASS, "3 <string> = moo\nmoo moo\n\n3 <eof>", | ||
| 148 | }, | ||
| 149 | ------------------------------------------------------------- | ||
| 150 | { "unterminated long string 1", | ||
| 151 | "\n[[\nbovine", | ||
| 152 | FAIL, ":3: unfinished long string near '<eof>'", | ||
| 153 | }, | ||
| 154 | ------------------------------------------------------------- | ||
| 155 | { "unterminated long string 2", | ||
| 156 | "[[bovine]", | ||
| 157 | FAIL, ":1: unfinished long string near '<eof>'", | ||
| 158 | }, | ||
| 159 | ------------------------------------------------------------- | ||
| 160 | { "unterminated long string 3", | ||
| 161 | "[[[[ \n", | ||
| 162 | FAIL, ":2: unfinished long string near '<eof>'", | ||
| 163 | }, | ||
| 164 | ------------------------------------------------------------- | ||
| 165 | { "nested long string 1", | ||
| 166 | "[[moo[[moo]]moo]]", | ||
| 167 | PASS, "moo[[moo]]moo", | ||
| 168 | }, | ||
| 169 | ------------------------------------------------------------- | ||
| 170 | { "nested long string 2", | ||
| 171 | "[[moo[[moo[[[[]]]]moo]]moo]]", | ||
| 172 | PASS, "moo[[moo[[[[]]]]moo]]moo", | ||
| 173 | }, | ||
| 174 | ------------------------------------------------------------- | ||
| 175 | { "nested long string 3", | ||
| 176 | "[[[[[[]]]][[[[]]]]]]", | ||
| 177 | PASS, "[[[[]]]][[[[]]]]", | ||
| 178 | }, | ||
| 179 | ------------------------------------------------------------- | ||
| 180 | { "brackets in long strings 1", | ||
| 181 | "[[moo[moo]]", | ||
| 182 | PASS, "moo[moo", | ||
| 183 | }, | ||
| 184 | ------------------------------------------------------------- | ||
| 185 | { "brackets in long strings 2", | ||
| 186 | "[[moo[[moo]moo]]moo]]", | ||
| 187 | PASS, "moo[[moo]moo]]moo", | ||
| 188 | }, | ||
| 189 | ------------------------------------------------------------- | ||
| 190 | { "unprocessed escapes in long strings", | ||
| 191 | [[ [[\a\b\f\n\r\t\v\123]] ]], | ||
| 192 | PASS, [[\a\b\f\n\r\t\v\123]], | ||
| 193 | }, | ||
| 194 | ------------------------------------------------------------- | ||
| 195 | { "unbalanced long string", | ||
| 196 | "[[moo]]moo]]", | ||
| 197 | PASS, "1 <string> = moo\n1 <name> = moo\n1 CHAR = ']'\n1 CHAR = ']'\n1 <eof>", | ||
| 198 | }, | ||
| 199 | ------------------------------------------------------------- | ||
| 200 | { "keywords 1", | ||
| 201 | "and break do else", | ||
| 202 | PASS, "1 and\n1 break\n1 do\n1 else\n1 <eof>", | ||
| 203 | }, | ||
| 204 | ------------------------------------------------------------- | ||
| 205 | { "keywords 2", | ||
| 206 | "elseif end false for", | ||
| 207 | PASS, "1 elseif\n1 end\n1 false\n1 for\n1 <eof>", | ||
| 208 | }, | ||
| 209 | ------------------------------------------------------------- | ||
| 210 | { "keywords 3", | ||
| 211 | "function if in local nil", | ||
| 212 | PASS, "1 function\n1 if\n1 in\n1 local\n1 nil\n1 <eof>", | ||
| 213 | }, | ||
| 214 | ------------------------------------------------------------- | ||
| 215 | { "keywords 4", | ||
| 216 | "not or repeat return", | ||
| 217 | PASS, "1 not\n1 or\n1 repeat\n1 return\n1 <eof>", | ||
| 218 | }, | ||
| 219 | ------------------------------------------------------------- | ||
| 220 | { "keywords 5", | ||
| 221 | "then true until while", | ||
| 222 | PASS, "1 then\n1 true\n1 until\n1 while\n1 <eof>", | ||
| 223 | }, | ||
| 224 | ------------------------------------------------------------- | ||
| 225 | { "concat and dots", | ||
| 226 | ".. ...", | ||
| 227 | PASS, "1 ..\n1 ...\n1 <eof>", | ||
| 228 | }, | ||
| 229 | ------------------------------------------------------------- | ||
| 230 | { "shbang handling 1", | ||
| 231 | "#blahblah", | ||
| 232 | PASS, "1 <eof>", | ||
| 233 | }, | ||
| 234 | ------------------------------------------------------------- | ||
| 235 | { "shbang handling 2", | ||
| 236 | "#blahblah\nmoo moo\n", | ||
| 237 | PASS, "2 <name> = moo\n2 <name> = moo\n3 <eof>", | ||
| 238 | }, | ||
| 239 | ------------------------------------------------------------- | ||
| 240 | { "empty string", | ||
| 241 | [['']], | ||
| 242 | PASS, "1 <string> = \n1 <eof>", | ||
| 243 | }, | ||
| 244 | ------------------------------------------------------------- | ||
| 245 | { "single-quoted string", | ||
| 246 | [['bovine']], | ||
| 247 | PASS, "1 <string> = bovine\n1 <eof>", | ||
| 248 | }, | ||
| 249 | ------------------------------------------------------------- | ||
| 250 | { "double-quoted string", | ||
| 251 | [["bovine"]], | ||
| 252 | PASS, "1 <string> = bovine\n1 <eof>", | ||
| 253 | }, | ||
| 254 | ------------------------------------------------------------- | ||
| 255 | { "unterminated string 1", | ||
| 256 | [['moo ]], | ||
| 257 | FAIL, ":1: unfinished string near '<eof>'", | ||
| 258 | }, | ||
| 259 | ------------------------------------------------------------- | ||
| 260 | { "unterminated string 2", | ||
| 261 | [["moo \n]], | ||
| 262 | FAIL, ":1: unfinished string near '<eof>'", | ||
| 263 | }, | ||
| 264 | ------------------------------------------------------------- | ||
| 265 | { "escaped newline in string, line number counted", | ||
| 266 | "\"moo\\\nmoo\\\nmoo\"", | ||
| 267 | PASS, "3 <string> = moo\nmoo\nmoo\n3 <eof>", | ||
| 268 | }, | ||
| 269 | ------------------------------------------------------------- | ||
| 270 | { "escaped characters in string 1", | ||
| 271 | [["moo\amoo"]], | ||
| 272 | PASS, "1 <string> = moo\amoo", | ||
| 273 | }, | ||
| 274 | ------------------------------------------------------------- | ||
| 275 | { "escaped characters in string 2", | ||
| 276 | [["moo\bmoo"]], | ||
| 277 | PASS, "1 <string> = moo\bmoo", | ||
| 278 | }, | ||
| 279 | ------------------------------------------------------------- | ||
| 280 | { "escaped characters in string 3", | ||
| 281 | [["moo\f\n\r\t\vmoo"]], | ||
| 282 | PASS, "1 <string> = moo\f\n\r\t\vmoo", | ||
| 283 | }, | ||
| 284 | ------------------------------------------------------------- | ||
| 285 | { "escaped characters in string 4", | ||
| 286 | [["\\ \" \' \? \[ \]"]], | ||
| 287 | PASS, "1 <string> = \\ \" \' \? \[ \]", | ||
| 288 | }, | ||
| 289 | ------------------------------------------------------------- | ||
| 290 | { "escaped characters in string 5", | ||
| 291 | [["\z \k \: \;"]], | ||
| 292 | PASS, "1 <string> = z k : ;", | ||
| 293 | }, | ||
| 294 | ------------------------------------------------------------- | ||
| 295 | { "escaped characters in string 6", | ||
| 296 | [["\8 \65 \160 \180K \097097"]], | ||
| 297 | PASS, "1 <string> = \8 \65 \160 \180K \097097\n", | ||
| 298 | }, | ||
| 299 | ------------------------------------------------------------- | ||
| 300 | { "escaped characters in string 7", | ||
| 301 | [["\666"]], | ||
| 302 | FAIL, ":1: escape sequence too large near '\"'", | ||
| 303 | }, | ||
| 304 | ------------------------------------------------------------- | ||
| 305 | { "simple numbers", | ||
| 306 | "123 123+", | ||
| 307 | PASS, "1 <number> = 123\n1 <number> = 123\n1 CHAR = '+'\n1 <eof>", | ||
| 308 | }, | ||
| 309 | ------------------------------------------------------------- | ||
| 310 | { "longer numbers", | ||
| 311 | "1234567890 12345678901234567890", | ||
| 312 | PASS, "1 <number> = 1234567890\n1 <number> = 1.2345678901235e+19\n", | ||
| 313 | }, | ||
| 314 | ------------------------------------------------------------- | ||
| 315 | { "fractional numbers", | ||
| 316 | ".123 .12345678901234567890", | ||
| 317 | PASS, "1 <number> = 0.123\n1 <number> = 0.12345678901235\n", | ||
| 318 | }, | ||
| 319 | ------------------------------------------------------------- | ||
| 320 | { "more numbers with decimal points", | ||
| 321 | "12345.67890 1.1.", | ||
| 322 | PASS, "1 <number> = 12345.6789\n1 <number> = 1.1\n1 CHAR = '.'\n", | ||
| 323 | }, | ||
| 324 | ------------------------------------------------------------- | ||
| 325 | { "double decimal points", | ||
| 326 | ".1.1", | ||
| 327 | FAIL, ":1: malformed number near '.1.1'", | ||
| 328 | }, | ||
| 329 | ------------------------------------------------------------- | ||
| 330 | { "double dots within numbers", | ||
| 331 | "1..1", | ||
| 332 | FAIL, ":1: ambiguous syntax (dots follows digits) near '1..'", | ||
| 333 | }, | ||
| 334 | ------------------------------------------------------------- | ||
| 335 | { "incomplete exponential numbers", | ||
| 336 | "123e", | ||
| 337 | FAIL, ":1: malformed number near '123e'", | ||
| 338 | }, | ||
| 339 | ------------------------------------------------------------- | ||
| 340 | { "exponential numbers 1", | ||
| 341 | "1234e5 1234e5.", | ||
| 342 | PASS, "1 <number> = 123400000\n1 <number> = 123400000\n1 CHAR = '.'", | ||
| 343 | }, | ||
| 344 | ------------------------------------------------------------- | ||
| 345 | { "exponential numbers 2", | ||
| 346 | "1234e56 1.23e123", | ||
| 347 | PASS, "1 <number> = 1.234e+59\n1 <number> = 1.23e+123\n", | ||
| 348 | }, | ||
| 349 | ------------------------------------------------------------- | ||
| 350 | { "exponential numbers 3", | ||
| 351 | "12.34e+", | ||
| 352 | FAIL, ":1: malformed number near '12.34e+'", | ||
| 353 | }, | ||
| 354 | ------------------------------------------------------------- | ||
| 355 | { "exponential numbers 4", | ||
| 356 | "12.34e+5 123.4e-5 1234.E+5", | ||
| 357 | PASS, "1 <number> = 1234000\n1 <number> = 0.001234\n1 <number> = 123400000\n", | ||
| 358 | }, | ||
| 359 | ------------------------------------------------------------- | ||
| 360 | { "single character symbols 1", | ||
| 361 | "= > < ~", | ||
| 362 | PASS, "1 CHAR = '='\n1 CHAR = '>'\n1 CHAR = '<'\n1 CHAR = '~'\n", | ||
| 363 | }, | ||
| 364 | ------------------------------------------------------------- | ||
| 365 | { "double character symbols", | ||
| 366 | "== >= <= ~=", | ||
| 367 | PASS, "1 ==\n1 >=\n1 <=\n1 ~=\n", | ||
| 368 | }, | ||
| 369 | ------------------------------------------------------------- | ||
| 370 | { "simple identifiers", | ||
| 371 | "abc ABC", | ||
| 372 | PASS, "1 <name> = abc\n1 <name> = ABC\n1 <eof>", | ||
| 373 | }, | ||
| 374 | ------------------------------------------------------------- | ||
| 375 | { "more identifiers", | ||
| 376 | "_abc _ABC", | ||
| 377 | PASS, "1 <name> = _abc\n1 <name> = _ABC\n1 <eof>", | ||
| 378 | }, | ||
| 379 | ------------------------------------------------------------- | ||
| 380 | { "still more identifiers", | ||
| 381 | "_aB_ _123", | ||
| 382 | PASS, "1 <name> = _aB_\n1 <name> = _123\n1 <eof>", | ||
| 383 | }, | ||
| 384 | ------------------------------------------------------------- | ||
| 385 | { "invalid control character", | ||
| 386 | "\4", | ||
| 387 | FAIL, ":1: invalid control char near 'char(4)'", | ||
| 388 | }, | ||
| 389 | ------------------------------------------------------------- | ||
| 390 | { "single character symbols 2", | ||
| 391 | "` ! @ $ %", | ||
| 392 | PASS, "1 CHAR = '`'\n1 CHAR = '!'\n1 CHAR = '@'\n1 CHAR = '$'\n1 CHAR = '%'\n", | ||
| 393 | }, | ||
| 394 | ------------------------------------------------------------- | ||
| 395 | { "single character symbols 3", | ||
| 396 | "^ & * ( )", | ||
| 397 | PASS, "1 CHAR = '^'\n1 CHAR = '&'\n1 CHAR = '*'\n1 CHAR = '('\n1 CHAR = ')'\n", | ||
| 398 | }, | ||
| 399 | ------------------------------------------------------------- | ||
| 400 | { "single character symbols 4", | ||
| 401 | "_ - + \\ |", | ||
| 402 | PASS, "1 <name> = _\n1 CHAR = '-'\n1 CHAR = '+'\n1 CHAR = '\\'\n1 CHAR = '|'\n", | ||
| 403 | }, | ||
| 404 | ------------------------------------------------------------- | ||
| 405 | { "single character symbols 5", | ||
| 406 | "{ } [ ] :", | ||
| 407 | PASS, "1 CHAR = '{'\n1 CHAR = '}'\n1 CHAR = '['\n1 CHAR = ']'\n1 CHAR = ':'\n", | ||
| 408 | }, | ||
| 409 | ------------------------------------------------------------- | ||
| 410 | { "single character symbols 6", | ||
| 411 | "; , . / ?", | ||
| 412 | PASS, "1 CHAR = ';'\n1 CHAR = ','\n1 CHAR = '.'\n1 CHAR = '/'\n1 CHAR = '?'\n", | ||
| 413 | }, | ||
| 414 | ------------------------------------------------------------- | ||
| 415 | } | ||
| 416 | ------------------------------------------------------------------ | ||
| 417 | -- perform a test case | ||
| 418 | ------------------------------------------------------------------ | ||
| 419 | function do_test_case(count, test_case) | ||
| 420 | if comment == "" then return end -- skip empty entries | ||
| 421 | local comment, chunk, outcome, matcher = unpack(test_case) | ||
| 422 | local result = PASS | ||
| 423 | local output = "" | ||
| 424 | -- initialize lexer | ||
| 425 | local z = zio_init(chunk) | ||
| 426 | local luaX = lex_init(z, "=test") | ||
| 427 | -- lexer test loop | ||
| 428 | local status, token, seminfo | ||
| 429 | repeat | ||
| 430 | -- protected call | ||
| 431 | status, token, seminfo = pcall(luaX.lex, luaX) | ||
| 432 | output = output..luaX.lineno.." " | ||
| 433 | if status then | ||
| 434 | -- successful call | ||
| 435 | if string.len(token) > 1 then | ||
| 436 | if token == "<name>" | ||
| 437 | or token == "<number>" | ||
| 438 | or token == "<string>" then | ||
| 439 | token = token.." = "..seminfo | ||
| 440 | end | ||
| 441 | elseif string.byte(token) >= 32 then -- displayable chars | ||
| 442 | token = "CHAR = '"..token.."'" | ||
| 443 | else -- control characters | ||
| 444 | token = "CHAR = (".. string.byte(token)..")" | ||
| 445 | end | ||
| 446 | output = output..token.."\n" | ||
| 447 | else | ||
| 448 | -- failed call | ||
| 449 | output = output..token -- token is the error message | ||
| 450 | result = FAIL | ||
| 451 | break | ||
| 452 | end | ||
| 453 | until token == "<eof>" | ||
| 454 | -- decision making and reporting | ||
| 455 | local head = "Test "..count..": "..comment | ||
| 456 | if matcher == "" then | ||
| 457 | -- nothing to check against, display for manual check | ||
| 458 | print(head.."\nMANUAL please check manually".. | ||
| 459 | "\n--chunk---------------------------------\n"..chunk.. | ||
| 460 | "\n--actual--------------------------------\n"..output.. | ||
| 461 | "\n\n") | ||
| 462 | return | ||
| 463 | else | ||
| 464 | if outcome == PASS then | ||
| 465 | -- success expected, may be a partial match | ||
| 466 | if string.find(output, matcher, 1, 1) and result == PASS then | ||
| 467 | if not BRIEF then print(head.."\nOK expected success\n") end | ||
| 468 | return | ||
| 469 | end | ||
| 470 | else | ||
| 471 | -- failure expected, may be a partial match | ||
| 472 | if string.find(output, matcher, 1, 1) and result == FAIL then | ||
| 473 | if not BRIEF then print(head.."\nOK expected failure\n") end | ||
| 474 | return | ||
| 475 | end | ||
| 476 | end | ||
| 477 | -- failed because of unmatched string or boolean result | ||
| 478 | local function passfail(status) | ||
| 479 | if status == PASS then return "PASS" else return "FAIL" end | ||
| 480 | end | ||
| 481 | print(head.." *FAILED*".. | ||
| 482 | "\noutcome="..passfail(outcome).. | ||
| 483 | "\nactual= "..passfail(result).. | ||
| 484 | "\n--chunk---------------------------------\n"..chunk.. | ||
| 485 | "\n--expected------------------------------\n"..matcher.. | ||
| 486 | "\n--actual--------------------------------\n"..output.. | ||
| 487 | "\n\n") | ||
| 488 | end | ||
| 489 | end | ||
| 490 | ------------------------------------------------------------------ | ||
| 491 | -- perform auto testing | ||
| 492 | ------------------------------------------------------------------ | ||
| 493 | for i,test_case in ipairs(test_cases) do | ||
| 494 | do_test_case(i, test_case) | ||
| 495 | end | ||
| 496 | end | ||
| 497 | |||
| 498 | auto_test() | ||
| 499 | --]] | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_llex_mk3.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_llex_mk3.lua deleted file mode 100644 index 8b0eec9..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_llex_mk3.lua +++ /dev/null | |||
| @@ -1,500 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | test_llex.lua | ||
| 4 | Test for llex.lua | ||
| 5 | This file is part of Yueliang. | ||
| 6 | |||
| 7 | Copyright (c) 2006 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 | ------------------------------------------------------------------------ | ||
| 18 | BRIEF = true -- if set to true, messages are less verbose | ||
| 19 | |||
| 20 | local lex_init = require("../llex_mk3") | ||
| 21 | |||
| 22 | ------------------------------------------------------------------------ | ||
| 23 | -- simple manual tests | ||
| 24 | ------------------------------------------------------------------------ | ||
| 25 | |||
| 26 | --[[ | ||
| 27 | local function dump(z, source) | ||
| 28 | local luaX = lex_init(z, source) | ||
| 29 | while true do | ||
| 30 | local tok, seminfo = luaX:lex() | ||
| 31 | if tok == "<name>" then | ||
| 32 | seminfo = " "..seminfo | ||
| 33 | elseif tok == "<number>" then | ||
| 34 | seminfo = " "..seminfo | ||
| 35 | elseif tok == "<string>" then | ||
| 36 | seminfo = " '"..seminfo.."'" | ||
| 37 | else | ||
| 38 | seminfo = "" | ||
| 39 | end | ||
| 40 | io.stdout:write(tok..seminfo.."\n") | ||
| 41 | if tok == "<eof>" then break end | ||
| 42 | end | ||
| 43 | end | ||
| 44 | |||
| 45 | local function try_string(chunk) | ||
| 46 | dump(chunk, "=string") | ||
| 47 | end | ||
| 48 | local function try_file(filename) | ||
| 49 | local inf = io.open(filename, "r") | ||
| 50 | if not inf then error("file not found") end | ||
| 51 | local data = inf:read("*a") | ||
| 52 | inf:close() | ||
| 53 | dump(data, "@"..filename) | ||
| 54 | end | ||
| 55 | |||
| 56 | z = try_string("local c = z:getc()") | ||
| 57 | z = try_file("test_lzio_mk2.lua") | ||
| 58 | z = try_file("test_llex_mk2.lua") | ||
| 59 | os.exit() | ||
| 60 | --]] | ||
| 61 | |||
| 62 | ------------------------------------------------------------------------ | ||
| 63 | -- auto-testing of simple test cases to validate lexer behaviour: | ||
| 64 | -- * NOTE coverage has not been checked; not comprehensive | ||
| 65 | -- * only test cases with non-empty comments are processed | ||
| 66 | -- * if no result, then the output is displayed for manual decision | ||
| 67 | -- (output may be used to set expected success or fail text) | ||
| 68 | -- * cases expected to be successful may be a partial match | ||
| 69 | -- * cases expected to fail may also be a partial match | ||
| 70 | ------------------------------------------------------------------------ | ||
| 71 | |||
| 72 | -- [[ | ||
| 73 | local function auto_test() | ||
| 74 | local PASS, FAIL = true, false | ||
| 75 | ------------------------------------------------------------------ | ||
| 76 | -- table of test cases | ||
| 77 | ------------------------------------------------------------------ | ||
| 78 | local test_cases = | ||
| 79 | { | ||
| 80 | ------------------------------------------------------------- | ||
| 81 | --{ "comment", -- comment about the test | ||
| 82 | -- "chunk", -- chunk to test | ||
| 83 | -- PASS, -- PASS or FAIL outcome | ||
| 84 | -- "output", -- output to compare against | ||
| 85 | --}, | ||
| 86 | ------------------------------------------------------------- | ||
| 87 | { "empty chunk string, test EOS", | ||
| 88 | "", | ||
| 89 | PASS, "1 <eof>", | ||
| 90 | }, | ||
| 91 | ------------------------------------------------------------- | ||
| 92 | { "line number counting", | ||
| 93 | "\n\n\r\n", | ||
| 94 | PASS, "4 <eof>", | ||
| 95 | }, | ||
| 96 | ------------------------------------------------------------- | ||
| 97 | { "various whitespaces", | ||
| 98 | " \n\t\t\n \t \t \n\n", | ||
| 99 | PASS, "5 <eof>", | ||
| 100 | }, | ||
| 101 | ------------------------------------------------------------- | ||
| 102 | { "short comment ending in EOS", | ||
| 103 | "-- moo moo", | ||
| 104 | PASS, "1 <eof>", | ||
| 105 | }, | ||
| 106 | ------------------------------------------------------------- | ||
| 107 | { "short comment ending in newline", | ||
| 108 | "-- moo moo\n", | ||
| 109 | PASS, "2 <eof>", | ||
| 110 | }, | ||
| 111 | ------------------------------------------------------------- | ||
| 112 | { "several lines of short comments", | ||
| 113 | "--moo\n-- moo moo\n\n--\tmoo\n", | ||
| 114 | PASS, "5 <eof>", | ||
| 115 | }, | ||
| 116 | ------------------------------------------------------------- | ||
| 117 | { "basic block comment", | ||
| 118 | "--[[bovine]]", | ||
| 119 | PASS, "1 <eof>", | ||
| 120 | }, | ||
| 121 | ------------------------------------------------------------- | ||
| 122 | { "unterminated block comment 1", | ||
| 123 | "--[[bovine", | ||
| 124 | FAIL, ":1: unfinished long comment", | ||
| 125 | }, | ||
| 126 | ------------------------------------------------------------- | ||
| 127 | { "unterminated block comment 2", | ||
| 128 | "--[[bovine]", | ||
| 129 | FAIL, ":1: unfinished long comment", | ||
| 130 | }, | ||
| 131 | ------------------------------------------------------------- | ||
| 132 | { "unterminated block comment 3", | ||
| 133 | "--[[bovine\nmoo moo\nwoof", | ||
| 134 | FAIL, ":3: unfinished long comment", | ||
| 135 | }, | ||
| 136 | ------------------------------------------------------------- | ||
| 137 | { "basic long string", | ||
| 138 | "\n[[bovine]]\n", | ||
| 139 | PASS, "2 <string> = bovine\n3 <eof>", | ||
| 140 | }, | ||
| 141 | ------------------------------------------------------------- | ||
| 142 | { "first newline consumed in long string", | ||
| 143 | "[[\nmoo]]", | ||
| 144 | PASS, "2 <string> = moo\n2 <eof>", | ||
| 145 | }, | ||
| 146 | ------------------------------------------------------------- | ||
| 147 | { "multiline long string", | ||
| 148 | "[[moo\nmoo moo\n]]", | ||
| 149 | PASS, "3 <string> = moo\nmoo moo\n\n3 <eof>", | ||
| 150 | }, | ||
| 151 | ------------------------------------------------------------- | ||
| 152 | { "unterminated long string 1", | ||
| 153 | "\n[[\nbovine", | ||
| 154 | FAIL, ":3: unfinished long string", | ||
| 155 | }, | ||
| 156 | ------------------------------------------------------------- | ||
| 157 | { "unterminated long string 2", | ||
| 158 | "[[bovine]", | ||
| 159 | FAIL, ":1: unfinished long string", | ||
| 160 | }, | ||
| 161 | ------------------------------------------------------------- | ||
| 162 | { "unterminated long string 3", | ||
| 163 | "[[[[ \n", | ||
| 164 | FAIL, ":2: unfinished long string", | ||
| 165 | }, | ||
| 166 | ------------------------------------------------------------- | ||
| 167 | { "nested long string 1", | ||
| 168 | "[[moo[[moo]]moo]]", | ||
| 169 | PASS, "moo[[moo]]moo", | ||
| 170 | }, | ||
| 171 | ------------------------------------------------------------- | ||
| 172 | { "nested long string 2", | ||
| 173 | "[[moo[[moo[[[[]]]]moo]]moo]]", | ||
| 174 | PASS, "moo[[moo[[[[]]]]moo]]moo", | ||
| 175 | }, | ||
| 176 | ------------------------------------------------------------- | ||
| 177 | { "nested long string 3", | ||
| 178 | "[[[[[[]]]][[[[]]]]]]", | ||
| 179 | PASS, "[[[[]]]][[[[]]]]", | ||
| 180 | }, | ||
| 181 | ------------------------------------------------------------- | ||
| 182 | { "brackets in long strings 1", | ||
| 183 | "[[moo[moo]]", | ||
| 184 | PASS, "moo[moo", | ||
| 185 | }, | ||
| 186 | ------------------------------------------------------------- | ||
| 187 | { "brackets in long strings 2", | ||
| 188 | "[[moo[[moo]moo]]moo]]", | ||
| 189 | PASS, "moo[[moo]moo]]moo", | ||
| 190 | }, | ||
| 191 | ------------------------------------------------------------- | ||
| 192 | { "unprocessed escapes in long strings", | ||
| 193 | [[ [[\a\b\f\n\r\t\v\123]] ]], | ||
| 194 | PASS, [[\a\b\f\n\r\t\v\123]], | ||
| 195 | }, | ||
| 196 | ------------------------------------------------------------- | ||
| 197 | { "unbalanced long string", | ||
| 198 | "[[moo]]moo]]", | ||
| 199 | PASS, "1 <string> = moo\n1 <name> = moo\n1 CHAR = ']'\n1 CHAR = ']'\n1 <eof>", | ||
| 200 | }, | ||
| 201 | ------------------------------------------------------------- | ||
| 202 | { "keywords 1", | ||
| 203 | "and break do else", | ||
| 204 | PASS, "1 and\n1 break\n1 do\n1 else\n1 <eof>", | ||
| 205 | }, | ||
| 206 | ------------------------------------------------------------- | ||
| 207 | { "keywords 2", | ||
| 208 | "elseif end false for", | ||
| 209 | PASS, "1 elseif\n1 end\n1 false\n1 for\n1 <eof>", | ||
| 210 | }, | ||
| 211 | ------------------------------------------------------------- | ||
| 212 | { "keywords 3", | ||
| 213 | "function if in local nil", | ||
| 214 | PASS, "1 function\n1 if\n1 in\n1 local\n1 nil\n1 <eof>", | ||
| 215 | }, | ||
| 216 | ------------------------------------------------------------- | ||
| 217 | { "keywords 4", | ||
| 218 | "not or repeat return", | ||
| 219 | PASS, "1 not\n1 or\n1 repeat\n1 return\n1 <eof>", | ||
| 220 | }, | ||
| 221 | ------------------------------------------------------------- | ||
| 222 | { "keywords 5", | ||
| 223 | "then true until while", | ||
| 224 | PASS, "1 then\n1 true\n1 until\n1 while\n1 <eof>", | ||
| 225 | }, | ||
| 226 | ------------------------------------------------------------- | ||
| 227 | { "concat and dots", | ||
| 228 | ".. ...", | ||
| 229 | PASS, "1 ..\n1 ...\n1 <eof>", | ||
| 230 | }, | ||
| 231 | ------------------------------------------------------------- | ||
| 232 | { "shbang handling 1", | ||
| 233 | "#blahblah", | ||
| 234 | PASS, "1 <eof>", | ||
| 235 | }, | ||
| 236 | ------------------------------------------------------------- | ||
| 237 | { "shbang handling 2", | ||
| 238 | "#blahblah\nmoo moo\n", | ||
| 239 | PASS, "2 <name> = moo\n2 <name> = moo\n3 <eof>", | ||
| 240 | }, | ||
| 241 | ------------------------------------------------------------- | ||
| 242 | { "empty string", | ||
| 243 | [['']], | ||
| 244 | PASS, "1 <string> = \n1 <eof>", | ||
| 245 | }, | ||
| 246 | ------------------------------------------------------------- | ||
| 247 | { "single-quoted string", | ||
| 248 | [['bovine']], | ||
| 249 | PASS, "1 <string> = bovine\n1 <eof>", | ||
| 250 | }, | ||
| 251 | ------------------------------------------------------------- | ||
| 252 | { "double-quoted string", | ||
| 253 | [["bovine"]], | ||
| 254 | PASS, "1 <string> = bovine\n1 <eof>", | ||
| 255 | }, | ||
| 256 | ------------------------------------------------------------- | ||
| 257 | { "unterminated string 1", | ||
| 258 | [['moo ]], | ||
| 259 | FAIL, ":1: unfinished string", | ||
| 260 | }, | ||
| 261 | ------------------------------------------------------------- | ||
| 262 | { "unterminated string 2", | ||
| 263 | [["moo \n]], | ||
| 264 | FAIL, ":1: unfinished string", | ||
| 265 | }, | ||
| 266 | ------------------------------------------------------------- | ||
| 267 | { "escaped newline in string, line number counted", | ||
| 268 | "\"moo\\\nmoo\\\nmoo\"", | ||
| 269 | PASS, "3 <string> = moo\nmoo\nmoo\n3 <eof>", | ||
| 270 | }, | ||
| 271 | ------------------------------------------------------------- | ||
| 272 | { "escaped characters in string 1", | ||
| 273 | [["moo\amoo"]], | ||
| 274 | PASS, "1 <string> = moo\amoo", | ||
| 275 | }, | ||
| 276 | ------------------------------------------------------------- | ||
| 277 | { "escaped characters in string 2", | ||
| 278 | [["moo\bmoo"]], | ||
| 279 | PASS, "1 <string> = moo\bmoo", | ||
| 280 | }, | ||
| 281 | ------------------------------------------------------------- | ||
| 282 | { "escaped characters in string 3", | ||
| 283 | [["moo\f\n\r\t\vmoo"]], | ||
| 284 | PASS, "1 <string> = moo\f\n\r\t\vmoo", | ||
| 285 | }, | ||
| 286 | ------------------------------------------------------------- | ||
| 287 | { "escaped characters in string 4", | ||
| 288 | [["\\ \" \' \? \[ \]"]], | ||
| 289 | PASS, "1 <string> = \\ \" \' \? \[ \]", | ||
| 290 | }, | ||
| 291 | ------------------------------------------------------------- | ||
| 292 | { "escaped characters in string 5", | ||
| 293 | [["\z \k \: \;"]], | ||
| 294 | PASS, "1 <string> = z k : ;", | ||
| 295 | }, | ||
| 296 | ------------------------------------------------------------- | ||
| 297 | { "escaped characters in string 6", | ||
| 298 | [["\8 \65 \160 \180K \097097"]], | ||
| 299 | PASS, "1 <string> = \8 \65 \160 \180K \097097\n", | ||
| 300 | }, | ||
| 301 | ------------------------------------------------------------- | ||
| 302 | { "escaped characters in string 7", | ||
| 303 | [["\666"]], | ||
| 304 | FAIL, ":1: escape sequence too large", | ||
| 305 | }, | ||
| 306 | ------------------------------------------------------------- | ||
| 307 | { "simple numbers", | ||
| 308 | "123 123+", | ||
| 309 | PASS, "1 <number> = 123\n1 <number> = 123\n1 CHAR = '+'\n1 <eof>", | ||
| 310 | }, | ||
| 311 | ------------------------------------------------------------- | ||
| 312 | { "longer numbers", | ||
| 313 | "1234567890 12345678901234567890", | ||
| 314 | PASS, "1 <number> = 1234567890\n1 <number> = 1.2345678901235e+19\n", | ||
| 315 | }, | ||
| 316 | ------------------------------------------------------------- | ||
| 317 | { "fractional numbers", | ||
| 318 | ".123 .12345678901234567890", | ||
| 319 | PASS, "1 <number> = 0.123\n1 <number> = 0.12345678901235\n", | ||
| 320 | }, | ||
| 321 | ------------------------------------------------------------- | ||
| 322 | { "more numbers with decimal points", | ||
| 323 | "12345.67890 1.1.", | ||
| 324 | PASS, "1 <number> = 12345.6789\n1 <number> = 1.1\n1 CHAR = '.'\n", | ||
| 325 | }, | ||
| 326 | ------------------------------------------------------------- | ||
| 327 | { "double decimal points", | ||
| 328 | ".1.1", | ||
| 329 | FAIL, ":1: malformed number", | ||
| 330 | }, | ||
| 331 | ------------------------------------------------------------- | ||
| 332 | { "double dots within numbers", | ||
| 333 | "1..1", | ||
| 334 | FAIL, ":1: ambiguous syntax (dots follows digits)", | ||
| 335 | }, | ||
| 336 | ------------------------------------------------------------- | ||
| 337 | { "incomplete exponential numbers", | ||
| 338 | "123e", | ||
| 339 | FAIL, ":1: malformed number", | ||
| 340 | }, | ||
| 341 | ------------------------------------------------------------- | ||
| 342 | { "exponential numbers 1", | ||
| 343 | "1234e5 1234e5.", | ||
| 344 | PASS, "1 <number> = 123400000\n1 <number> = 123400000\n1 CHAR = '.'", | ||
| 345 | }, | ||
| 346 | ------------------------------------------------------------- | ||
| 347 | { "exponential numbers 2", | ||
| 348 | "1234e56 1.23e123", | ||
| 349 | PASS, "1 <number> = 1.234e+59\n1 <number> = 1.23e+123\n", | ||
| 350 | }, | ||
| 351 | ------------------------------------------------------------- | ||
| 352 | { "exponential numbers 3", | ||
| 353 | "12.34e+", | ||
| 354 | FAIL, ":1: malformed number", | ||
| 355 | }, | ||
| 356 | ------------------------------------------------------------- | ||
| 357 | { "exponential numbers 4", | ||
| 358 | "12.34e+5 123.4e-5 1234.E+5", | ||
| 359 | PASS, "1 <number> = 1234000\n1 <number> = 0.001234\n1 <number> = 123400000\n", | ||
| 360 | }, | ||
| 361 | ------------------------------------------------------------- | ||
| 362 | { "single character symbols 1", | ||
| 363 | "= > < ~", | ||
| 364 | PASS, "1 CHAR = '='\n1 CHAR = '>'\n1 CHAR = '<'\n1 CHAR = '~'\n", | ||
| 365 | }, | ||
| 366 | ------------------------------------------------------------- | ||
| 367 | { "double character symbols", | ||
| 368 | "== >= <= ~=", | ||
| 369 | PASS, "1 ==\n1 >=\n1 <=\n1 ~=\n", | ||
| 370 | }, | ||
| 371 | ------------------------------------------------------------- | ||
| 372 | { "simple identifiers", | ||
| 373 | "abc ABC", | ||
| 374 | PASS, "1 <name> = abc\n1 <name> = ABC\n1 <eof>", | ||
| 375 | }, | ||
| 376 | ------------------------------------------------------------- | ||
| 377 | { "more identifiers", | ||
| 378 | "_abc _ABC", | ||
| 379 | PASS, "1 <name> = _abc\n1 <name> = _ABC\n1 <eof>", | ||
| 380 | }, | ||
| 381 | ------------------------------------------------------------- | ||
| 382 | { "still more identifiers", | ||
| 383 | "_aB_ _123", | ||
| 384 | PASS, "1 <name> = _aB_\n1 <name> = _123\n1 <eof>", | ||
| 385 | }, | ||
| 386 | ------------------------------------------------------------- | ||
| 387 | { "invalid control character", | ||
| 388 | "\4", | ||
| 389 | FAIL, ":1: invalid control char", | ||
| 390 | }, | ||
| 391 | ------------------------------------------------------------- | ||
| 392 | { "single character symbols 2", | ||
| 393 | "` ! @ $ %", | ||
| 394 | PASS, "1 CHAR = '`'\n1 CHAR = '!'\n1 CHAR = '@'\n1 CHAR = '$'\n1 CHAR = '%'\n", | ||
| 395 | }, | ||
| 396 | ------------------------------------------------------------- | ||
| 397 | { "single character symbols 3", | ||
| 398 | "^ & * ( )", | ||
| 399 | PASS, "1 CHAR = '^'\n1 CHAR = '&'\n1 CHAR = '*'\n1 CHAR = '('\n1 CHAR = ')'\n", | ||
| 400 | }, | ||
| 401 | ------------------------------------------------------------- | ||
| 402 | { "single character symbols 4", | ||
| 403 | "_ - + \\ |", | ||
| 404 | PASS, "1 <name> = _\n1 CHAR = '-'\n1 CHAR = '+'\n1 CHAR = '\\'\n1 CHAR = '|'\n", | ||
| 405 | }, | ||
| 406 | ------------------------------------------------------------- | ||
| 407 | { "single character symbols 5", | ||
| 408 | "{ } [ ] :", | ||
| 409 | PASS, "1 CHAR = '{'\n1 CHAR = '}'\n1 CHAR = '['\n1 CHAR = ']'\n1 CHAR = ':'\n", | ||
| 410 | }, | ||
| 411 | ------------------------------------------------------------- | ||
| 412 | { "single character symbols 6", | ||
| 413 | "; , . / ?", | ||
| 414 | PASS, "1 CHAR = ';'\n1 CHAR = ','\n1 CHAR = '.'\n1 CHAR = '/'\n1 CHAR = '?'\n", | ||
| 415 | }, | ||
| 416 | ------------------------------------------------------------- | ||
| 417 | } | ||
| 418 | ------------------------------------------------------------------ | ||
| 419 | -- perform a test case | ||
| 420 | ------------------------------------------------------------------ | ||
| 421 | function do_test_case(count, test_case) | ||
| 422 | if comment == "" then return end -- skip empty entries | ||
| 423 | local comment, chunk, outcome, matcher = unpack(test_case) | ||
| 424 | local result = PASS | ||
| 425 | local output = "" | ||
| 426 | -- initialize lexer | ||
| 427 | local luaX = lex_init(chunk, "=test") | ||
| 428 | -- lexer test loop | ||
| 429 | local status, token, seminfo | ||
| 430 | repeat | ||
| 431 | -- protected call | ||
| 432 | status, token, seminfo = pcall(luaX.lex, luaX) | ||
| 433 | output = output..luaX.ln.." " | ||
| 434 | if status then | ||
| 435 | -- successful call | ||
| 436 | if string.len(token) > 1 then | ||
| 437 | if token == "<name>" | ||
| 438 | or token == "<number>" | ||
| 439 | or token == "<string>" then | ||
| 440 | token = token.." = "..seminfo | ||
| 441 | end | ||
| 442 | elseif string.byte(token) >= 32 then -- displayable chars | ||
| 443 | token = "CHAR = '"..token.."'" | ||
| 444 | else -- control characters | ||
| 445 | token = "CHAR = (".. string.byte(token)..")" | ||
| 446 | end | ||
| 447 | output = output..token.."\n" | ||
| 448 | else | ||
| 449 | -- failed call | ||
| 450 | output = output..token -- token is the error message | ||
| 451 | result = FAIL | ||
| 452 | break | ||
| 453 | end | ||
| 454 | until token == "<eof>" | ||
| 455 | -- decision making and reporting | ||
| 456 | local head = "Test "..count..": "..comment | ||
| 457 | if matcher == "" then | ||
| 458 | -- nothing to check against, display for manual check | ||
| 459 | print(head.."\nMANUAL please check manually".. | ||
| 460 | "\n--chunk---------------------------------\n"..chunk.. | ||
| 461 | "\n--actual--------------------------------\n"..output.. | ||
| 462 | "\n\n") | ||
| 463 | return | ||
| 464 | else | ||
| 465 | if outcome == PASS then | ||
| 466 | -- success expected, may be a partial match | ||
| 467 | if string.find(output, matcher, 1, 1) and result == PASS then | ||
| 468 | if not BRIEF then print(head.."\nOK expected success\n") end | ||
| 469 | return | ||
| 470 | end | ||
| 471 | else | ||
| 472 | -- failure expected, may be a partial match | ||
| 473 | if string.find(output, matcher, 1, 1) and result == FAIL then | ||
| 474 | if not BRIEF then print(head.."\nOK expected failure\n") end | ||
| 475 | return | ||
| 476 | end | ||
| 477 | end | ||
| 478 | -- failed because of unmatched string or boolean result | ||
| 479 | local function passfail(status) | ||
| 480 | if status == PASS then return "PASS" else return "FAIL" end | ||
| 481 | end | ||
| 482 | print(head.." *FAILED*".. | ||
| 483 | "\noutcome="..passfail(outcome).. | ||
| 484 | "\nactual= "..passfail(result).. | ||
| 485 | "\n--chunk---------------------------------\n"..chunk.. | ||
| 486 | "\n--expected------------------------------\n"..matcher.. | ||
| 487 | "\n--actual--------------------------------\n"..output.. | ||
| 488 | "\n\n") | ||
| 489 | end | ||
| 490 | end | ||
| 491 | ------------------------------------------------------------------ | ||
| 492 | -- perform auto testing | ||
| 493 | ------------------------------------------------------------------ | ||
| 494 | for i,test_case in ipairs(test_cases) do | ||
| 495 | do_test_case(i, test_case) | ||
| 496 | end | ||
| 497 | end | ||
| 498 | |||
| 499 | auto_test() | ||
| 500 | --]] | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_llex_mk4.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_llex_mk4.lua deleted file mode 100644 index 316a9bf..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_llex_mk4.lua +++ /dev/null | |||
| @@ -1,499 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | test_llex.lua | ||
| 4 | Test for llex.lua | ||
| 5 | This file is part of Yueliang. | ||
| 6 | |||
| 7 | Copyright (c) 2006 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 | ------------------------------------------------------------------------ | ||
| 18 | BRIEF = true -- if set to true, messages are less verbose | ||
| 19 | |||
| 20 | local zio_init = require("../lzio_mk4") | ||
| 21 | local lex_init = require("../llex_mk4") | ||
| 22 | |||
| 23 | ------------------------------------------------------------------------ | ||
| 24 | -- simple manual tests | ||
| 25 | ------------------------------------------------------------------------ | ||
| 26 | |||
| 27 | --[[ | ||
| 28 | local function dump(z, source) | ||
| 29 | local luaX = lex_init(z, source) | ||
| 30 | while true do | ||
| 31 | local tok, seminfo = luaX:lex() | ||
| 32 | if tok == "<name>" then | ||
| 33 | seminfo = " "..seminfo | ||
| 34 | elseif tok == "<number>" then | ||
| 35 | seminfo = " "..seminfo | ||
| 36 | elseif tok == "<string>" then | ||
| 37 | seminfo = " '"..seminfo.."'" | ||
| 38 | else | ||
| 39 | seminfo = "" | ||
| 40 | end | ||
| 41 | io.stdout:write(tok..seminfo.."\n") | ||
| 42 | if tok == "<eof>" then break end | ||
| 43 | end | ||
| 44 | end | ||
| 45 | |||
| 46 | local function try_string(chunk) | ||
| 47 | dump(zio_init(chunk), "=string") | ||
| 48 | end | ||
| 49 | local function try_file(filename) | ||
| 50 | local f = "@"..filename | ||
| 51 | dump(zio_init(f), f) | ||
| 52 | end | ||
| 53 | |||
| 54 | z = try_string("local c = z:getc()") | ||
| 55 | z = try_file("test_lzio_mk2.lua") | ||
| 56 | z = try_file("test_llex_mk2.lua") | ||
| 57 | os.exit() | ||
| 58 | --]] | ||
| 59 | |||
| 60 | ------------------------------------------------------------------------ | ||
| 61 | -- auto-testing of simple test cases to validate lexer behaviour: | ||
| 62 | -- * NOTE coverage has not been checked; not comprehensive | ||
| 63 | -- * only test cases with non-empty comments are processed | ||
| 64 | -- * if no result, then the output is displayed for manual decision | ||
| 65 | -- (output may be used to set expected success or fail text) | ||
| 66 | -- * cases expected to be successful may be a partial match | ||
| 67 | -- * cases expected to fail may also be a partial match | ||
| 68 | ------------------------------------------------------------------------ | ||
| 69 | |||
| 70 | -- [[ | ||
| 71 | local function auto_test() | ||
| 72 | local PASS, FAIL = true, false | ||
| 73 | ------------------------------------------------------------------ | ||
| 74 | -- table of test cases | ||
| 75 | ------------------------------------------------------------------ | ||
| 76 | local test_cases = | ||
| 77 | { | ||
| 78 | ------------------------------------------------------------- | ||
| 79 | --{ "comment", -- comment about the test | ||
| 80 | -- "chunk", -- chunk to test | ||
| 81 | -- PASS, -- PASS or FAIL outcome | ||
| 82 | -- "output", -- output to compare against | ||
| 83 | --}, | ||
| 84 | ------------------------------------------------------------- | ||
| 85 | { "empty chunk string, test EOS", | ||
| 86 | "", | ||
| 87 | PASS, "1 <eof>", | ||
| 88 | }, | ||
| 89 | ------------------------------------------------------------- | ||
| 90 | { "line number counting", | ||
| 91 | "\n\n\r\n", | ||
| 92 | PASS, "4 <eof>", | ||
| 93 | }, | ||
| 94 | ------------------------------------------------------------- | ||
| 95 | { "various whitespaces", | ||
| 96 | " \n\t\t\n \t \t \n\n", | ||
| 97 | PASS, "5 <eof>", | ||
| 98 | }, | ||
| 99 | ------------------------------------------------------------- | ||
| 100 | { "short comment ending in EOS", | ||
| 101 | "-- moo moo", | ||
| 102 | PASS, "1 <eof>", | ||
| 103 | }, | ||
| 104 | ------------------------------------------------------------- | ||
| 105 | { "short comment ending in newline", | ||
| 106 | "-- moo moo\n", | ||
| 107 | PASS, "2 <eof>", | ||
| 108 | }, | ||
| 109 | ------------------------------------------------------------- | ||
| 110 | { "several lines of short comments", | ||
| 111 | "--moo\n-- moo moo\n\n--\tmoo\n", | ||
| 112 | PASS, "5 <eof>", | ||
| 113 | }, | ||
| 114 | ------------------------------------------------------------- | ||
| 115 | { "basic block comment", | ||
| 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\nmoo moo\nwoof", | ||
| 132 | FAIL, ":3: unfinished long comment", | ||
| 133 | }, | ||
| 134 | ------------------------------------------------------------- | ||
| 135 | { "basic long string", | ||
| 136 | "\n[[bovine]]\n", | ||
| 137 | PASS, "2 <string> = bovine\n3 <eof>", | ||
| 138 | }, | ||
| 139 | ------------------------------------------------------------- | ||
| 140 | { "first newline consumed in long string", | ||
| 141 | "[[\nmoo]]", | ||
| 142 | PASS, "2 <string> = moo\n2 <eof>", | ||
| 143 | }, | ||
| 144 | ------------------------------------------------------------- | ||
| 145 | { "multiline long string", | ||
| 146 | "[[moo\nmoo moo\n]]", | ||
| 147 | PASS, "3 <string> = moo\nmoo moo\n\n3 <eof>", | ||
| 148 | }, | ||
| 149 | ------------------------------------------------------------- | ||
| 150 | { "unterminated long string 1", | ||
| 151 | "\n[[\nbovine", | ||
| 152 | FAIL, ":3: unfinished long string", | ||
| 153 | }, | ||
| 154 | ------------------------------------------------------------- | ||
| 155 | { "unterminated long string 2", | ||
| 156 | "[[bovine]", | ||
| 157 | FAIL, ":1: unfinished long string", | ||
| 158 | }, | ||
| 159 | ------------------------------------------------------------- | ||
| 160 | { "unterminated long string 3", | ||
| 161 | "[[[[ \n", | ||
| 162 | FAIL, ":2: unfinished long string", | ||
| 163 | }, | ||
| 164 | ------------------------------------------------------------- | ||
| 165 | { "nested long string 1", | ||
| 166 | "[[moo[[moo]]moo]]", | ||
| 167 | PASS, "moo[[moo]]moo", | ||
| 168 | }, | ||
| 169 | ------------------------------------------------------------- | ||
| 170 | { "nested long string 2", | ||
| 171 | "[[moo[[moo[[[[]]]]moo]]moo]]", | ||
| 172 | PASS, "moo[[moo[[[[]]]]moo]]moo", | ||
| 173 | }, | ||
| 174 | ------------------------------------------------------------- | ||
| 175 | { "nested long string 3", | ||
| 176 | "[[[[[[]]]][[[[]]]]]]", | ||
| 177 | PASS, "[[[[]]]][[[[]]]]", | ||
| 178 | }, | ||
| 179 | ------------------------------------------------------------- | ||
| 180 | { "brackets in long strings 1", | ||
| 181 | "[[moo[moo]]", | ||
| 182 | PASS, "moo[moo", | ||
| 183 | }, | ||
| 184 | ------------------------------------------------------------- | ||
| 185 | { "brackets in long strings 2", | ||
| 186 | "[[moo[[moo]moo]]moo]]", | ||
| 187 | PASS, "moo[[moo]moo]]moo", | ||
| 188 | }, | ||
| 189 | ------------------------------------------------------------- | ||
| 190 | { "unprocessed escapes in long strings", | ||
| 191 | [[ [[\a\b\f\n\r\t\v\123]] ]], | ||
| 192 | PASS, [[\a\b\f\n\r\t\v\123]], | ||
| 193 | }, | ||
| 194 | ------------------------------------------------------------- | ||
| 195 | { "unbalanced long string", | ||
| 196 | "[[moo]]moo]]", | ||
| 197 | PASS, "1 <string> = moo\n1 <name> = moo\n1 CHAR = ']'\n1 CHAR = ']'\n1 <eof>", | ||
| 198 | }, | ||
| 199 | ------------------------------------------------------------- | ||
| 200 | { "keywords 1", | ||
| 201 | "and break do else", | ||
| 202 | PASS, "1 and\n1 break\n1 do\n1 else\n1 <eof>", | ||
| 203 | }, | ||
| 204 | ------------------------------------------------------------- | ||
| 205 | { "keywords 2", | ||
| 206 | "elseif end false for", | ||
| 207 | PASS, "1 elseif\n1 end\n1 false\n1 for\n1 <eof>", | ||
| 208 | }, | ||
| 209 | ------------------------------------------------------------- | ||
| 210 | { "keywords 3", | ||
| 211 | "function if in local nil", | ||
| 212 | PASS, "1 function\n1 if\n1 in\n1 local\n1 nil\n1 <eof>", | ||
| 213 | }, | ||
| 214 | ------------------------------------------------------------- | ||
| 215 | { "keywords 4", | ||
| 216 | "not or repeat return", | ||
| 217 | PASS, "1 not\n1 or\n1 repeat\n1 return\n1 <eof>", | ||
| 218 | }, | ||
| 219 | ------------------------------------------------------------- | ||
| 220 | { "keywords 5", | ||
| 221 | "then true until while", | ||
| 222 | PASS, "1 then\n1 true\n1 until\n1 while\n1 <eof>", | ||
| 223 | }, | ||
| 224 | ------------------------------------------------------------- | ||
| 225 | { "concat and dots", | ||
| 226 | ".. ...", | ||
| 227 | PASS, "1 ..\n1 ...\n1 <eof>", | ||
| 228 | }, | ||
| 229 | ------------------------------------------------------------- | ||
| 230 | { "shbang handling 1", | ||
| 231 | "#blahblah", | ||
| 232 | PASS, "1 <eof>", | ||
| 233 | }, | ||
| 234 | ------------------------------------------------------------- | ||
| 235 | { "shbang handling 2", | ||
| 236 | "#blahblah\nmoo moo\n", | ||
| 237 | PASS, "2 <name> = moo\n2 <name> = moo\n3 <eof>", | ||
| 238 | }, | ||
| 239 | ------------------------------------------------------------- | ||
| 240 | { "empty string", | ||
| 241 | [['']], | ||
| 242 | PASS, "1 <string> = \n1 <eof>", | ||
| 243 | }, | ||
| 244 | ------------------------------------------------------------- | ||
| 245 | { "single-quoted string", | ||
| 246 | [['bovine']], | ||
| 247 | PASS, "1 <string> = bovine\n1 <eof>", | ||
| 248 | }, | ||
| 249 | ------------------------------------------------------------- | ||
| 250 | { "double-quoted string", | ||
| 251 | [["bovine"]], | ||
| 252 | PASS, "1 <string> = bovine\n1 <eof>", | ||
| 253 | }, | ||
| 254 | ------------------------------------------------------------- | ||
| 255 | { "unterminated string 1", | ||
| 256 | [['moo ]], | ||
| 257 | FAIL, ":1: unfinished string", | ||
| 258 | }, | ||
| 259 | ------------------------------------------------------------- | ||
| 260 | { "unterminated string 2", | ||
| 261 | [["moo \n]], | ||
| 262 | FAIL, ":1: unfinished string", | ||
| 263 | }, | ||
| 264 | ------------------------------------------------------------- | ||
| 265 | { "escaped newline in string, line number counted", | ||
| 266 | "\"moo\\\nmoo\\\nmoo\"", | ||
| 267 | PASS, "3 <string> = moo\nmoo\nmoo\n3 <eof>", | ||
| 268 | }, | ||
| 269 | ------------------------------------------------------------- | ||
| 270 | { "escaped characters in string 1", | ||
| 271 | [["moo\amoo"]], | ||
| 272 | PASS, "1 <string> = moo\amoo", | ||
| 273 | }, | ||
| 274 | ------------------------------------------------------------- | ||
| 275 | { "escaped characters in string 2", | ||
| 276 | [["moo\bmoo"]], | ||
| 277 | PASS, "1 <string> = moo\bmoo", | ||
| 278 | }, | ||
| 279 | ------------------------------------------------------------- | ||
| 280 | { "escaped characters in string 3", | ||
| 281 | [["moo\f\n\r\t\vmoo"]], | ||
| 282 | PASS, "1 <string> = moo\f\n\r\t\vmoo", | ||
| 283 | }, | ||
| 284 | ------------------------------------------------------------- | ||
| 285 | { "escaped characters in string 4", | ||
| 286 | [["\\ \" \' \? \[ \]"]], | ||
| 287 | PASS, "1 <string> = \\ \" \' \? \[ \]", | ||
| 288 | }, | ||
| 289 | ------------------------------------------------------------- | ||
| 290 | { "escaped characters in string 5", | ||
| 291 | [["\z \k \: \;"]], | ||
| 292 | PASS, "1 <string> = z k : ;", | ||
| 293 | }, | ||
| 294 | ------------------------------------------------------------- | ||
| 295 | { "escaped characters in string 6", | ||
| 296 | [["\8 \65 \160 \180K \097097"]], | ||
| 297 | PASS, "1 <string> = \8 \65 \160 \180K \097097\n", | ||
| 298 | }, | ||
| 299 | ------------------------------------------------------------- | ||
| 300 | { "escaped characters in string 7", | ||
| 301 | [["\666"]], | ||
| 302 | FAIL, ":1: escape sequence too large", | ||
| 303 | }, | ||
| 304 | ------------------------------------------------------------- | ||
| 305 | { "simple numbers", | ||
| 306 | "123 123+", | ||
| 307 | PASS, "1 <number> = 123\n1 <number> = 123\n1 CHAR = '+'\n1 <eof>", | ||
| 308 | }, | ||
| 309 | ------------------------------------------------------------- | ||
| 310 | { "longer numbers", | ||
| 311 | "1234567890 12345678901234567890", | ||
| 312 | PASS, "1 <number> = 1234567890\n1 <number> = 1.2345678901235e+19\n", | ||
| 313 | }, | ||
| 314 | ------------------------------------------------------------- | ||
| 315 | { "fractional numbers", | ||
| 316 | ".123 .12345678901234567890", | ||
| 317 | PASS, "1 <number> = 0.123\n1 <number> = 0.12345678901235\n", | ||
| 318 | }, | ||
| 319 | ------------------------------------------------------------- | ||
| 320 | { "more numbers with decimal points", | ||
| 321 | "12345.67890 1.1.", | ||
| 322 | PASS, "1 <number> = 12345.6789\n1 <number> = 1.1\n1 CHAR = '.'\n", | ||
| 323 | }, | ||
| 324 | ------------------------------------------------------------- | ||
| 325 | { "double decimal points", | ||
| 326 | ".1.1", | ||
| 327 | FAIL, ":1: malformed number", | ||
| 328 | }, | ||
| 329 | ------------------------------------------------------------- | ||
| 330 | { "double dots within numbers", | ||
| 331 | "1..1", | ||
| 332 | FAIL, ":1: ambiguous syntax (dots follows digits)", | ||
| 333 | }, | ||
| 334 | ------------------------------------------------------------- | ||
| 335 | { "incomplete exponential numbers", | ||
| 336 | "123e", | ||
| 337 | FAIL, ":1: malformed number", | ||
| 338 | }, | ||
| 339 | ------------------------------------------------------------- | ||
| 340 | { "exponential numbers 1", | ||
| 341 | "1234e5 1234e5.", | ||
| 342 | PASS, "1 <number> = 123400000\n1 <number> = 123400000\n1 CHAR = '.'", | ||
| 343 | }, | ||
| 344 | ------------------------------------------------------------- | ||
| 345 | { "exponential numbers 2", | ||
| 346 | "1234e56 1.23e123", | ||
| 347 | PASS, "1 <number> = 1.234e+59\n1 <number> = 1.23e+123\n", | ||
| 348 | }, | ||
| 349 | ------------------------------------------------------------- | ||
| 350 | { "exponential numbers 3", | ||
| 351 | "12.34e+", | ||
| 352 | FAIL, ":1: malformed number", | ||
| 353 | }, | ||
| 354 | ------------------------------------------------------------- | ||
| 355 | { "exponential numbers 4", | ||
| 356 | "12.34e+5 123.4e-5 1234.E+5", | ||
| 357 | PASS, "1 <number> = 1234000\n1 <number> = 0.001234\n1 <number> = 123400000\n", | ||
| 358 | }, | ||
| 359 | ------------------------------------------------------------- | ||
| 360 | { "single character symbols 1", | ||
| 361 | "= > < ~", | ||
| 362 | PASS, "1 CHAR = '='\n1 CHAR = '>'\n1 CHAR = '<'\n1 CHAR = '~'\n", | ||
| 363 | }, | ||
| 364 | ------------------------------------------------------------- | ||
| 365 | { "double character symbols", | ||
| 366 | "== >= <= ~=", | ||
| 367 | PASS, "1 ==\n1 >=\n1 <=\n1 ~=\n", | ||
| 368 | }, | ||
| 369 | ------------------------------------------------------------- | ||
| 370 | { "simple identifiers", | ||
| 371 | "abc ABC", | ||
| 372 | PASS, "1 <name> = abc\n1 <name> = ABC\n1 <eof>", | ||
| 373 | }, | ||
| 374 | ------------------------------------------------------------- | ||
| 375 | { "more identifiers", | ||
| 376 | "_abc _ABC", | ||
| 377 | PASS, "1 <name> = _abc\n1 <name> = _ABC\n1 <eof>", | ||
| 378 | }, | ||
| 379 | ------------------------------------------------------------- | ||
| 380 | { "still more identifiers", | ||
| 381 | "_aB_ _123", | ||
| 382 | PASS, "1 <name> = _aB_\n1 <name> = _123\n1 <eof>", | ||
| 383 | }, | ||
| 384 | ------------------------------------------------------------- | ||
| 385 | { "invalid control character", | ||
| 386 | "\4", | ||
| 387 | FAIL, ":1: invalid control char", | ||
| 388 | }, | ||
| 389 | ------------------------------------------------------------- | ||
| 390 | { "single character symbols 2", | ||
| 391 | "` ! @ $ %", | ||
| 392 | PASS, "1 CHAR = '`'\n1 CHAR = '!'\n1 CHAR = '@'\n1 CHAR = '$'\n1 CHAR = '%'\n", | ||
| 393 | }, | ||
| 394 | ------------------------------------------------------------- | ||
| 395 | { "single character symbols 3", | ||
| 396 | "^ & * ( )", | ||
| 397 | PASS, "1 CHAR = '^'\n1 CHAR = '&'\n1 CHAR = '*'\n1 CHAR = '('\n1 CHAR = ')'\n", | ||
| 398 | }, | ||
| 399 | ------------------------------------------------------------- | ||
| 400 | { "single character symbols 4", | ||
| 401 | "_ - + \\ |", | ||
| 402 | PASS, "1 <name> = _\n1 CHAR = '-'\n1 CHAR = '+'\n1 CHAR = '\\'\n1 CHAR = '|'\n", | ||
| 403 | }, | ||
| 404 | ------------------------------------------------------------- | ||
| 405 | { "single character symbols 5", | ||
| 406 | "{ } [ ] :", | ||
| 407 | PASS, "1 CHAR = '{'\n1 CHAR = '}'\n1 CHAR = '['\n1 CHAR = ']'\n1 CHAR = ':'\n", | ||
| 408 | }, | ||
| 409 | ------------------------------------------------------------- | ||
| 410 | { "single character symbols 6", | ||
| 411 | "; , . / ?", | ||
| 412 | PASS, "1 CHAR = ';'\n1 CHAR = ','\n1 CHAR = '.'\n1 CHAR = '/'\n1 CHAR = '?'\n", | ||
| 413 | }, | ||
| 414 | ------------------------------------------------------------- | ||
| 415 | } | ||
| 416 | ------------------------------------------------------------------ | ||
| 417 | -- perform a test case | ||
| 418 | ------------------------------------------------------------------ | ||
| 419 | function do_test_case(count, test_case) | ||
| 420 | if comment == "" then return end -- skip empty entries | ||
| 421 | local comment, chunk, outcome, matcher = unpack(test_case) | ||
| 422 | local result = PASS | ||
| 423 | local output = "" | ||
| 424 | -- initialize lexer | ||
| 425 | local z = zio_init(chunk) | ||
| 426 | local luaX = lex_init(z, "=test") | ||
| 427 | -- lexer test loop | ||
| 428 | local status, token, seminfo | ||
| 429 | repeat | ||
| 430 | -- protected call | ||
| 431 | status, token, seminfo = pcall(luaX.lex, luaX) | ||
| 432 | output = output..luaX.ln.." " | ||
| 433 | if status then | ||
| 434 | -- successful call | ||
| 435 | if string.len(token) > 1 then | ||
| 436 | if token == "<name>" | ||
| 437 | or token == "<number>" | ||
| 438 | or token == "<string>" then | ||
| 439 | token = token.." = "..seminfo | ||
| 440 | end | ||
| 441 | elseif string.byte(token) >= 32 then -- displayable chars | ||
| 442 | token = "CHAR = '"..token.."'" | ||
| 443 | else -- control characters | ||
| 444 | token = "CHAR = (".. string.byte(token)..")" | ||
| 445 | end | ||
| 446 | output = output..token.."\n" | ||
| 447 | else | ||
| 448 | -- failed call | ||
| 449 | output = output..token -- token is the error message | ||
| 450 | result = FAIL | ||
| 451 | break | ||
| 452 | end | ||
| 453 | until token == "<eof>" | ||
| 454 | -- decision making and reporting | ||
| 455 | local head = "Test "..count..": "..comment | ||
| 456 | if matcher == "" then | ||
| 457 | -- nothing to check against, display for manual check | ||
| 458 | print(head.."\nMANUAL please check manually".. | ||
| 459 | "\n--chunk---------------------------------\n"..chunk.. | ||
| 460 | "\n--actual--------------------------------\n"..output.. | ||
| 461 | "\n\n") | ||
| 462 | return | ||
| 463 | else | ||
| 464 | if outcome == PASS then | ||
| 465 | -- success expected, may be a partial match | ||
| 466 | if string.find(output, matcher, 1, 1) and result == PASS then | ||
| 467 | if not BRIEF then print(head.."\nOK expected success\n") end | ||
| 468 | return | ||
| 469 | end | ||
| 470 | else | ||
| 471 | -- failure expected, may be a partial match | ||
| 472 | if string.find(output, matcher, 1, 1) and result == FAIL then | ||
| 473 | if not BRIEF then print(head.."\nOK expected failure\n") end | ||
| 474 | return | ||
| 475 | end | ||
| 476 | end | ||
| 477 | -- failed because of unmatched string or boolean result | ||
| 478 | local function passfail(status) | ||
| 479 | if status == PASS then return "PASS" else return "FAIL" end | ||
| 480 | end | ||
| 481 | print(head.." *FAILED*".. | ||
| 482 | "\noutcome="..passfail(outcome).. | ||
| 483 | "\nactual= "..passfail(result).. | ||
| 484 | "\n--chunk---------------------------------\n"..chunk.. | ||
| 485 | "\n--expected------------------------------\n"..matcher.. | ||
| 486 | "\n--actual--------------------------------\n"..output.. | ||
| 487 | "\n\n") | ||
| 488 | end | ||
| 489 | end | ||
| 490 | ------------------------------------------------------------------ | ||
| 491 | -- perform auto testing | ||
| 492 | ------------------------------------------------------------------ | ||
| 493 | for i,test_case in ipairs(test_cases) do | ||
| 494 | do_test_case(i, test_case) | ||
| 495 | end | ||
| 496 | end | ||
| 497 | |||
| 498 | auto_test() | ||
| 499 | --]] | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lparser_mk3.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lparser_mk3.lua deleted file mode 100644 index 662c826..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lparser_mk3.lua +++ /dev/null | |||
| @@ -1,218 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | test_lparser_mk3.lua | ||
| 4 | Test for lparser_mk3.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 | |||
| 19 | local lex_init = require("../llex_mk3") | ||
| 20 | local parser_init = require("../lparser_mk3") | ||
| 21 | |||
| 22 | ------------------------------------------------------------------------ | ||
| 23 | -- dump contents of log table | ||
| 24 | ------------------------------------------------------------------------ | ||
| 25 | |||
| 26 | local function dump_log(fs) | ||
| 27 | local log = fs.log | ||
| 28 | for i = 1, table.getn(log) do | ||
| 29 | print(log[i]) | ||
| 30 | end | ||
| 31 | end | ||
| 32 | |||
| 33 | ------------------------------------------------------------------------ | ||
| 34 | -- try 1 | ||
| 35 | ------------------------------------------------------------------------ | ||
| 36 | |||
| 37 | local luaX = lex_init("local a = 1", "=string") | ||
| 38 | local luaY = parser_init(luaX) | ||
| 39 | |||
| 40 | -- nothing is returned, so hope there is an error if problem occurs | ||
| 41 | local fs = luaY:parser() | ||
| 42 | --dump_log(fs) | ||
| 43 | |||
| 44 | ------------------------------------------------------------------------ | ||
| 45 | -- try 2 | ||
| 46 | ------------------------------------------------------------------------ | ||
| 47 | |||
| 48 | -- llex_mk3.lua cannot load files by itself | ||
| 49 | local INF = io.open("sample.lua", "rb") | ||
| 50 | if not INF then error("failed to load test file") end | ||
| 51 | local sample = INF:read("*a") | ||
| 52 | INF:close() | ||
| 53 | |||
| 54 | luaX = lex_init(sample, "@sample.lua") | ||
| 55 | luaY = parser_init(luaX) | ||
| 56 | |||
| 57 | -- nothing is returned, so hope there is an error if problem occurs | ||
| 58 | local fs = luaY:parser() | ||
| 59 | --dump_log(fs) | ||
| 60 | |||
| 61 | ------------------------------------------------------------------------ | ||
| 62 | -- automatic dumper of output log data | ||
| 63 | ------------------------------------------------------------------------ | ||
| 64 | |||
| 65 | local test_case = { | ||
| 66 | -- 1 | ||
| 67 | [[ | ||
| 68 | ]], | ||
| 69 | -- 2 | ||
| 70 | [[ | ||
| 71 | -- foobar | ||
| 72 | ]], | ||
| 73 | -- 3 | ||
| 74 | [[ | ||
| 75 | do | ||
| 76 | end | ||
| 77 | ]], | ||
| 78 | -- 4 | ||
| 79 | [[ | ||
| 80 | do end | ||
| 81 | do end | ||
| 82 | ]], | ||
| 83 | -- 5 | ||
| 84 | [[ | ||
| 85 | foo() | ||
| 86 | foo{} | ||
| 87 | foo"" | ||
| 88 | foo:bar() | ||
| 89 | foo=false | ||
| 90 | foo.bar=true | ||
| 91 | foo[true]=nil | ||
| 92 | foo,bar=1,"a" | ||
| 93 | ]], | ||
| 94 | -- 6 | ||
| 95 | [[ | ||
| 96 | foo=true | ||
| 97 | foo=false | ||
| 98 | foo=nil | ||
| 99 | foo=1.23e45 | ||
| 100 | foo=-1 | ||
| 101 | foo=(0) | ||
| 102 | foo=1+2 | ||
| 103 | foo=1+2*3-4/5 | ||
| 104 | ]], | ||
| 105 | -- 7 | ||
| 106 | [[ | ||
| 107 | if foo then foo=1 end | ||
| 108 | if foo then foo=1 else foo=0 end | ||
| 109 | if foo then foo=1 elseif not foo then foo=0 end | ||
| 110 | ]], | ||
| 111 | -- 8 | ||
| 112 | [[ | ||
| 113 | do return end | ||
| 114 | do return 123 end | ||
| 115 | do return "foo","bar" end | ||
| 116 | ]], | ||
| 117 | -- 9 | ||
| 118 | [[ | ||
| 119 | while true do foo=not foo end | ||
| 120 | while foo~=42 do foo=foo-1 end | ||
| 121 | while true do break end | ||
| 122 | ]], | ||
| 123 | -- 10 | ||
| 124 | [[ | ||
| 125 | repeat foo=foo.."bar" until false | ||
| 126 | repeat foo=foo/2 until foo<1 | ||
| 127 | repeat break until false | ||
| 128 | ]], | ||
| 129 | -- 11 | ||
| 130 | [[ | ||
| 131 | for i=1,10 do foo=i end | ||
| 132 | for i=1,10,2 do break end | ||
| 133 | for i in foo do bar=0 end | ||
| 134 | for i,j in foo,bar do baz=0 end | ||
| 135 | ]], | ||
| 136 | -- 12 | ||
| 137 | [[ | ||
| 138 | local foo | ||
| 139 | local foo,bar,baz | ||
| 140 | local foo,bar="foo","bar" | ||
| 141 | ]], | ||
| 142 | -- 13 | ||
| 143 | [[ | ||
| 144 | local function foo() return end | ||
| 145 | local function foo(a) return end | ||
| 146 | local function foo(x,y,z) return end | ||
| 147 | local function foo(x,...) return end | ||
| 148 | ]], | ||
| 149 | -- 14 | ||
| 150 | [[ | ||
| 151 | function foo() return end | ||
| 152 | function foo(a) return end | ||
| 153 | function foo(x,y,z) return end | ||
| 154 | function foo(x,...) return end | ||
| 155 | ]], | ||
| 156 | -- 15 | ||
| 157 | [[ | ||
| 158 | function foo.bar(p) return end | ||
| 159 | function foo.bar.baz(p) return end | ||
| 160 | function foo:bar(p) return end | ||
| 161 | function foo.bar.baz(p) return end | ||
| 162 | ]], | ||
| 163 | -- 16 | ||
| 164 | [[ | ||
| 165 | foo = function() return end | ||
| 166 | foo = function(x,y) return end | ||
| 167 | foo = function(...) return end | ||
| 168 | ]], | ||
| 169 | -- 17 | ||
| 170 | [[ | ||
| 171 | foo = {} | ||
| 172 | foo = { 1,2,3; "foo"; } | ||
| 173 | foo = { bar=77, baz=88, } | ||
| 174 | foo = { ["bar"]=77, ["baz"]=88, } | ||
| 175 | ]], | ||
| 176 | } | ||
| 177 | |||
| 178 | -- helps to skip old stuff during development of snippets | ||
| 179 | local do_beg, do_end = 1, table.getn(test_case) | ||
| 180 | |||
| 181 | -- loop for all example snippets | ||
| 182 | for i = do_beg, do_end do | ||
| 183 | local fname = "parser_log/sample_"..string.format("%02d", i)..".lua" | ||
| 184 | local src = test_case[i] | ||
| 185 | local OUTF = io.open(fname, "wb") | ||
| 186 | if not OUTF then error("failed to write to file '"..fname.."'") end | ||
| 187 | -- write out actual source for comparison | ||
| 188 | OUTF:write( | ||
| 189 | "-- START OF SOURCE --\n".. | ||
| 190 | src.. | ||
| 191 | "-- END OF SOURCE --\n".. | ||
| 192 | "\n" | ||
| 193 | ) | ||
| 194 | -- attempt to parse | ||
| 195 | local luaX = lex_init(src, "=string") | ||
| 196 | local luaY = parser_init(luaX) | ||
| 197 | local fs = luaY:parser() | ||
| 198 | -- grab logged messages and write | ||
| 199 | local log = fs.log | ||
| 200 | local indent = 0 | ||
| 201 | for i = 1, table.getn(log) do | ||
| 202 | local ln = log[i] | ||
| 203 | -- handle indentation | ||
| 204 | local tag = string.sub(ln, 1, 2) | ||
| 205 | if tag == ">>" or tag == "<<" then | ||
| 206 | ln = string.sub(ln, 4) | ||
| 207 | end | ||
| 208 | if tag == ">>" then | ||
| 209 | indent = indent + 1 | ||
| 210 | end | ||
| 211 | OUTF:write(string.rep(" ", indent)..ln.."\n") | ||
| 212 | if tag == "<<" then | ||
| 213 | indent = indent - 1 | ||
| 214 | end | ||
| 215 | end | ||
| 216 | -- we're done | ||
| 217 | OUTF:close() | ||
| 218 | end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lparser_mk3_2.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lparser_mk3_2.lua deleted file mode 100644 index 957ee22..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lparser_mk3_2.lua +++ /dev/null | |||
| @@ -1,158 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | test_lparser_mk3_2.lua | ||
| 4 | Test for lparser_mk3.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.0.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.0.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 | ||
| 24 | local DEBUG_FAILS = false | ||
| 25 | |||
| 26 | ------------------------------------------------------------------------ | ||
| 27 | -- test the whole kaboodle | ||
| 28 | ------------------------------------------------------------------------ | ||
| 29 | |||
| 30 | local lex_init = require("../llex_mk3") | ||
| 31 | local parser_init = require("../lparser_mk3") | ||
| 32 | |||
| 33 | ------------------------------------------------------------------------ | ||
| 34 | -- load test cases | ||
| 35 | ------------------------------------------------------------------------ | ||
| 36 | |||
| 37 | require("../../test_lua/test_parser-5.0") | ||
| 38 | |||
| 39 | local test, expect, heading = {}, {}, {} | ||
| 40 | local total, total_pass, total_fail = 0, 0, 0 | ||
| 41 | |||
| 42 | for ln in string.gfind(tests_source, "([^\n]*)\n") do | ||
| 43 | if string.find(ln, "^%s*%-%-") then | ||
| 44 | -- comment, ignore | ||
| 45 | else | ||
| 46 | local m, _, head = string.find(ln, "^%s*(TESTS:%s*.*)$") | ||
| 47 | if m then | ||
| 48 | heading[total + 1] = head -- informational heading | ||
| 49 | else | ||
| 50 | total = total + 1 | ||
| 51 | local n, _, flag = string.find(ln, "%s*%-%-%s*FAIL%s*$") | ||
| 52 | if n then -- FAIL test case | ||
| 53 | ln = string.sub(ln, 1, n - 1) -- remove comment | ||
| 54 | expect[total] = "FAIL" | ||
| 55 | total_fail = total_fail + 1 | ||
| 56 | else -- PASS test case | ||
| 57 | expect[total] = "PASS" | ||
| 58 | total_pass = total_pass + 1 | ||
| 59 | end--n | ||
| 60 | test[total] = ln | ||
| 61 | end--m | ||
| 62 | end--ln | ||
| 63 | end--for | ||
| 64 | |||
| 65 | print("Tests loaded: "..total.." (total), " | ||
| 66 | ..total_pass.." (passes), " | ||
| 67 | ..total_fail.." (fails)") | ||
| 68 | |||
| 69 | ------------------------------------------------------------------------ | ||
| 70 | -- verify test cases using native Lua | ||
| 71 | ------------------------------------------------------------------------ | ||
| 72 | |||
| 73 | local last_head = "TESTS: no heading yet" | ||
| 74 | for i = 1, total do | ||
| 75 | local test_case, expected, head = test[i], expect[i], heading[i] | ||
| 76 | -- show progress | ||
| 77 | if head then | ||
| 78 | last_head = head | ||
| 79 | if DEBUG_FAILS then print("\n"..head.."\n") end | ||
| 80 | end | ||
| 81 | ------------------------------------------------------------------ | ||
| 82 | -- perform test | ||
| 83 | local f, err = loadstring(test_case) | ||
| 84 | -- look at outcome | ||
| 85 | ------------------------------------------------------------------ | ||
| 86 | if f then-- actual PASS | ||
| 87 | if expected == "FAIL" then | ||
| 88 | print("\nVerified as PASS but expected to FAIL".. | ||
| 89 | "\n-------------------------------------") | ||
| 90 | print("Lastest heading: "..last_head) | ||
| 91 | print("TEST: "..test_case) | ||
| 92 | os.exit() | ||
| 93 | end | ||
| 94 | ------------------------------------------------------------------ | ||
| 95 | else-- actual FAIL | ||
| 96 | if expected == "PASS" then | ||
| 97 | print("\nVerified as FAIL but expected to PASS".. | ||
| 98 | "\n-------------------------------------") | ||
| 99 | print("Lastest heading: "..last_head) | ||
| 100 | print("TEST: "..test_case) | ||
| 101 | print("ERROR: "..err) | ||
| 102 | os.exit() | ||
| 103 | end | ||
| 104 | if DEBUG_FAILS then | ||
| 105 | print("TEST: "..test_case) | ||
| 106 | print("ERROR: "..err.."\n") | ||
| 107 | end | ||
| 108 | ------------------------------------------------------------------ | ||
| 109 | end--f | ||
| 110 | end--for | ||
| 111 | |||
| 112 | print("Test cases verified using native Lua, no anomalies.") | ||
| 113 | |||
| 114 | ------------------------------------------------------------------------ | ||
| 115 | -- test using Yueliang front end | ||
| 116 | ------------------------------------------------------------------------ | ||
| 117 | |||
| 118 | local last_head = "TESTS: no heading yet" | ||
| 119 | for i = 1, total do | ||
| 120 | local test_case, expected, head = test[i], expect[i], heading[i] | ||
| 121 | -- show progress | ||
| 122 | if head then last_head = head end | ||
| 123 | ------------------------------------------------------------------ | ||
| 124 | -- perform test | ||
| 125 | luaX = lex_init(test_case, "=test_sample") | ||
| 126 | luaY = parser_init(luaX) | ||
| 127 | |||
| 128 | local status, func = pcall(luaY.parser, luaY) | ||
| 129 | -- look at outcome | ||
| 130 | ------------------------------------------------------------------ | ||
| 131 | if status then-- actual PASS | ||
| 132 | if expected == "FAIL" then | ||
| 133 | print("\nTested as PASS but expected to FAIL".. | ||
| 134 | "\n-----------------------------------") | ||
| 135 | print("Lastest heading: "..last_head) | ||
| 136 | print("TEST: "..test_case) | ||
| 137 | os.exit() | ||
| 138 | end | ||
| 139 | ------------------------------------------------------------------ | ||
| 140 | else-- actual FAIL | ||
| 141 | if expected == "PASS" then | ||
| 142 | print("\nTested as FAIL but expected to PASS".. | ||
| 143 | "\n-----------------------------------") | ||
| 144 | print("Lastest heading: "..last_head) | ||
| 145 | print("TEST: "..test_case) | ||
| 146 | os.exit() | ||
| 147 | else | ||
| 148 | io.stdout:write("-") | ||
| 149 | end | ||
| 150 | ------------------------------------------------------------------ | ||
| 151 | end--status | ||
| 152 | io.stdout:write("\rTesting ["..i.."]...") | ||
| 153 | end--for | ||
| 154 | print(" done.") | ||
| 155 | |||
| 156 | print("Test cases run on Yueliang, no anomalies.") | ||
| 157 | |||
| 158 | -- end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lparser_mk3b.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lparser_mk3b.lua deleted file mode 100644 index d8dc33d..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lparser_mk3b.lua +++ /dev/null | |||
| @@ -1,188 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | test_lparser_mk3b.lua | ||
| 4 | Test for lparser_mk3b.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 | |||
| 19 | local lex_init = require("../llex_mk3") | ||
| 20 | local parser_init = require("../lparser_mk3b") | ||
| 21 | |||
| 22 | ------------------------------------------------------------------------ | ||
| 23 | -- dump contents of log table | ||
| 24 | ------------------------------------------------------------------------ | ||
| 25 | |||
| 26 | local function dump_log(fs) | ||
| 27 | local log = fs.log | ||
| 28 | for i = 1, table.getn(log) do | ||
| 29 | print(log[i]) | ||
| 30 | end | ||
| 31 | end | ||
| 32 | |||
| 33 | ------------------------------------------------------------------------ | ||
| 34 | -- automatic dumper of output log data | ||
| 35 | ------------------------------------------------------------------------ | ||
| 36 | |||
| 37 | local test_case = { | ||
| 38 | -- 1 | ||
| 39 | [[ | ||
| 40 | print(a) | ||
| 41 | ]], | ||
| 42 | -- 2 | ||
| 43 | [[ | ||
| 44 | local a | ||
| 45 | print(a) | ||
| 46 | ]], | ||
| 47 | -- 3 | ||
| 48 | [[ | ||
| 49 | do | ||
| 50 | local a | ||
| 51 | print(a) | ||
| 52 | end | ||
| 53 | print(a) | ||
| 54 | ]], | ||
| 55 | -- 4 | ||
| 56 | [[ | ||
| 57 | local a,b,c | ||
| 58 | do | ||
| 59 | local b | ||
| 60 | print(b) | ||
| 61 | end | ||
| 62 | print(b) | ||
| 63 | ]], | ||
| 64 | -- 5 | ||
| 65 | [[ | ||
| 66 | local function foo() end | ||
| 67 | bar = foo | ||
| 68 | ]], | ||
| 69 | -- 6 | ||
| 70 | [[ | ||
| 71 | do | ||
| 72 | local function foo() end | ||
| 73 | bar = foo | ||
| 74 | end | ||
| 75 | baz = foo | ||
| 76 | ]], | ||
| 77 | -- 7 | ||
| 78 | [[ | ||
| 79 | local foo | ||
| 80 | local function bar() | ||
| 81 | baz = nil | ||
| 82 | foo = bar() | ||
| 83 | end | ||
| 84 | foo = bar | ||
| 85 | ]], | ||
| 86 | -- 8 | ||
| 87 | [[ | ||
| 88 | local foo | ||
| 89 | local function bar() | ||
| 90 | local function baz() | ||
| 91 | local foo, bar | ||
| 92 | foo = bar | ||
| 93 | foo = baz | ||
| 94 | end | ||
| 95 | foo = bar | ||
| 96 | foo = baz | ||
| 97 | end | ||
| 98 | foo = bar | ||
| 99 | foo = baz | ||
| 100 | ]], | ||
| 101 | -- 9 | ||
| 102 | [[ | ||
| 103 | function foo:bar() | ||
| 104 | print(self) | ||
| 105 | end | ||
| 106 | ]], | ||
| 107 | -- 10 | ||
| 108 | [[ | ||
| 109 | function foo(...) | ||
| 110 | print(arg) | ||
| 111 | end | ||
| 112 | ]], | ||
| 113 | -- 11 | ||
| 114 | [[ | ||
| 115 | local c,d | ||
| 116 | function foo(a,b,c) | ||
| 117 | print(a,c,d,e) | ||
| 118 | end | ||
| 119 | ]], | ||
| 120 | -- 11 | ||
| 121 | [[ | ||
| 122 | function foo(a,b) | ||
| 123 | local bar = function(c,d) | ||
| 124 | print(a,b,c,d) | ||
| 125 | end | ||
| 126 | end | ||
| 127 | ]], | ||
| 128 | -- 12 | ||
| 129 | [[ | ||
| 130 | for i = 1,10 do | ||
| 131 | print(i) | ||
| 132 | end | ||
| 133 | for i = 1,10,-2 do | ||
| 134 | print(i) | ||
| 135 | end | ||
| 136 | ]], | ||
| 137 | -- 13 | ||
| 138 | [[ | ||
| 139 | for foo in bar() do | ||
| 140 | print(foo) | ||
| 141 | end | ||
| 142 | for foo,bar,baz in spring() do | ||
| 143 | print(foo,bar,baz) | ||
| 144 | end | ||
| 145 | ]], | ||
| 146 | } | ||
| 147 | |||
| 148 | -- helps to skip old stuff during development of snippets | ||
| 149 | local do_beg, do_end = 1, table.getn(test_case) | ||
| 150 | |||
| 151 | -- loop for all example snippets | ||
| 152 | for i = do_beg, do_end do | ||
| 153 | local fname = "parser_log/sample_b_"..string.format("%02d", i)..".lua" | ||
| 154 | local src = test_case[i] | ||
| 155 | local OUTF = io.open(fname, "wb") | ||
| 156 | if not OUTF then error("failed to write to file '"..fname.."'") end | ||
| 157 | -- write out actual source for comparison | ||
| 158 | OUTF:write( | ||
| 159 | "-- START OF SOURCE --\n".. | ||
| 160 | src.. | ||
| 161 | "-- END OF SOURCE --\n".. | ||
| 162 | "\n" | ||
| 163 | ) | ||
| 164 | -- attempt to parse | ||
| 165 | local luaX = lex_init(src, "=string") | ||
| 166 | local luaY = parser_init(luaX) | ||
| 167 | local fs = luaY:parser() | ||
| 168 | -- grab logged messages and write | ||
| 169 | local log = fs.log | ||
| 170 | local indent = 0 | ||
| 171 | for i = 1, table.getn(log) do | ||
| 172 | local ln = log[i] | ||
| 173 | -- handle indentation | ||
| 174 | local tag = string.sub(ln, 1, 2) | ||
| 175 | if tag == ">>" or tag == "<<" then | ||
| 176 | ln = string.sub(ln, 4) | ||
| 177 | end | ||
| 178 | if tag == ">>" then | ||
| 179 | indent = indent + 1 | ||
| 180 | end | ||
| 181 | OUTF:write(string.rep(" ", indent)..ln.."\n") | ||
| 182 | if tag == "<<" then | ||
| 183 | indent = indent - 1 | ||
| 184 | end | ||
| 185 | end | ||
| 186 | -- we're done | ||
| 187 | OUTF:close() | ||
| 188 | end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lparser_mk3b_2.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lparser_mk3b_2.lua deleted file mode 100644 index 4d4e8c5..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lparser_mk3b_2.lua +++ /dev/null | |||
| @@ -1,158 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | test_lparser_mk3b_2.lua | ||
| 4 | Test for lparser_mk3b.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.0.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.0.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 | ||
| 24 | local DEBUG_FAILS = false | ||
| 25 | |||
| 26 | ------------------------------------------------------------------------ | ||
| 27 | -- test the whole kaboodle | ||
| 28 | ------------------------------------------------------------------------ | ||
| 29 | |||
| 30 | local lex_init = require("../llex_mk3") | ||
| 31 | local parser_init = require("../lparser_mk3b") | ||
| 32 | |||
| 33 | ------------------------------------------------------------------------ | ||
| 34 | -- load test cases | ||
| 35 | ------------------------------------------------------------------------ | ||
| 36 | |||
| 37 | require("../../test_lua/test_parser-5.0") | ||
| 38 | |||
| 39 | local test, expect, heading = {}, {}, {} | ||
| 40 | local total, total_pass, total_fail = 0, 0, 0 | ||
| 41 | |||
| 42 | for ln in string.gfind(tests_source, "([^\n]*)\n") do | ||
| 43 | if string.find(ln, "^%s*%-%-") then | ||
| 44 | -- comment, ignore | ||
| 45 | else | ||
| 46 | local m, _, head = string.find(ln, "^%s*(TESTS:%s*.*)$") | ||
| 47 | if m then | ||
| 48 | heading[total + 1] = head -- informational heading | ||
| 49 | else | ||
| 50 | total = total + 1 | ||
| 51 | local n, _, flag = string.find(ln, "%s*%-%-%s*FAIL%s*$") | ||
| 52 | if n then -- FAIL test case | ||
| 53 | ln = string.sub(ln, 1, n - 1) -- remove comment | ||
| 54 | expect[total] = "FAIL" | ||
| 55 | total_fail = total_fail + 1 | ||
| 56 | else -- PASS test case | ||
| 57 | expect[total] = "PASS" | ||
| 58 | total_pass = total_pass + 1 | ||
| 59 | end--n | ||
| 60 | test[total] = ln | ||
| 61 | end--m | ||
| 62 | end--ln | ||
| 63 | end--for | ||
| 64 | |||
| 65 | print("Tests loaded: "..total.." (total), " | ||
| 66 | ..total_pass.." (passes), " | ||
| 67 | ..total_fail.." (fails)") | ||
| 68 | |||
| 69 | ------------------------------------------------------------------------ | ||
| 70 | -- verify test cases using native Lua | ||
| 71 | ------------------------------------------------------------------------ | ||
| 72 | |||
| 73 | local last_head = "TESTS: no heading yet" | ||
| 74 | for i = 1, total do | ||
| 75 | local test_case, expected, head = test[i], expect[i], heading[i] | ||
| 76 | -- show progress | ||
| 77 | if head then | ||
| 78 | last_head = head | ||
| 79 | if DEBUG_FAILS then print("\n"..head.."\n") end | ||
| 80 | end | ||
| 81 | ------------------------------------------------------------------ | ||
| 82 | -- perform test | ||
| 83 | local f, err = loadstring(test_case) | ||
| 84 | -- look at outcome | ||
| 85 | ------------------------------------------------------------------ | ||
| 86 | if f then-- actual PASS | ||
| 87 | if expected == "FAIL" then | ||
| 88 | print("\nVerified as PASS but expected to FAIL".. | ||
| 89 | "\n-------------------------------------") | ||
| 90 | print("Lastest heading: "..last_head) | ||
| 91 | print("TEST: "..test_case) | ||
| 92 | os.exit() | ||
| 93 | end | ||
| 94 | ------------------------------------------------------------------ | ||
| 95 | else-- actual FAIL | ||
| 96 | if expected == "PASS" then | ||
| 97 | print("\nVerified as FAIL but expected to PASS".. | ||
| 98 | "\n-------------------------------------") | ||
| 99 | print("Lastest heading: "..last_head) | ||
| 100 | print("TEST: "..test_case) | ||
| 101 | print("ERROR: "..err) | ||
| 102 | os.exit() | ||
| 103 | end | ||
| 104 | if DEBUG_FAILS then | ||
| 105 | print("TEST: "..test_case) | ||
| 106 | print("ERROR: "..err.."\n") | ||
| 107 | end | ||
| 108 | ------------------------------------------------------------------ | ||
| 109 | end--f | ||
| 110 | end--for | ||
| 111 | |||
| 112 | print("Test cases verified using native Lua, no anomalies.") | ||
| 113 | |||
| 114 | ------------------------------------------------------------------------ | ||
| 115 | -- test using Yueliang front end | ||
| 116 | ------------------------------------------------------------------------ | ||
| 117 | |||
| 118 | local last_head = "TESTS: no heading yet" | ||
| 119 | for i = 1, total do | ||
| 120 | local test_case, expected, head = test[i], expect[i], heading[i] | ||
| 121 | -- show progress | ||
| 122 | if head then last_head = head end | ||
| 123 | ------------------------------------------------------------------ | ||
| 124 | -- perform test | ||
| 125 | luaX = lex_init(test_case, "=test_sample") | ||
| 126 | luaY = parser_init(luaX) | ||
| 127 | |||
| 128 | local status, func = pcall(luaY.parser, luaY) | ||
| 129 | -- look at outcome | ||
| 130 | ------------------------------------------------------------------ | ||
| 131 | if status then-- actual PASS | ||
| 132 | if expected == "FAIL" then | ||
| 133 | print("\nTested as PASS but expected to FAIL".. | ||
| 134 | "\n-----------------------------------") | ||
| 135 | print("Lastest heading: "..last_head) | ||
| 136 | print("TEST: "..test_case) | ||
| 137 | os.exit() | ||
| 138 | end | ||
| 139 | ------------------------------------------------------------------ | ||
| 140 | else-- actual FAIL | ||
| 141 | if expected == "PASS" then | ||
| 142 | print("\nTested as FAIL but expected to PASS".. | ||
| 143 | "\n-----------------------------------") | ||
| 144 | print("Lastest heading: "..last_head) | ||
| 145 | print("TEST: "..test_case) | ||
| 146 | os.exit() | ||
| 147 | else | ||
| 148 | io.stdout:write("-") | ||
| 149 | end | ||
| 150 | ------------------------------------------------------------------ | ||
| 151 | end--status | ||
| 152 | io.stdout:write("\rTesting ["..i.."]...") | ||
| 153 | end--for | ||
| 154 | print(" done.") | ||
| 155 | |||
| 156 | print("Test cases run on Yueliang, no anomalies.") | ||
| 157 | |||
| 158 | -- end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lzio_mk2.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lzio_mk2.lua deleted file mode 100644 index 30259c8..0000000 --- a/LuaSL/testLua/yueliang-0.4.1/nat-5.0.3/test/test_lzio_mk2.lua +++ /dev/null | |||
| @@ -1,53 +0,0 @@ | |||
| 1 | --[[-------------------------------------------------------------------- | ||
| 2 | |||
| 3 | test_lzio.lua | ||
| 4 | Test for lzio.lua | ||
| 5 | This file is part of Yueliang. | ||
| 6 | |||
| 7 | Copyright (c) 2005-2006 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 | -- manual test for lzio.lua lua-style chunk reader | ||
| 16 | |||
| 17 | local zio_init = require("../lzio_mk2") | ||
| 18 | |||
| 19 | local z | ||
| 20 | function dump(z) | ||
| 21 | while true do | ||
| 22 | local c = z:getc() | ||
| 23 | io.stdout:write("("..c..")") | ||
| 24 | if c == "EOZ" then break end | ||
| 25 | end | ||
| 26 | io.stdout:write("\n") | ||
| 27 | end | ||
| 28 | |||
| 29 | -- z = zio_init("@<filename>") for a file | ||
| 30 | -- z = zio_init("<string>") for a string | ||
| 31 | |||
| 32 | -- [[ | ||
| 33 | z = zio_init("hello, world!") | ||
| 34 | dump(z) | ||
| 35 | z = zio_init("line1\nline2\n") | ||
| 36 | dump(z) | ||
| 37 | z = zio_init("@test_lzio_mk2.lua") | ||
| 38 | dump(z) | ||
| 39 | --]] | ||
| 40 | |||
| 41 | -- test read beyond end of file | ||
| 42 | -- bug reported by Adam429 | ||
| 43 | --[[ | ||
| 44 | z = zio_init("@test_lzio_mk2.lua") | ||
| 45 | while true do | ||
| 46 | local c = z:getc() | ||
| 47 | io.stdout:write("("..c..")") | ||
| 48 | if c == "EOZ" then break end | ||
| 49 | end | ||
| 50 | print(z:getc()) | ||
| 51 | print(z:getc()) | ||
| 52 | io.stdout:write("\n") | ||
| 53 | --]] | ||