diff options
author | David Walter Seikel | 2012-01-23 21:58:02 +1000 |
---|---|---|
committer | David Walter Seikel | 2012-01-23 21:58:02 +1000 |
commit | 2d1df4714e2736dbde7855ddcd76b4c1de822fa5 (patch) | |
tree | c80e4622631c92dbe8dd6375d187702d084c2f2b /LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log | |
parent | Remove the conflict, and the comment. lol (diff) | |
download | SledjHamr-2d1df4714e2736dbde7855ddcd76b4c1de822fa5.zip SledjHamr-2d1df4714e2736dbde7855ddcd76b4c1de822fa5.tar.gz SledjHamr-2d1df4714e2736dbde7855ddcd76b4c1de822fa5.tar.bz2 SledjHamr-2d1df4714e2736dbde7855ddcd76b4c1de822fa5.tar.xz |
Added a big bunch of example lua scripts for testing the speed of lua compiling.
Diffstat (limited to 'LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log')
31 files changed, 2668 insertions, 0 deletions
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_01.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_01.lua new file mode 100644 index 0000000..379cc9d --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_01.lua | |||
@@ -0,0 +1,9 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | -- END OF SOURCE -- | ||
3 | |||
4 | -- TOP: begin | ||
5 | open_func | ||
6 | |||
7 | chunk: | ||
8 | close_func | ||
9 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_02.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_02.lua new file mode 100644 index 0000000..13eb2e6 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_02.lua | |||
@@ -0,0 +1,10 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | -- foobar | ||
3 | -- END OF SOURCE -- | ||
4 | |||
5 | -- TOP: begin | ||
6 | open_func | ||
7 | |||
8 | chunk: | ||
9 | close_func | ||
10 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_03.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_03.lua new file mode 100644 index 0000000..33df29c --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_03.lua | |||
@@ -0,0 +1,21 @@ | |||
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.1.3/test/parser_log/sample_04.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_04.lua new file mode 100644 index 0000000..d0fefbc --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_04.lua | |||
@@ -0,0 +1,31 @@ | |||
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.1.3/test/parser_log/sample_05.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_05.lua new file mode 100644 index 0000000..17a9231 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_05.lua | |||
@@ -0,0 +1,129 @@ | |||
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(kind): 'VGLOBAL' | ||
20 | primaryexp: ( funcargs | ||
21 | funcargs: begin '(' | ||
22 | funcargs: end -- expr is a VCALL | ||
23 | expr_stat: function call k='VCALL' | ||
24 | -- STATEMENT: end 'expr' | ||
25 | |||
26 | -- STATEMENT: begin 'expr' line=2 | ||
27 | prefixexp: <name> | ||
28 | str_checkname: 'foo' | ||
29 | singlevar(kind): 'VGLOBAL' | ||
30 | primaryexp: { funcargs | ||
31 | funcargs: begin '{' | ||
32 | constructor: begin | ||
33 | constructor: end | ||
34 | funcargs: end -- expr is a VCALL | ||
35 | expr_stat: function call k='VCALL' | ||
36 | -- STATEMENT: end 'expr' | ||
37 | |||
38 | -- STATEMENT: begin 'expr' line=3 | ||
39 | prefixexp: <name> | ||
40 | str_checkname: 'foo' | ||
41 | singlevar(kind): 'VGLOBAL' | ||
42 | primaryexp: <string> funcargs | ||
43 | funcargs: begin <string> | ||
44 | codestring: "" | ||
45 | funcargs: end -- expr is a VCALL | ||
46 | expr_stat: function call k='VCALL' | ||
47 | -- STATEMENT: end 'expr' | ||
48 | |||
49 | -- STATEMENT: begin 'expr' line=4 | ||
50 | prefixexp: <name> | ||
51 | str_checkname: 'foo' | ||
52 | singlevar(kind): 'VGLOBAL' | ||
53 | primaryexp: :<name> funcargs | ||
54 | checkname: | ||
55 | str_checkname: 'bar' | ||
56 | codestring: "bar" | ||
57 | funcargs: begin '(' | ||
58 | funcargs: end -- expr is a VCALL | ||
59 | expr_stat: function call k='VCALL' | ||
60 | -- STATEMENT: end 'expr' | ||
61 | |||
62 | -- STATEMENT: begin 'expr' line=5 | ||
63 | prefixexp: <name> | ||
64 | str_checkname: 'foo' | ||
65 | singlevar(kind): 'VGLOBAL' | ||
66 | expr_stat: assignment k='VGLOBAL' | ||
67 | assignment: '=' -- RHS elements follows | ||
68 | explist1: begin | ||
69 | expr: | ||
70 | simpleexp: false | ||
71 | explist1: end | ||
72 | -- STATEMENT: end 'expr' | ||
73 | |||
74 | -- STATEMENT: begin 'expr' line=6 | ||
75 | prefixexp: <name> | ||
76 | str_checkname: 'foo' | ||
77 | singlevar(kind): 'VGLOBAL' | ||
78 | primaryexp: '.' field | ||
79 | field: operator=. | ||
80 | checkname: | ||
81 | str_checkname: 'bar' | ||
82 | codestring: "bar" | ||
83 | expr_stat: assignment k='VINDEXED' | ||
84 | assignment: '=' -- RHS elements follows | ||
85 | explist1: begin | ||
86 | expr: | ||
87 | simpleexp: true | ||
88 | explist1: end | ||
89 | -- STATEMENT: end 'expr' | ||
90 | |||
91 | -- STATEMENT: begin 'expr' line=7 | ||
92 | prefixexp: <name> | ||
93 | str_checkname: 'foo' | ||
94 | singlevar(kind): 'VGLOBAL' | ||
95 | primaryexp: [ exp1 ] | ||
96 | index: begin '[' | ||
97 | expr: | ||
98 | simpleexp: true | ||
99 | index: end ']' | ||
100 | expr_stat: assignment k='VGLOBAL' | ||
101 | assignment: '=' -- RHS elements follows | ||
102 | explist1: begin | ||
103 | expr: | ||
104 | simpleexp: nil | ||
105 | explist1: end | ||
106 | -- STATEMENT: end 'expr' | ||
107 | |||
108 | -- STATEMENT: begin 'expr' line=8 | ||
109 | prefixexp: <name> | ||
110 | str_checkname: 'foo' | ||
111 | singlevar(kind): 'VGLOBAL' | ||
112 | expr_stat: assignment k='VGLOBAL' | ||
113 | assignment: ',' -- next LHS element | ||
114 | prefixexp: <name> | ||
115 | str_checkname: 'bar' | ||
116 | singlevar(kind): 'VGLOBAL' | ||
117 | assignment: '=' -- RHS elements follows | ||
118 | explist1: begin | ||
119 | expr: | ||
120 | simpleexp: <number>=1 | ||
121 | explist1: ',' -- continuation | ||
122 | expr: | ||
123 | simpleexp: <string>=a | ||
124 | codestring: "a" | ||
125 | explist1: end | ||
126 | -- STATEMENT: end 'expr' | ||
127 | |||
128 | close_func | ||
129 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_06.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_06.lua new file mode 100644 index 0000000..29f1703 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_06.lua | |||
@@ -0,0 +1,132 @@ | |||
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(kind): 'VGLOBAL' | ||
20 | expr_stat: assignment k='VGLOBAL' | ||
21 | assignment: '=' -- RHS elements follows | ||
22 | explist1: begin | ||
23 | expr: | ||
24 | simpleexp: true | ||
25 | explist1: end | ||
26 | -- STATEMENT: end 'expr' | ||
27 | |||
28 | -- STATEMENT: begin 'expr' line=2 | ||
29 | prefixexp: <name> | ||
30 | str_checkname: 'foo' | ||
31 | singlevar(kind): 'VGLOBAL' | ||
32 | expr_stat: assignment k='VGLOBAL' | ||
33 | assignment: '=' -- RHS elements follows | ||
34 | explist1: begin | ||
35 | expr: | ||
36 | simpleexp: false | ||
37 | explist1: end | ||
38 | -- STATEMENT: end 'expr' | ||
39 | |||
40 | -- STATEMENT: begin 'expr' line=3 | ||
41 | prefixexp: <name> | ||
42 | str_checkname: 'foo' | ||
43 | singlevar(kind): 'VGLOBAL' | ||
44 | expr_stat: assignment k='VGLOBAL' | ||
45 | assignment: '=' -- RHS elements follows | ||
46 | explist1: begin | ||
47 | expr: | ||
48 | simpleexp: nil | ||
49 | explist1: end | ||
50 | -- STATEMENT: end 'expr' | ||
51 | |||
52 | -- STATEMENT: begin 'expr' line=4 | ||
53 | prefixexp: <name> | ||
54 | str_checkname: 'foo' | ||
55 | singlevar(kind): 'VGLOBAL' | ||
56 | expr_stat: assignment k='VGLOBAL' | ||
57 | assignment: '=' -- RHS elements follows | ||
58 | explist1: begin | ||
59 | expr: | ||
60 | simpleexp: <number>=1.23e+45 | ||
61 | explist1: end | ||
62 | -- STATEMENT: end 'expr' | ||
63 | |||
64 | -- STATEMENT: begin 'expr' line=5 | ||
65 | prefixexp: <name> | ||
66 | str_checkname: 'foo' | ||
67 | singlevar(kind): 'VGLOBAL' | ||
68 | expr_stat: assignment k='VGLOBAL' | ||
69 | assignment: '=' -- RHS elements follows | ||
70 | explist1: begin | ||
71 | expr: | ||
72 | subexpr: uop='-' | ||
73 | simpleexp: <number>=1 | ||
74 | explist1: end | ||
75 | -- STATEMENT: end 'expr' | ||
76 | |||
77 | -- STATEMENT: begin 'expr' line=6 | ||
78 | prefixexp: <name> | ||
79 | str_checkname: 'foo' | ||
80 | singlevar(kind): 'VGLOBAL' | ||
81 | expr_stat: assignment k='VGLOBAL' | ||
82 | assignment: '=' -- RHS elements follows | ||
83 | explist1: begin | ||
84 | expr: | ||
85 | prefixexp: begin ( expr ) | ||
86 | expr: | ||
87 | simpleexp: <number>=0 | ||
88 | prefixexp: end ( expr ) | ||
89 | explist1: end | ||
90 | -- STATEMENT: end 'expr' | ||
91 | |||
92 | -- STATEMENT: begin 'expr' line=7 | ||
93 | prefixexp: <name> | ||
94 | str_checkname: 'foo' | ||
95 | singlevar(kind): 'VGLOBAL' | ||
96 | expr_stat: assignment k='VGLOBAL' | ||
97 | assignment: '=' -- RHS elements follows | ||
98 | explist1: begin | ||
99 | expr: | ||
100 | simpleexp: <number>=1 | ||
101 | subexpr: binop='+' | ||
102 | simpleexp: <number>=2 | ||
103 | subexpr: -- evaluate | ||
104 | explist1: end | ||
105 | -- STATEMENT: end 'expr' | ||
106 | |||
107 | -- STATEMENT: begin 'expr' line=8 | ||
108 | prefixexp: <name> | ||
109 | str_checkname: 'foo' | ||
110 | singlevar(kind): 'VGLOBAL' | ||
111 | expr_stat: assignment k='VGLOBAL' | ||
112 | assignment: '=' -- RHS elements follows | ||
113 | explist1: begin | ||
114 | expr: | ||
115 | simpleexp: <number>=1 | ||
116 | subexpr: binop='+' | ||
117 | simpleexp: <number>=2 | ||
118 | subexpr: binop='*' | ||
119 | simpleexp: <number>=3 | ||
120 | subexpr: -- evaluate | ||
121 | subexpr: -- evaluate | ||
122 | subexpr: binop='-' | ||
123 | simpleexp: <number>=4 | ||
124 | subexpr: binop='/' | ||
125 | simpleexp: <number>=5 | ||
126 | subexpr: -- evaluate | ||
127 | subexpr: -- evaluate | ||
128 | explist1: end | ||
129 | -- STATEMENT: end 'expr' | ||
130 | |||
131 | close_func | ||
132 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_07.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_07.lua new file mode 100644 index 0000000..c3a4600 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_07.lua | |||
@@ -0,0 +1,147 @@ | |||
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(kind): 'VGLOBAL' | ||
19 | cond: end | ||
20 | test_then_block: then block | ||
21 | block: begin | ||
22 | enterblock(isbreakable=false) | ||
23 | chunk: | ||
24 | -- STATEMENT: begin 'expr' line=1 | ||
25 | prefixexp: <name> | ||
26 | str_checkname: 'foo' | ||
27 | singlevar(kind): 'VGLOBAL' | ||
28 | expr_stat: assignment k='VGLOBAL' | ||
29 | assignment: '=' -- RHS elements follows | ||
30 | explist1: begin | ||
31 | expr: | ||
32 | simpleexp: <number>=1 | ||
33 | explist1: end | ||
34 | -- STATEMENT: end 'expr' | ||
35 | |||
36 | leaveblock | ||
37 | block: end | ||
38 | if_stat: end | ||
39 | -- STATEMENT: end 'if' | ||
40 | |||
41 | -- STATEMENT: begin 'if' line=2 | ||
42 | if_stat: if...then | ||
43 | test_then_block: test condition | ||
44 | cond: begin | ||
45 | expr: | ||
46 | prefixexp: <name> | ||
47 | str_checkname: 'foo' | ||
48 | singlevar(kind): 'VGLOBAL' | ||
49 | cond: end | ||
50 | test_then_block: then block | ||
51 | block: begin | ||
52 | enterblock(isbreakable=false) | ||
53 | chunk: | ||
54 | -- STATEMENT: begin 'expr' line=2 | ||
55 | prefixexp: <name> | ||
56 | str_checkname: 'foo' | ||
57 | singlevar(kind): 'VGLOBAL' | ||
58 | expr_stat: assignment k='VGLOBAL' | ||
59 | assignment: '=' -- RHS elements follows | ||
60 | explist1: begin | ||
61 | expr: | ||
62 | simpleexp: <number>=1 | ||
63 | explist1: end | ||
64 | -- STATEMENT: end 'expr' | ||
65 | |||
66 | leaveblock | ||
67 | block: end | ||
68 | if_stat: else... | ||
69 | block: begin | ||
70 | enterblock(isbreakable=false) | ||
71 | chunk: | ||
72 | -- STATEMENT: begin 'expr' line=2 | ||
73 | prefixexp: <name> | ||
74 | str_checkname: 'foo' | ||
75 | singlevar(kind): 'VGLOBAL' | ||
76 | expr_stat: assignment k='VGLOBAL' | ||
77 | assignment: '=' -- RHS elements follows | ||
78 | explist1: begin | ||
79 | expr: | ||
80 | simpleexp: <number>=0 | ||
81 | explist1: end | ||
82 | -- STATEMENT: end 'expr' | ||
83 | |||
84 | leaveblock | ||
85 | block: end | ||
86 | if_stat: end | ||
87 | -- STATEMENT: end 'if' | ||
88 | |||
89 | -- STATEMENT: begin 'if' line=3 | ||
90 | if_stat: if...then | ||
91 | test_then_block: test condition | ||
92 | cond: begin | ||
93 | expr: | ||
94 | prefixexp: <name> | ||
95 | str_checkname: 'foo' | ||
96 | singlevar(kind): 'VGLOBAL' | ||
97 | cond: end | ||
98 | test_then_block: then block | ||
99 | block: begin | ||
100 | enterblock(isbreakable=false) | ||
101 | chunk: | ||
102 | -- STATEMENT: begin 'expr' line=3 | ||
103 | prefixexp: <name> | ||
104 | str_checkname: 'foo' | ||
105 | singlevar(kind): 'VGLOBAL' | ||
106 | expr_stat: assignment k='VGLOBAL' | ||
107 | assignment: '=' -- RHS elements follows | ||
108 | explist1: begin | ||
109 | expr: | ||
110 | simpleexp: <number>=1 | ||
111 | explist1: end | ||
112 | -- STATEMENT: end 'expr' | ||
113 | |||
114 | leaveblock | ||
115 | block: end | ||
116 | if_stat: elseif...then | ||
117 | test_then_block: test condition | ||
118 | cond: begin | ||
119 | expr: | ||
120 | subexpr: uop='not' | ||
121 | prefixexp: <name> | ||
122 | str_checkname: 'foo' | ||
123 | singlevar(kind): 'VGLOBAL' | ||
124 | cond: end | ||
125 | test_then_block: then block | ||
126 | block: begin | ||
127 | enterblock(isbreakable=false) | ||
128 | chunk: | ||
129 | -- STATEMENT: begin 'expr' line=3 | ||
130 | prefixexp: <name> | ||
131 | str_checkname: 'foo' | ||
132 | singlevar(kind): 'VGLOBAL' | ||
133 | expr_stat: assignment k='VGLOBAL' | ||
134 | assignment: '=' -- RHS elements follows | ||
135 | explist1: begin | ||
136 | expr: | ||
137 | simpleexp: <number>=0 | ||
138 | explist1: end | ||
139 | -- STATEMENT: end 'expr' | ||
140 | |||
141 | leaveblock | ||
142 | block: end | ||
143 | if_stat: end | ||
144 | -- STATEMENT: end 'if' | ||
145 | |||
146 | close_func | ||
147 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_08.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_08.lua new file mode 100644 index 0000000..d086c98 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_08.lua | |||
@@ -0,0 +1,66 @@ | |||
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.1.3/test/parser_log/sample_09.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_09.lua new file mode 100644 index 0000000..67c6cf3 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_09.lua | |||
@@ -0,0 +1,103 @@ | |||
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 | cond: begin | ||
14 | expr: | ||
15 | simpleexp: true | ||
16 | cond: end | ||
17 | enterblock(isbreakable=true) | ||
18 | while_stat: block | ||
19 | block: begin | ||
20 | enterblock(isbreakable=false) | ||
21 | chunk: | ||
22 | -- STATEMENT: begin 'expr' line=1 | ||
23 | prefixexp: <name> | ||
24 | str_checkname: 'foo' | ||
25 | singlevar(kind): 'VGLOBAL' | ||
26 | expr_stat: assignment k='VGLOBAL' | ||
27 | assignment: '=' -- RHS elements follows | ||
28 | explist1: begin | ||
29 | expr: | ||
30 | subexpr: uop='not' | ||
31 | prefixexp: <name> | ||
32 | str_checkname: 'foo' | ||
33 | singlevar(kind): 'VGLOBAL' | ||
34 | explist1: end | ||
35 | -- STATEMENT: end 'expr' | ||
36 | |||
37 | leaveblock | ||
38 | block: end | ||
39 | leaveblock | ||
40 | while_stat: end | ||
41 | -- STATEMENT: end 'while' | ||
42 | |||
43 | -- STATEMENT: begin 'while' line=2 | ||
44 | while_stat: begin/condition | ||
45 | cond: begin | ||
46 | expr: | ||
47 | prefixexp: <name> | ||
48 | str_checkname: 'foo' | ||
49 | singlevar(kind): 'VGLOBAL' | ||
50 | subexpr: binop='~=' | ||
51 | simpleexp: <number>=42 | ||
52 | subexpr: -- evaluate | ||
53 | cond: end | ||
54 | enterblock(isbreakable=true) | ||
55 | while_stat: block | ||
56 | block: begin | ||
57 | enterblock(isbreakable=false) | ||
58 | chunk: | ||
59 | -- STATEMENT: begin 'expr' line=2 | ||
60 | prefixexp: <name> | ||
61 | str_checkname: 'foo' | ||
62 | singlevar(kind): 'VGLOBAL' | ||
63 | expr_stat: assignment k='VGLOBAL' | ||
64 | assignment: '=' -- RHS elements follows | ||
65 | explist1: begin | ||
66 | expr: | ||
67 | prefixexp: <name> | ||
68 | str_checkname: 'foo' | ||
69 | singlevar(kind): 'VGLOBAL' | ||
70 | subexpr: binop='-' | ||
71 | simpleexp: <number>=1 | ||
72 | subexpr: -- evaluate | ||
73 | explist1: end | ||
74 | -- STATEMENT: end 'expr' | ||
75 | |||
76 | leaveblock | ||
77 | block: end | ||
78 | leaveblock | ||
79 | while_stat: end | ||
80 | -- STATEMENT: end 'while' | ||
81 | |||
82 | -- STATEMENT: begin 'while' line=3 | ||
83 | while_stat: begin/condition | ||
84 | cond: begin | ||
85 | expr: | ||
86 | simpleexp: true | ||
87 | cond: end | ||
88 | enterblock(isbreakable=true) | ||
89 | while_stat: block | ||
90 | block: begin | ||
91 | enterblock(isbreakable=false) | ||
92 | chunk: | ||
93 | -- STATEMENT: begin 'break' line=3 | ||
94 | break_stat: -- break out of loop | ||
95 | -- STATEMENT: end 'break' | ||
96 | leaveblock | ||
97 | block: end | ||
98 | leaveblock | ||
99 | while_stat: end | ||
100 | -- STATEMENT: end 'while' | ||
101 | |||
102 | close_func | ||
103 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_10.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_10.lua new file mode 100644 index 0000000..b8e7754 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_10.lua | |||
@@ -0,0 +1,100 @@ | |||
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 | enterblock(isbreakable=false) | ||
15 | chunk: | ||
16 | -- STATEMENT: begin 'expr' line=1 | ||
17 | prefixexp: <name> | ||
18 | str_checkname: 'foo' | ||
19 | singlevar(kind): 'VGLOBAL' | ||
20 | expr_stat: assignment k='VGLOBAL' | ||
21 | assignment: '=' -- RHS elements follows | ||
22 | explist1: begin | ||
23 | expr: | ||
24 | prefixexp: <name> | ||
25 | str_checkname: 'foo' | ||
26 | singlevar(kind): 'VGLOBAL' | ||
27 | subexpr: binop='..' | ||
28 | simpleexp: <string>=bar | ||
29 | codestring: "bar" | ||
30 | subexpr: -- evaluate | ||
31 | explist1: end | ||
32 | -- STATEMENT: end 'expr' | ||
33 | |||
34 | repeat_stat: condition | ||
35 | cond: begin | ||
36 | expr: | ||
37 | simpleexp: false | ||
38 | cond: end | ||
39 | leaveblock | ||
40 | leaveblock | ||
41 | repeat_stat: end | ||
42 | -- STATEMENT: end 'repeat' | ||
43 | |||
44 | -- STATEMENT: begin 'repeat' line=2 | ||
45 | repeat_stat: begin | ||
46 | enterblock(isbreakable=true) | ||
47 | enterblock(isbreakable=false) | ||
48 | chunk: | ||
49 | -- STATEMENT: begin 'expr' line=2 | ||
50 | prefixexp: <name> | ||
51 | str_checkname: 'foo' | ||
52 | singlevar(kind): 'VGLOBAL' | ||
53 | expr_stat: assignment k='VGLOBAL' | ||
54 | assignment: '=' -- RHS elements follows | ||
55 | explist1: begin | ||
56 | expr: | ||
57 | prefixexp: <name> | ||
58 | str_checkname: 'foo' | ||
59 | singlevar(kind): 'VGLOBAL' | ||
60 | subexpr: binop='/' | ||
61 | simpleexp: <number>=2 | ||
62 | subexpr: -- evaluate | ||
63 | explist1: end | ||
64 | -- STATEMENT: end 'expr' | ||
65 | |||
66 | repeat_stat: condition | ||
67 | cond: begin | ||
68 | expr: | ||
69 | prefixexp: <name> | ||
70 | str_checkname: 'foo' | ||
71 | singlevar(kind): 'VGLOBAL' | ||
72 | subexpr: binop='<' | ||
73 | simpleexp: <number>=1 | ||
74 | subexpr: -- evaluate | ||
75 | cond: end | ||
76 | leaveblock | ||
77 | leaveblock | ||
78 | repeat_stat: end | ||
79 | -- STATEMENT: end 'repeat' | ||
80 | |||
81 | -- STATEMENT: begin 'repeat' line=3 | ||
82 | repeat_stat: begin | ||
83 | enterblock(isbreakable=true) | ||
84 | enterblock(isbreakable=false) | ||
85 | chunk: | ||
86 | -- STATEMENT: begin 'break' line=3 | ||
87 | break_stat: -- break out of loop | ||
88 | -- STATEMENT: end 'break' | ||
89 | repeat_stat: condition | ||
90 | cond: begin | ||
91 | expr: | ||
92 | simpleexp: false | ||
93 | cond: end | ||
94 | leaveblock | ||
95 | leaveblock | ||
96 | repeat_stat: end | ||
97 | -- STATEMENT: end 'repeat' | ||
98 | |||
99 | close_func | ||
100 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_11.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_11.lua new file mode 100644 index 0000000..461ea82 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_11.lua | |||
@@ -0,0 +1,192 @@ | |||
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=true) | ||
15 | str_checkname: 'i' | ||
16 | for_stat: numerical loop | ||
17 | new_localvar: '(for index)' | ||
18 | new_localvar: '(for limit)' | ||
19 | new_localvar: '(for step)' | ||
20 | new_localvar: 'i' | ||
21 | fornum: begin | ||
22 | fornum: index start | ||
23 | exp1: begin | ||
24 | expr: | ||
25 | simpleexp: <number>=1 | ||
26 | exp1: end | ||
27 | fornum: index stop | ||
28 | exp1: begin | ||
29 | expr: | ||
30 | simpleexp: <number>=10 | ||
31 | exp1: end | ||
32 | fornum: body | ||
33 | enterblock(isbreakable=false) | ||
34 | block: begin | ||
35 | enterblock(isbreakable=false) | ||
36 | chunk: | ||
37 | -- STATEMENT: begin 'expr' line=1 | ||
38 | prefixexp: <name> | ||
39 | str_checkname: 'foo' | ||
40 | singlevar(kind): 'VGLOBAL' | ||
41 | expr_stat: assignment k='VGLOBAL' | ||
42 | assignment: '=' -- RHS elements follows | ||
43 | explist1: begin | ||
44 | expr: | ||
45 | prefixexp: <name> | ||
46 | str_checkname: 'i' | ||
47 | singlevar(kind): 'VLOCAL' | ||
48 | explist1: end | ||
49 | -- STATEMENT: end 'expr' | ||
50 | |||
51 | leaveblock | ||
52 | block: end | ||
53 | leaveblock | ||
54 | fornum: end | ||
55 | leaveblock | ||
56 | for_stat: end | ||
57 | -- STATEMENT: end 'for' | ||
58 | |||
59 | -- STATEMENT: begin 'for' line=2 | ||
60 | for_stat: begin | ||
61 | enterblock(isbreakable=true) | ||
62 | str_checkname: 'i' | ||
63 | for_stat: numerical loop | ||
64 | new_localvar: '(for index)' | ||
65 | new_localvar: '(for limit)' | ||
66 | new_localvar: '(for step)' | ||
67 | new_localvar: 'i' | ||
68 | fornum: begin | ||
69 | fornum: index start | ||
70 | exp1: begin | ||
71 | expr: | ||
72 | simpleexp: <number>=1 | ||
73 | exp1: end | ||
74 | fornum: index stop | ||
75 | exp1: begin | ||
76 | expr: | ||
77 | simpleexp: <number>=10 | ||
78 | exp1: end | ||
79 | fornum: index step | ||
80 | exp1: begin | ||
81 | expr: | ||
82 | simpleexp: <number>=2 | ||
83 | exp1: end | ||
84 | fornum: body | ||
85 | enterblock(isbreakable=false) | ||
86 | block: begin | ||
87 | enterblock(isbreakable=false) | ||
88 | chunk: | ||
89 | -- STATEMENT: begin 'break' line=2 | ||
90 | break_stat: -- break out of loop | ||
91 | -- STATEMENT: end 'break' | ||
92 | leaveblock | ||
93 | block: end | ||
94 | leaveblock | ||
95 | fornum: end | ||
96 | leaveblock | ||
97 | for_stat: end | ||
98 | -- STATEMENT: end 'for' | ||
99 | |||
100 | -- STATEMENT: begin 'for' line=3 | ||
101 | for_stat: begin | ||
102 | enterblock(isbreakable=true) | ||
103 | str_checkname: 'i' | ||
104 | for_stat: list-based loop | ||
105 | forlist: begin | ||
106 | new_localvar: '(for generator)' | ||
107 | new_localvar: '(for state)' | ||
108 | new_localvar: '(for control)' | ||
109 | new_localvar: 'i' | ||
110 | forlist: explist1 | ||
111 | explist1: begin | ||
112 | expr: | ||
113 | prefixexp: <name> | ||
114 | str_checkname: 'foo' | ||
115 | singlevar(kind): 'VGLOBAL' | ||
116 | explist1: end | ||
117 | forlist: body | ||
118 | enterblock(isbreakable=false) | ||
119 | block: begin | ||
120 | enterblock(isbreakable=false) | ||
121 | chunk: | ||
122 | -- STATEMENT: begin 'expr' line=3 | ||
123 | prefixexp: <name> | ||
124 | str_checkname: 'bar' | ||
125 | singlevar(kind): 'VGLOBAL' | ||
126 | expr_stat: assignment k='VGLOBAL' | ||
127 | assignment: '=' -- RHS elements follows | ||
128 | explist1: begin | ||
129 | expr: | ||
130 | simpleexp: <number>=0 | ||
131 | explist1: end | ||
132 | -- STATEMENT: end 'expr' | ||
133 | |||
134 | leaveblock | ||
135 | block: end | ||
136 | leaveblock | ||
137 | forlist: end | ||
138 | leaveblock | ||
139 | for_stat: end | ||
140 | -- STATEMENT: end 'for' | ||
141 | |||
142 | -- STATEMENT: begin 'for' line=4 | ||
143 | for_stat: begin | ||
144 | enterblock(isbreakable=true) | ||
145 | str_checkname: 'i' | ||
146 | for_stat: list-based loop | ||
147 | forlist: begin | ||
148 | new_localvar: '(for generator)' | ||
149 | new_localvar: '(for state)' | ||
150 | new_localvar: '(for control)' | ||
151 | new_localvar: 'i' | ||
152 | str_checkname: 'j' | ||
153 | new_localvar: 'j' | ||
154 | forlist: explist1 | ||
155 | explist1: begin | ||
156 | expr: | ||
157 | prefixexp: <name> | ||
158 | str_checkname: 'foo' | ||
159 | singlevar(kind): 'VGLOBAL' | ||
160 | explist1: ',' -- continuation | ||
161 | expr: | ||
162 | prefixexp: <name> | ||
163 | str_checkname: 'bar' | ||
164 | singlevar(kind): 'VGLOBAL' | ||
165 | explist1: end | ||
166 | forlist: body | ||
167 | enterblock(isbreakable=false) | ||
168 | block: begin | ||
169 | enterblock(isbreakable=false) | ||
170 | chunk: | ||
171 | -- STATEMENT: begin 'expr' line=4 | ||
172 | prefixexp: <name> | ||
173 | str_checkname: 'baz' | ||
174 | singlevar(kind): 'VGLOBAL' | ||
175 | expr_stat: assignment k='VGLOBAL' | ||
176 | assignment: '=' -- RHS elements follows | ||
177 | explist1: begin | ||
178 | expr: | ||
179 | simpleexp: <number>=0 | ||
180 | explist1: end | ||
181 | -- STATEMENT: end 'expr' | ||
182 | |||
183 | leaveblock | ||
184 | block: end | ||
185 | leaveblock | ||
186 | forlist: end | ||
187 | leaveblock | ||
188 | for_stat: end | ||
189 | -- STATEMENT: end 'for' | ||
190 | |||
191 | close_func | ||
192 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_12.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_12.lua new file mode 100644 index 0000000..c423d85 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_12.lua | |||
@@ -0,0 +1,52 @@ | |||
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 | new_localvar: 'foo' | ||
16 | localstat: end | ||
17 | -- STATEMENT: end 'local' | ||
18 | |||
19 | -- STATEMENT: begin 'local' line=2 | ||
20 | local_stat: local statement | ||
21 | localstat: begin | ||
22 | str_checkname: 'foo' | ||
23 | new_localvar: 'foo' | ||
24 | str_checkname: 'bar' | ||
25 | new_localvar: 'bar' | ||
26 | str_checkname: 'baz' | ||
27 | new_localvar: 'baz' | ||
28 | localstat: end | ||
29 | -- STATEMENT: end 'local' | ||
30 | |||
31 | -- STATEMENT: begin 'local' line=3 | ||
32 | local_stat: local statement | ||
33 | localstat: begin | ||
34 | str_checkname: 'foo' | ||
35 | new_localvar: 'foo' | ||
36 | str_checkname: 'bar' | ||
37 | new_localvar: 'bar' | ||
38 | localstat: -- assignment | ||
39 | explist1: begin | ||
40 | expr: | ||
41 | simpleexp: <string>=foo | ||
42 | codestring: "foo" | ||
43 | explist1: ',' -- continuation | ||
44 | expr: | ||
45 | simpleexp: <string>=bar | ||
46 | codestring: "bar" | ||
47 | explist1: end | ||
48 | localstat: end | ||
49 | -- STATEMENT: end 'local' | ||
50 | |||
51 | close_func | ||
52 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_13.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_13.lua new file mode 100644 index 0000000..b5f598a --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_13.lua | |||
@@ -0,0 +1,108 @@ | |||
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 | new_localvar: 'foo' | ||
17 | localfunc: body | ||
18 | open_func | ||
19 | body: begin | ||
20 | body: parlist | ||
21 | parlist: begin | ||
22 | parlist: end | ||
23 | body: chunk | ||
24 | chunk: | ||
25 | -- STATEMENT: begin 'return' line=1 | ||
26 | return_stat: no return values | ||
27 | -- STATEMENT: end 'return' | ||
28 | body: end | ||
29 | close_func | ||
30 | localfunc: end | ||
31 | -- STATEMENT: end 'local' | ||
32 | |||
33 | -- STATEMENT: begin 'local' line=2 | ||
34 | local_stat: local function | ||
35 | localfunc: begin | ||
36 | str_checkname: 'foo' | ||
37 | new_localvar: 'foo' | ||
38 | localfunc: body | ||
39 | open_func | ||
40 | body: begin | ||
41 | body: parlist | ||
42 | parlist: begin | ||
43 | str_checkname: 'a' | ||
44 | new_localvar: 'a' | ||
45 | parlist: end | ||
46 | body: chunk | ||
47 | chunk: | ||
48 | -- STATEMENT: begin 'return' line=2 | ||
49 | return_stat: no return values | ||
50 | -- STATEMENT: end 'return' | ||
51 | body: end | ||
52 | close_func | ||
53 | localfunc: end | ||
54 | -- STATEMENT: end 'local' | ||
55 | |||
56 | -- STATEMENT: begin 'local' line=3 | ||
57 | local_stat: local function | ||
58 | localfunc: begin | ||
59 | str_checkname: 'foo' | ||
60 | new_localvar: 'foo' | ||
61 | localfunc: body | ||
62 | open_func | ||
63 | body: begin | ||
64 | body: parlist | ||
65 | parlist: begin | ||
66 | str_checkname: 'x' | ||
67 | new_localvar: 'x' | ||
68 | str_checkname: 'y' | ||
69 | new_localvar: 'y' | ||
70 | str_checkname: 'z' | ||
71 | new_localvar: 'z' | ||
72 | parlist: end | ||
73 | body: chunk | ||
74 | chunk: | ||
75 | -- STATEMENT: begin 'return' line=3 | ||
76 | return_stat: no return values | ||
77 | -- STATEMENT: end 'return' | ||
78 | body: end | ||
79 | close_func | ||
80 | localfunc: end | ||
81 | -- STATEMENT: end 'local' | ||
82 | |||
83 | -- STATEMENT: begin 'local' line=4 | ||
84 | local_stat: local function | ||
85 | localfunc: begin | ||
86 | str_checkname: 'foo' | ||
87 | new_localvar: 'foo' | ||
88 | localfunc: body | ||
89 | open_func | ||
90 | body: begin | ||
91 | body: parlist | ||
92 | parlist: begin | ||
93 | str_checkname: 'x' | ||
94 | new_localvar: 'x' | ||
95 | parlist: ... (dots) | ||
96 | parlist: end | ||
97 | body: chunk | ||
98 | chunk: | ||
99 | -- STATEMENT: begin 'return' line=4 | ||
100 | return_stat: no return values | ||
101 | -- STATEMENT: end 'return' | ||
102 | body: end | ||
103 | close_func | ||
104 | localfunc: end | ||
105 | -- STATEMENT: end 'local' | ||
106 | |||
107 | close_func | ||
108 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_14.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_14.lua new file mode 100644 index 0000000..a6b9ad0 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_14.lua | |||
@@ -0,0 +1,112 @@ | |||
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(kind): 'VGLOBAL' | ||
17 | funcname: end | ||
18 | function_stat: body needself='false' | ||
19 | open_func | ||
20 | body: begin | ||
21 | body: parlist | ||
22 | parlist: begin | ||
23 | parlist: end | ||
24 | body: chunk | ||
25 | chunk: | ||
26 | -- STATEMENT: begin 'return' line=1 | ||
27 | return_stat: no return values | ||
28 | -- STATEMENT: end 'return' | ||
29 | body: end | ||
30 | close_func | ||
31 | function_stat: end | ||
32 | -- STATEMENT: end 'function' | ||
33 | |||
34 | -- STATEMENT: begin 'function' line=2 | ||
35 | function_stat: begin | ||
36 | funcname: begin | ||
37 | str_checkname: 'foo' | ||
38 | singlevar(kind): 'VGLOBAL' | ||
39 | funcname: end | ||
40 | function_stat: body needself='false' | ||
41 | open_func | ||
42 | body: begin | ||
43 | body: parlist | ||
44 | parlist: begin | ||
45 | str_checkname: 'a' | ||
46 | new_localvar: 'a' | ||
47 | parlist: end | ||
48 | body: chunk | ||
49 | chunk: | ||
50 | -- STATEMENT: begin 'return' line=2 | ||
51 | return_stat: no return values | ||
52 | -- STATEMENT: end 'return' | ||
53 | body: end | ||
54 | close_func | ||
55 | function_stat: end | ||
56 | -- STATEMENT: end 'function' | ||
57 | |||
58 | -- STATEMENT: begin 'function' line=3 | ||
59 | function_stat: begin | ||
60 | funcname: begin | ||
61 | str_checkname: 'foo' | ||
62 | singlevar(kind): 'VGLOBAL' | ||
63 | funcname: end | ||
64 | function_stat: body needself='false' | ||
65 | open_func | ||
66 | body: begin | ||
67 | body: parlist | ||
68 | parlist: begin | ||
69 | str_checkname: 'x' | ||
70 | new_localvar: 'x' | ||
71 | str_checkname: 'y' | ||
72 | new_localvar: 'y' | ||
73 | str_checkname: 'z' | ||
74 | new_localvar: 'z' | ||
75 | parlist: end | ||
76 | body: chunk | ||
77 | chunk: | ||
78 | -- STATEMENT: begin 'return' line=3 | ||
79 | return_stat: no return values | ||
80 | -- STATEMENT: end 'return' | ||
81 | body: end | ||
82 | close_func | ||
83 | function_stat: end | ||
84 | -- STATEMENT: end 'function' | ||
85 | |||
86 | -- STATEMENT: begin 'function' line=4 | ||
87 | function_stat: begin | ||
88 | funcname: begin | ||
89 | str_checkname: 'foo' | ||
90 | singlevar(kind): 'VGLOBAL' | ||
91 | funcname: end | ||
92 | function_stat: body needself='false' | ||
93 | open_func | ||
94 | body: begin | ||
95 | body: parlist | ||
96 | parlist: begin | ||
97 | str_checkname: 'x' | ||
98 | new_localvar: 'x' | ||
99 | parlist: ... (dots) | ||
100 | parlist: end | ||
101 | body: chunk | ||
102 | chunk: | ||
103 | -- STATEMENT: begin 'return' line=4 | ||
104 | return_stat: no return values | ||
105 | -- STATEMENT: end 'return' | ||
106 | body: end | ||
107 | close_func | ||
108 | function_stat: end | ||
109 | -- STATEMENT: end 'function' | ||
110 | |||
111 | close_func | ||
112 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_15.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_15.lua new file mode 100644 index 0000000..497eeaf --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_15.lua | |||
@@ -0,0 +1,140 @@ | |||
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(kind): 'VGLOBAL' | ||
17 | funcname: -- '.' field | ||
18 | field: operator=. | ||
19 | checkname: | ||
20 | str_checkname: 'bar' | ||
21 | codestring: "bar" | ||
22 | funcname: end | ||
23 | function_stat: body needself='false' | ||
24 | open_func | ||
25 | body: begin | ||
26 | body: parlist | ||
27 | parlist: begin | ||
28 | str_checkname: 'p' | ||
29 | new_localvar: 'p' | ||
30 | parlist: end | ||
31 | body: chunk | ||
32 | chunk: | ||
33 | -- STATEMENT: begin 'return' line=1 | ||
34 | return_stat: no return values | ||
35 | -- STATEMENT: end 'return' | ||
36 | body: end | ||
37 | close_func | ||
38 | function_stat: end | ||
39 | -- STATEMENT: end 'function' | ||
40 | |||
41 | -- STATEMENT: begin 'function' line=2 | ||
42 | function_stat: begin | ||
43 | funcname: begin | ||
44 | str_checkname: 'foo' | ||
45 | singlevar(kind): 'VGLOBAL' | ||
46 | funcname: -- '.' field | ||
47 | field: operator=. | ||
48 | checkname: | ||
49 | str_checkname: 'bar' | ||
50 | codestring: "bar" | ||
51 | funcname: -- '.' field | ||
52 | field: operator=. | ||
53 | checkname: | ||
54 | str_checkname: 'baz' | ||
55 | codestring: "baz" | ||
56 | funcname: end | ||
57 | function_stat: body needself='false' | ||
58 | open_func | ||
59 | body: begin | ||
60 | body: parlist | ||
61 | parlist: begin | ||
62 | str_checkname: 'p' | ||
63 | new_localvar: 'p' | ||
64 | parlist: end | ||
65 | body: chunk | ||
66 | chunk: | ||
67 | -- STATEMENT: begin 'return' line=2 | ||
68 | return_stat: no return values | ||
69 | -- STATEMENT: end 'return' | ||
70 | body: end | ||
71 | close_func | ||
72 | function_stat: end | ||
73 | -- STATEMENT: end 'function' | ||
74 | |||
75 | -- STATEMENT: begin 'function' line=3 | ||
76 | function_stat: begin | ||
77 | funcname: begin | ||
78 | str_checkname: 'foo' | ||
79 | singlevar(kind): 'VGLOBAL' | ||
80 | funcname: -- ':' field | ||
81 | field: operator=: | ||
82 | checkname: | ||
83 | str_checkname: 'bar' | ||
84 | codestring: "bar" | ||
85 | funcname: end | ||
86 | function_stat: body needself='true' | ||
87 | open_func | ||
88 | body: begin | ||
89 | new_localvar: 'self' | ||
90 | body: parlist | ||
91 | parlist: begin | ||
92 | str_checkname: 'p' | ||
93 | new_localvar: 'p' | ||
94 | parlist: end | ||
95 | body: chunk | ||
96 | chunk: | ||
97 | -- STATEMENT: begin 'return' line=3 | ||
98 | return_stat: no return values | ||
99 | -- STATEMENT: end 'return' | ||
100 | body: end | ||
101 | close_func | ||
102 | function_stat: end | ||
103 | -- STATEMENT: end 'function' | ||
104 | |||
105 | -- STATEMENT: begin 'function' line=4 | ||
106 | function_stat: begin | ||
107 | funcname: begin | ||
108 | str_checkname: 'foo' | ||
109 | singlevar(kind): 'VGLOBAL' | ||
110 | funcname: -- '.' field | ||
111 | field: operator=. | ||
112 | checkname: | ||
113 | str_checkname: 'bar' | ||
114 | codestring: "bar" | ||
115 | funcname: -- '.' field | ||
116 | field: operator=. | ||
117 | checkname: | ||
118 | str_checkname: 'baz' | ||
119 | codestring: "baz" | ||
120 | funcname: end | ||
121 | function_stat: body needself='false' | ||
122 | open_func | ||
123 | body: begin | ||
124 | body: parlist | ||
125 | parlist: begin | ||
126 | str_checkname: 'p' | ||
127 | new_localvar: 'p' | ||
128 | parlist: end | ||
129 | body: chunk | ||
130 | chunk: | ||
131 | -- STATEMENT: begin 'return' line=4 | ||
132 | return_stat: no return values | ||
133 | -- STATEMENT: end 'return' | ||
134 | body: end | ||
135 | close_func | ||
136 | function_stat: end | ||
137 | -- STATEMENT: end 'function' | ||
138 | |||
139 | close_func | ||
140 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_16.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_16.lua new file mode 100644 index 0000000..b7907b8 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_16.lua | |||
@@ -0,0 +1,128 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | foo = function() return end | ||
3 | foo = function(x,y) return end | ||
4 | foo = function(...) return end | ||
5 | foo = function(...) local bar = ... return end | ||
6 | -- END OF SOURCE -- | ||
7 | |||
8 | -- TOP: begin | ||
9 | open_func | ||
10 | |||
11 | chunk: | ||
12 | -- STATEMENT: begin 'expr' line=1 | ||
13 | prefixexp: <name> | ||
14 | str_checkname: 'foo' | ||
15 | singlevar(kind): 'VGLOBAL' | ||
16 | expr_stat: assignment k='VGLOBAL' | ||
17 | assignment: '=' -- RHS elements follows | ||
18 | explist1: begin | ||
19 | expr: | ||
20 | simpleexp: function | ||
21 | open_func | ||
22 | body: begin | ||
23 | body: parlist | ||
24 | parlist: begin | ||
25 | parlist: end | ||
26 | body: chunk | ||
27 | chunk: | ||
28 | -- STATEMENT: begin 'return' line=1 | ||
29 | return_stat: no return values | ||
30 | -- STATEMENT: end 'return' | ||
31 | body: end | ||
32 | close_func | ||
33 | explist1: end | ||
34 | -- STATEMENT: end 'expr' | ||
35 | |||
36 | -- STATEMENT: begin 'expr' line=2 | ||
37 | prefixexp: <name> | ||
38 | str_checkname: 'foo' | ||
39 | singlevar(kind): 'VGLOBAL' | ||
40 | expr_stat: assignment k='VGLOBAL' | ||
41 | assignment: '=' -- RHS elements follows | ||
42 | explist1: begin | ||
43 | expr: | ||
44 | simpleexp: function | ||
45 | open_func | ||
46 | body: begin | ||
47 | body: parlist | ||
48 | parlist: begin | ||
49 | str_checkname: 'x' | ||
50 | new_localvar: 'x' | ||
51 | str_checkname: 'y' | ||
52 | new_localvar: 'y' | ||
53 | parlist: end | ||
54 | body: chunk | ||
55 | chunk: | ||
56 | -- STATEMENT: begin 'return' line=2 | ||
57 | return_stat: no return values | ||
58 | -- STATEMENT: end 'return' | ||
59 | body: end | ||
60 | close_func | ||
61 | explist1: end | ||
62 | -- STATEMENT: end 'expr' | ||
63 | |||
64 | -- STATEMENT: begin 'expr' line=3 | ||
65 | prefixexp: <name> | ||
66 | str_checkname: 'foo' | ||
67 | singlevar(kind): 'VGLOBAL' | ||
68 | expr_stat: assignment k='VGLOBAL' | ||
69 | assignment: '=' -- RHS elements follows | ||
70 | explist1: begin | ||
71 | expr: | ||
72 | simpleexp: function | ||
73 | open_func | ||
74 | body: begin | ||
75 | body: parlist | ||
76 | parlist: begin | ||
77 | parlist: ... (dots) | ||
78 | parlist: end | ||
79 | body: chunk | ||
80 | chunk: | ||
81 | -- STATEMENT: begin 'return' line=3 | ||
82 | return_stat: no return values | ||
83 | -- STATEMENT: end 'return' | ||
84 | body: end | ||
85 | close_func | ||
86 | explist1: end | ||
87 | -- STATEMENT: end 'expr' | ||
88 | |||
89 | -- STATEMENT: begin 'expr' line=4 | ||
90 | prefixexp: <name> | ||
91 | str_checkname: 'foo' | ||
92 | singlevar(kind): 'VGLOBAL' | ||
93 | expr_stat: assignment k='VGLOBAL' | ||
94 | assignment: '=' -- RHS elements follows | ||
95 | explist1: begin | ||
96 | expr: | ||
97 | simpleexp: function | ||
98 | open_func | ||
99 | body: begin | ||
100 | body: parlist | ||
101 | parlist: begin | ||
102 | parlist: ... (dots) | ||
103 | parlist: end | ||
104 | body: chunk | ||
105 | chunk: | ||
106 | -- STATEMENT: begin 'local' line=4 | ||
107 | local_stat: local statement | ||
108 | localstat: begin | ||
109 | str_checkname: 'bar' | ||
110 | new_localvar: 'bar' | ||
111 | localstat: -- assignment | ||
112 | explist1: begin | ||
113 | expr: | ||
114 | simpleexp: ... | ||
115 | explist1: end | ||
116 | localstat: end | ||
117 | -- STATEMENT: end 'local' | ||
118 | |||
119 | -- STATEMENT: begin 'return' line=4 | ||
120 | return_stat: no return values | ||
121 | -- STATEMENT: end 'return' | ||
122 | body: end | ||
123 | close_func | ||
124 | explist1: end | ||
125 | -- STATEMENT: end 'expr' | ||
126 | |||
127 | close_func | ||
128 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_17.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_17.lua new file mode 100644 index 0000000..fadc7f9 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_17.lua | |||
@@ -0,0 +1,110 @@ | |||
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(kind): 'VGLOBAL' | ||
16 | expr_stat: assignment k='VGLOBAL' | ||
17 | assignment: '=' -- RHS elements follows | ||
18 | explist1: begin | ||
19 | expr: | ||
20 | simpleexp: constructor | ||
21 | constructor: begin | ||
22 | constructor: end | ||
23 | explist1: end | ||
24 | -- STATEMENT: end 'expr' | ||
25 | |||
26 | -- STATEMENT: begin 'expr' line=2 | ||
27 | prefixexp: <name> | ||
28 | str_checkname: 'foo' | ||
29 | singlevar(kind): 'VGLOBAL' | ||
30 | expr_stat: assignment k='VGLOBAL' | ||
31 | assignment: '=' -- RHS elements follows | ||
32 | explist1: begin | ||
33 | expr: | ||
34 | simpleexp: constructor | ||
35 | constructor: begin | ||
36 | listfield: expr | ||
37 | expr: | ||
38 | simpleexp: <number>=1 | ||
39 | listfield: expr | ||
40 | expr: | ||
41 | simpleexp: <number>=2 | ||
42 | listfield: expr | ||
43 | expr: | ||
44 | simpleexp: <number>=3 | ||
45 | listfield: expr | ||
46 | expr: | ||
47 | simpleexp: <string>=foo | ||
48 | codestring: "foo" | ||
49 | constructor: end | ||
50 | explist1: end | ||
51 | -- STATEMENT: end 'expr' | ||
52 | |||
53 | -- STATEMENT: begin 'expr' line=3 | ||
54 | prefixexp: <name> | ||
55 | str_checkname: 'foo' | ||
56 | singlevar(kind): 'VGLOBAL' | ||
57 | expr_stat: assignment k='VGLOBAL' | ||
58 | assignment: '=' -- RHS elements follows | ||
59 | explist1: begin | ||
60 | expr: | ||
61 | simpleexp: constructor | ||
62 | constructor: begin | ||
63 | recfield: name | ||
64 | checkname: | ||
65 | str_checkname: 'bar' | ||
66 | codestring: "bar" | ||
67 | expr: | ||
68 | simpleexp: <number>=77 | ||
69 | recfield: name | ||
70 | checkname: | ||
71 | str_checkname: 'baz' | ||
72 | codestring: "baz" | ||
73 | expr: | ||
74 | simpleexp: <number>=88 | ||
75 | constructor: end | ||
76 | explist1: end | ||
77 | -- STATEMENT: end 'expr' | ||
78 | |||
79 | -- STATEMENT: begin 'expr' line=4 | ||
80 | prefixexp: <name> | ||
81 | str_checkname: 'foo' | ||
82 | singlevar(kind): 'VGLOBAL' | ||
83 | expr_stat: assignment k='VGLOBAL' | ||
84 | assignment: '=' -- RHS elements follows | ||
85 | explist1: begin | ||
86 | expr: | ||
87 | simpleexp: constructor | ||
88 | constructor: begin | ||
89 | recfield: [ exp1 ] | ||
90 | index: begin '[' | ||
91 | expr: | ||
92 | simpleexp: <string>=bar | ||
93 | codestring: "bar" | ||
94 | index: end ']' | ||
95 | expr: | ||
96 | simpleexp: <number>=77 | ||
97 | recfield: [ exp1 ] | ||
98 | index: begin '[' | ||
99 | expr: | ||
100 | simpleexp: <string>=baz | ||
101 | codestring: "baz" | ||
102 | index: end ']' | ||
103 | expr: | ||
104 | simpleexp: <number>=88 | ||
105 | constructor: end | ||
106 | explist1: end | ||
107 | -- STATEMENT: end 'expr' | ||
108 | |||
109 | close_func | ||
110 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_18.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_18.lua new file mode 100644 index 0000000..732b4d6 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_18.lua | |||
@@ -0,0 +1,26 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | print(a) | ||
3 | -- END OF SOURCE -- | ||
4 | |||
5 | -- TOP: begin | ||
6 | open_func | ||
7 | |||
8 | chunk: | ||
9 | -- STATEMENT: begin 'expr' line=1 | ||
10 | prefixexp: <name> | ||
11 | str_checkname: 'print' | ||
12 | singlevar(kind): 'VGLOBAL' | ||
13 | primaryexp: ( funcargs | ||
14 | funcargs: begin '(' | ||
15 | explist1: begin | ||
16 | expr: | ||
17 | prefixexp: <name> | ||
18 | str_checkname: 'a' | ||
19 | singlevar(kind): 'VGLOBAL' | ||
20 | explist1: end | ||
21 | funcargs: end -- expr is a VCALL | ||
22 | expr_stat: function call k='VCALL' | ||
23 | -- STATEMENT: end 'expr' | ||
24 | |||
25 | close_func | ||
26 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_19.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_19.lua new file mode 100644 index 0000000..9863b4a --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_19.lua | |||
@@ -0,0 +1,35 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | local a | ||
3 | print(a) | ||
4 | -- END OF SOURCE -- | ||
5 | |||
6 | -- TOP: begin | ||
7 | open_func | ||
8 | |||
9 | chunk: | ||
10 | -- STATEMENT: begin 'local' line=1 | ||
11 | local_stat: local statement | ||
12 | localstat: begin | ||
13 | str_checkname: 'a' | ||
14 | new_localvar: 'a' | ||
15 | localstat: end | ||
16 | -- STATEMENT: end 'local' | ||
17 | |||
18 | -- STATEMENT: begin 'expr' line=2 | ||
19 | prefixexp: <name> | ||
20 | str_checkname: 'print' | ||
21 | singlevar(kind): 'VGLOBAL' | ||
22 | primaryexp: ( funcargs | ||
23 | funcargs: begin '(' | ||
24 | explist1: begin | ||
25 | expr: | ||
26 | prefixexp: <name> | ||
27 | str_checkname: 'a' | ||
28 | singlevar(kind): 'VLOCAL' | ||
29 | explist1: end | ||
30 | funcargs: end -- expr is a VCALL | ||
31 | expr_stat: function call k='VCALL' | ||
32 | -- STATEMENT: end 'expr' | ||
33 | |||
34 | close_func | ||
35 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_20.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_20.lua new file mode 100644 index 0000000..bc37280 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_20.lua | |||
@@ -0,0 +1,64 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | do | ||
3 | local a | ||
4 | print(a) | ||
5 | end | ||
6 | print(a) | ||
7 | -- END OF SOURCE -- | ||
8 | |||
9 | -- TOP: begin | ||
10 | open_func | ||
11 | |||
12 | chunk: | ||
13 | -- STATEMENT: begin 'do' line=1 | ||
14 | do_stat: begin | ||
15 | block: begin | ||
16 | enterblock(isbreakable=false) | ||
17 | chunk: | ||
18 | -- STATEMENT: begin 'local' line=2 | ||
19 | local_stat: local statement | ||
20 | localstat: begin | ||
21 | str_checkname: 'a' | ||
22 | new_localvar: 'a' | ||
23 | localstat: end | ||
24 | -- STATEMENT: end 'local' | ||
25 | |||
26 | -- STATEMENT: begin 'expr' line=3 | ||
27 | prefixexp: <name> | ||
28 | str_checkname: 'print' | ||
29 | singlevar(kind): 'VGLOBAL' | ||
30 | primaryexp: ( funcargs | ||
31 | funcargs: begin '(' | ||
32 | explist1: begin | ||
33 | expr: | ||
34 | prefixexp: <name> | ||
35 | str_checkname: 'a' | ||
36 | singlevar(kind): 'VLOCAL' | ||
37 | explist1: end | ||
38 | funcargs: end -- expr is a VCALL | ||
39 | expr_stat: function call k='VCALL' | ||
40 | -- STATEMENT: end 'expr' | ||
41 | |||
42 | leaveblock | ||
43 | block: end | ||
44 | do_stat: end | ||
45 | -- STATEMENT: end 'do' | ||
46 | |||
47 | -- STATEMENT: begin 'expr' line=5 | ||
48 | prefixexp: <name> | ||
49 | str_checkname: 'print' | ||
50 | singlevar(kind): 'VGLOBAL' | ||
51 | primaryexp: ( funcargs | ||
52 | funcargs: begin '(' | ||
53 | explist1: begin | ||
54 | expr: | ||
55 | prefixexp: <name> | ||
56 | str_checkname: 'a' | ||
57 | singlevar(kind): 'VGLOBAL' | ||
58 | explist1: end | ||
59 | funcargs: end -- expr is a VCALL | ||
60 | expr_stat: function call k='VCALL' | ||
61 | -- STATEMENT: end 'expr' | ||
62 | |||
63 | close_func | ||
64 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_21.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_21.lua new file mode 100644 index 0000000..b2bac4b --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_21.lua | |||
@@ -0,0 +1,77 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | local a,b,c | ||
3 | do | ||
4 | local b | ||
5 | print(b) | ||
6 | end | ||
7 | print(b) | ||
8 | -- END OF SOURCE -- | ||
9 | |||
10 | -- TOP: begin | ||
11 | open_func | ||
12 | |||
13 | chunk: | ||
14 | -- STATEMENT: begin 'local' line=1 | ||
15 | local_stat: local statement | ||
16 | localstat: begin | ||
17 | str_checkname: 'a' | ||
18 | new_localvar: 'a' | ||
19 | str_checkname: 'b' | ||
20 | new_localvar: 'b' | ||
21 | str_checkname: 'c' | ||
22 | new_localvar: 'c' | ||
23 | localstat: end | ||
24 | -- STATEMENT: end 'local' | ||
25 | |||
26 | -- STATEMENT: begin 'do' line=2 | ||
27 | do_stat: begin | ||
28 | block: begin | ||
29 | enterblock(isbreakable=false) | ||
30 | chunk: | ||
31 | -- STATEMENT: begin 'local' line=3 | ||
32 | local_stat: local statement | ||
33 | localstat: begin | ||
34 | str_checkname: 'b' | ||
35 | new_localvar: 'b' | ||
36 | localstat: end | ||
37 | -- STATEMENT: end 'local' | ||
38 | |||
39 | -- STATEMENT: begin 'expr' line=4 | ||
40 | prefixexp: <name> | ||
41 | str_checkname: 'print' | ||
42 | singlevar(kind): 'VGLOBAL' | ||
43 | primaryexp: ( funcargs | ||
44 | funcargs: begin '(' | ||
45 | explist1: begin | ||
46 | expr: | ||
47 | prefixexp: <name> | ||
48 | str_checkname: 'b' | ||
49 | singlevar(kind): 'VLOCAL' | ||
50 | explist1: end | ||
51 | funcargs: end -- expr is a VCALL | ||
52 | expr_stat: function call k='VCALL' | ||
53 | -- STATEMENT: end 'expr' | ||
54 | |||
55 | leaveblock | ||
56 | block: end | ||
57 | do_stat: end | ||
58 | -- STATEMENT: end 'do' | ||
59 | |||
60 | -- STATEMENT: begin 'expr' line=6 | ||
61 | prefixexp: <name> | ||
62 | str_checkname: 'print' | ||
63 | singlevar(kind): 'VGLOBAL' | ||
64 | primaryexp: ( funcargs | ||
65 | funcargs: begin '(' | ||
66 | explist1: begin | ||
67 | expr: | ||
68 | prefixexp: <name> | ||
69 | str_checkname: 'b' | ||
70 | singlevar(kind): 'VLOCAL' | ||
71 | explist1: end | ||
72 | funcargs: end -- expr is a VCALL | ||
73 | expr_stat: function call k='VCALL' | ||
74 | -- STATEMENT: end 'expr' | ||
75 | |||
76 | close_func | ||
77 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_22.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_22.lua new file mode 100644 index 0000000..6885f01 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_22.lua | |||
@@ -0,0 +1,43 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | local function foo() end | ||
3 | bar = foo | ||
4 | -- END OF SOURCE -- | ||
5 | |||
6 | -- TOP: begin | ||
7 | open_func | ||
8 | |||
9 | chunk: | ||
10 | -- STATEMENT: begin 'local' line=1 | ||
11 | local_stat: local function | ||
12 | localfunc: begin | ||
13 | str_checkname: 'foo' | ||
14 | new_localvar: 'foo' | ||
15 | localfunc: body | ||
16 | open_func | ||
17 | body: begin | ||
18 | body: parlist | ||
19 | parlist: begin | ||
20 | parlist: end | ||
21 | body: chunk | ||
22 | chunk: | ||
23 | body: end | ||
24 | close_func | ||
25 | localfunc: end | ||
26 | -- STATEMENT: end 'local' | ||
27 | |||
28 | -- STATEMENT: begin 'expr' line=2 | ||
29 | prefixexp: <name> | ||
30 | str_checkname: 'bar' | ||
31 | singlevar(kind): 'VGLOBAL' | ||
32 | expr_stat: assignment k='VGLOBAL' | ||
33 | assignment: '=' -- RHS elements follows | ||
34 | explist1: begin | ||
35 | expr: | ||
36 | prefixexp: <name> | ||
37 | str_checkname: 'foo' | ||
38 | singlevar(kind): 'VLOCAL' | ||
39 | explist1: end | ||
40 | -- STATEMENT: end 'expr' | ||
41 | |||
42 | close_func | ||
43 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_23.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_23.lua new file mode 100644 index 0000000..eb658ed --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_23.lua | |||
@@ -0,0 +1,70 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | do | ||
3 | local function foo() end | ||
4 | bar = foo | ||
5 | end | ||
6 | baz = foo | ||
7 | -- END OF SOURCE -- | ||
8 | |||
9 | -- TOP: begin | ||
10 | open_func | ||
11 | |||
12 | chunk: | ||
13 | -- STATEMENT: begin 'do' line=1 | ||
14 | do_stat: begin | ||
15 | block: begin | ||
16 | enterblock(isbreakable=false) | ||
17 | chunk: | ||
18 | -- STATEMENT: begin 'local' line=2 | ||
19 | local_stat: local function | ||
20 | localfunc: begin | ||
21 | str_checkname: 'foo' | ||
22 | new_localvar: 'foo' | ||
23 | localfunc: body | ||
24 | open_func | ||
25 | body: begin | ||
26 | body: parlist | ||
27 | parlist: begin | ||
28 | parlist: end | ||
29 | body: chunk | ||
30 | chunk: | ||
31 | body: end | ||
32 | close_func | ||
33 | localfunc: end | ||
34 | -- STATEMENT: end 'local' | ||
35 | |||
36 | -- STATEMENT: begin 'expr' line=3 | ||
37 | prefixexp: <name> | ||
38 | str_checkname: 'bar' | ||
39 | singlevar(kind): 'VGLOBAL' | ||
40 | expr_stat: assignment k='VGLOBAL' | ||
41 | assignment: '=' -- RHS elements follows | ||
42 | explist1: begin | ||
43 | expr: | ||
44 | prefixexp: <name> | ||
45 | str_checkname: 'foo' | ||
46 | singlevar(kind): 'VLOCAL' | ||
47 | explist1: end | ||
48 | -- STATEMENT: end 'expr' | ||
49 | |||
50 | leaveblock | ||
51 | block: end | ||
52 | do_stat: end | ||
53 | -- STATEMENT: end 'do' | ||
54 | |||
55 | -- STATEMENT: begin 'expr' line=5 | ||
56 | prefixexp: <name> | ||
57 | str_checkname: 'baz' | ||
58 | singlevar(kind): 'VGLOBAL' | ||
59 | expr_stat: assignment k='VGLOBAL' | ||
60 | assignment: '=' -- RHS elements follows | ||
61 | explist1: begin | ||
62 | expr: | ||
63 | prefixexp: <name> | ||
64 | str_checkname: 'foo' | ||
65 | singlevar(kind): 'VGLOBAL' | ||
66 | explist1: end | ||
67 | -- STATEMENT: end 'expr' | ||
68 | |||
69 | close_func | ||
70 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_24.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_24.lua new file mode 100644 index 0000000..6403234 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_24.lua | |||
@@ -0,0 +1,84 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | local foo | ||
3 | local function bar() | ||
4 | baz = nil | ||
5 | foo = bar() | ||
6 | end | ||
7 | foo = bar | ||
8 | -- END OF SOURCE -- | ||
9 | |||
10 | -- TOP: begin | ||
11 | open_func | ||
12 | |||
13 | chunk: | ||
14 | -- STATEMENT: begin 'local' line=1 | ||
15 | local_stat: local statement | ||
16 | localstat: begin | ||
17 | str_checkname: 'foo' | ||
18 | new_localvar: 'foo' | ||
19 | localstat: end | ||
20 | -- STATEMENT: end 'local' | ||
21 | |||
22 | -- STATEMENT: begin 'local' line=2 | ||
23 | local_stat: local function | ||
24 | localfunc: begin | ||
25 | str_checkname: 'bar' | ||
26 | new_localvar: 'bar' | ||
27 | localfunc: body | ||
28 | open_func | ||
29 | body: begin | ||
30 | body: parlist | ||
31 | parlist: begin | ||
32 | parlist: end | ||
33 | body: chunk | ||
34 | chunk: | ||
35 | -- STATEMENT: begin 'expr' line=3 | ||
36 | prefixexp: <name> | ||
37 | str_checkname: 'baz' | ||
38 | singlevar(kind): 'VGLOBAL' | ||
39 | expr_stat: assignment k='VGLOBAL' | ||
40 | assignment: '=' -- RHS elements follows | ||
41 | explist1: begin | ||
42 | expr: | ||
43 | simpleexp: nil | ||
44 | explist1: end | ||
45 | -- STATEMENT: end 'expr' | ||
46 | |||
47 | -- STATEMENT: begin 'expr' line=4 | ||
48 | prefixexp: <name> | ||
49 | str_checkname: 'foo' | ||
50 | singlevar(kind): 'VUPVAL' | ||
51 | expr_stat: assignment k='VUPVAL' | ||
52 | assignment: '=' -- RHS elements follows | ||
53 | explist1: begin | ||
54 | expr: | ||
55 | prefixexp: <name> | ||
56 | str_checkname: 'bar' | ||
57 | singlevar(kind): 'VUPVAL' | ||
58 | primaryexp: ( funcargs | ||
59 | funcargs: begin '(' | ||
60 | funcargs: end -- expr is a VCALL | ||
61 | explist1: end | ||
62 | -- STATEMENT: end 'expr' | ||
63 | |||
64 | body: end | ||
65 | close_func | ||
66 | localfunc: end | ||
67 | -- STATEMENT: end 'local' | ||
68 | |||
69 | -- STATEMENT: begin 'expr' line=6 | ||
70 | prefixexp: <name> | ||
71 | str_checkname: 'foo' | ||
72 | singlevar(kind): 'VLOCAL' | ||
73 | expr_stat: assignment k='VLOCAL' | ||
74 | assignment: '=' -- RHS elements follows | ||
75 | explist1: begin | ||
76 | expr: | ||
77 | prefixexp: <name> | ||
78 | str_checkname: 'bar' | ||
79 | singlevar(kind): 'VLOCAL' | ||
80 | explist1: end | ||
81 | -- STATEMENT: end 'expr' | ||
82 | |||
83 | close_func | ||
84 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_25.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_25.lua new file mode 100644 index 0000000..594e267 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_25.lua | |||
@@ -0,0 +1,159 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | local foo | ||
3 | local function bar() | ||
4 | local function baz() | ||
5 | local foo, bar | ||
6 | foo = bar | ||
7 | foo = baz | ||
8 | end | ||
9 | foo = bar | ||
10 | foo = baz | ||
11 | end | ||
12 | foo = bar | ||
13 | foo = baz | ||
14 | -- END OF SOURCE -- | ||
15 | |||
16 | -- TOP: begin | ||
17 | open_func | ||
18 | |||
19 | chunk: | ||
20 | -- STATEMENT: begin 'local' line=1 | ||
21 | local_stat: local statement | ||
22 | localstat: begin | ||
23 | str_checkname: 'foo' | ||
24 | new_localvar: 'foo' | ||
25 | localstat: end | ||
26 | -- STATEMENT: end 'local' | ||
27 | |||
28 | -- STATEMENT: begin 'local' line=2 | ||
29 | local_stat: local function | ||
30 | localfunc: begin | ||
31 | str_checkname: 'bar' | ||
32 | new_localvar: 'bar' | ||
33 | localfunc: body | ||
34 | open_func | ||
35 | body: begin | ||
36 | body: parlist | ||
37 | parlist: begin | ||
38 | parlist: end | ||
39 | body: chunk | ||
40 | chunk: | ||
41 | -- STATEMENT: begin 'local' line=3 | ||
42 | local_stat: local function | ||
43 | localfunc: begin | ||
44 | str_checkname: 'baz' | ||
45 | new_localvar: 'baz' | ||
46 | localfunc: body | ||
47 | open_func | ||
48 | body: begin | ||
49 | body: parlist | ||
50 | parlist: begin | ||
51 | parlist: end | ||
52 | body: chunk | ||
53 | chunk: | ||
54 | -- STATEMENT: begin 'local' line=4 | ||
55 | local_stat: local statement | ||
56 | localstat: begin | ||
57 | str_checkname: 'foo' | ||
58 | new_localvar: 'foo' | ||
59 | str_checkname: 'bar' | ||
60 | new_localvar: 'bar' | ||
61 | localstat: end | ||
62 | -- STATEMENT: end 'local' | ||
63 | |||
64 | -- STATEMENT: begin 'expr' line=5 | ||
65 | prefixexp: <name> | ||
66 | str_checkname: 'foo' | ||
67 | singlevar(kind): 'VLOCAL' | ||
68 | expr_stat: assignment k='VLOCAL' | ||
69 | assignment: '=' -- RHS elements follows | ||
70 | explist1: begin | ||
71 | expr: | ||
72 | prefixexp: <name> | ||
73 | str_checkname: 'bar' | ||
74 | singlevar(kind): 'VLOCAL' | ||
75 | explist1: end | ||
76 | -- STATEMENT: end 'expr' | ||
77 | |||
78 | -- STATEMENT: begin 'expr' line=6 | ||
79 | prefixexp: <name> | ||
80 | str_checkname: 'foo' | ||
81 | singlevar(kind): 'VLOCAL' | ||
82 | expr_stat: assignment k='VLOCAL' | ||
83 | assignment: '=' -- RHS elements follows | ||
84 | explist1: begin | ||
85 | expr: | ||
86 | prefixexp: <name> | ||
87 | str_checkname: 'baz' | ||
88 | singlevar(kind): 'VUPVAL' | ||
89 | explist1: end | ||
90 | -- STATEMENT: end 'expr' | ||
91 | |||
92 | body: end | ||
93 | close_func | ||
94 | localfunc: end | ||
95 | -- STATEMENT: end 'local' | ||
96 | |||
97 | -- STATEMENT: begin 'expr' line=8 | ||
98 | prefixexp: <name> | ||
99 | str_checkname: 'foo' | ||
100 | singlevar(kind): 'VUPVAL' | ||
101 | expr_stat: assignment k='VUPVAL' | ||
102 | assignment: '=' -- RHS elements follows | ||
103 | explist1: begin | ||
104 | expr: | ||
105 | prefixexp: <name> | ||
106 | str_checkname: 'bar' | ||
107 | singlevar(kind): 'VUPVAL' | ||
108 | explist1: end | ||
109 | -- STATEMENT: end 'expr' | ||
110 | |||
111 | -- STATEMENT: begin 'expr' line=9 | ||
112 | prefixexp: <name> | ||
113 | str_checkname: 'foo' | ||
114 | singlevar(kind): 'VUPVAL' | ||
115 | expr_stat: assignment k='VUPVAL' | ||
116 | assignment: '=' -- RHS elements follows | ||
117 | explist1: begin | ||
118 | expr: | ||
119 | prefixexp: <name> | ||
120 | str_checkname: 'baz' | ||
121 | singlevar(kind): 'VLOCAL' | ||
122 | explist1: end | ||
123 | -- STATEMENT: end 'expr' | ||
124 | |||
125 | body: end | ||
126 | close_func | ||
127 | localfunc: end | ||
128 | -- STATEMENT: end 'local' | ||
129 | |||
130 | -- STATEMENT: begin 'expr' line=11 | ||
131 | prefixexp: <name> | ||
132 | str_checkname: 'foo' | ||
133 | singlevar(kind): 'VLOCAL' | ||
134 | expr_stat: assignment k='VLOCAL' | ||
135 | assignment: '=' -- RHS elements follows | ||
136 | explist1: begin | ||
137 | expr: | ||
138 | prefixexp: <name> | ||
139 | str_checkname: 'bar' | ||
140 | singlevar(kind): 'VLOCAL' | ||
141 | explist1: end | ||
142 | -- STATEMENT: end 'expr' | ||
143 | |||
144 | -- STATEMENT: begin 'expr' line=12 | ||
145 | prefixexp: <name> | ||
146 | str_checkname: 'foo' | ||
147 | singlevar(kind): 'VLOCAL' | ||
148 | expr_stat: assignment k='VLOCAL' | ||
149 | assignment: '=' -- RHS elements follows | ||
150 | explist1: begin | ||
151 | expr: | ||
152 | prefixexp: <name> | ||
153 | str_checkname: 'baz' | ||
154 | singlevar(kind): 'VGLOBAL' | ||
155 | explist1: end | ||
156 | -- STATEMENT: end 'expr' | ||
157 | |||
158 | close_func | ||
159 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_26.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_26.lua new file mode 100644 index 0000000..bfa3920 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_26.lua | |||
@@ -0,0 +1,53 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | function foo:bar() | ||
3 | print(self) | ||
4 | end | ||
5 | -- END OF SOURCE -- | ||
6 | |||
7 | -- TOP: begin | ||
8 | open_func | ||
9 | |||
10 | chunk: | ||
11 | -- STATEMENT: begin 'function' line=1 | ||
12 | function_stat: begin | ||
13 | funcname: begin | ||
14 | str_checkname: 'foo' | ||
15 | singlevar(kind): 'VGLOBAL' | ||
16 | funcname: -- ':' field | ||
17 | field: operator=: | ||
18 | checkname: | ||
19 | str_checkname: 'bar' | ||
20 | codestring: "bar" | ||
21 | funcname: end | ||
22 | function_stat: body needself='true' | ||
23 | open_func | ||
24 | body: begin | ||
25 | new_localvar: 'self' | ||
26 | body: parlist | ||
27 | parlist: begin | ||
28 | parlist: end | ||
29 | body: chunk | ||
30 | chunk: | ||
31 | -- STATEMENT: begin 'expr' line=2 | ||
32 | prefixexp: <name> | ||
33 | str_checkname: 'print' | ||
34 | singlevar(kind): 'VGLOBAL' | ||
35 | primaryexp: ( funcargs | ||
36 | funcargs: begin '(' | ||
37 | explist1: begin | ||
38 | expr: | ||
39 | prefixexp: <name> | ||
40 | str_checkname: 'self' | ||
41 | singlevar(kind): 'VLOCAL' | ||
42 | explist1: end | ||
43 | funcargs: end -- expr is a VCALL | ||
44 | expr_stat: function call k='VCALL' | ||
45 | -- STATEMENT: end 'expr' | ||
46 | |||
47 | body: end | ||
48 | close_func | ||
49 | function_stat: end | ||
50 | -- STATEMENT: end 'function' | ||
51 | |||
52 | close_func | ||
53 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_27.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_27.lua new file mode 100644 index 0000000..77db3ef --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_27.lua | |||
@@ -0,0 +1,48 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | function foo(...) | ||
3 | print(arg) | ||
4 | end | ||
5 | -- END OF SOURCE -- | ||
6 | |||
7 | -- TOP: begin | ||
8 | open_func | ||
9 | |||
10 | chunk: | ||
11 | -- STATEMENT: begin 'function' line=1 | ||
12 | function_stat: begin | ||
13 | funcname: begin | ||
14 | str_checkname: 'foo' | ||
15 | singlevar(kind): 'VGLOBAL' | ||
16 | funcname: end | ||
17 | function_stat: body needself='false' | ||
18 | open_func | ||
19 | body: begin | ||
20 | body: parlist | ||
21 | parlist: begin | ||
22 | parlist: ... (dots) | ||
23 | parlist: end | ||
24 | body: chunk | ||
25 | chunk: | ||
26 | -- STATEMENT: begin 'expr' line=2 | ||
27 | prefixexp: <name> | ||
28 | str_checkname: 'print' | ||
29 | singlevar(kind): 'VGLOBAL' | ||
30 | primaryexp: ( funcargs | ||
31 | funcargs: begin '(' | ||
32 | explist1: begin | ||
33 | expr: | ||
34 | prefixexp: <name> | ||
35 | str_checkname: 'arg' | ||
36 | singlevar(kind): 'VGLOBAL' | ||
37 | explist1: end | ||
38 | funcargs: end -- expr is a VCALL | ||
39 | expr_stat: function call k='VCALL' | ||
40 | -- STATEMENT: end 'expr' | ||
41 | |||
42 | body: end | ||
43 | close_func | ||
44 | function_stat: end | ||
45 | -- STATEMENT: end 'function' | ||
46 | |||
47 | close_func | ||
48 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_28.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_28.lua new file mode 100644 index 0000000..e4c9e21 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_28.lua | |||
@@ -0,0 +1,79 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | local c,d | ||
3 | function foo(a,b,c) | ||
4 | print(a,c,d,e) | ||
5 | end | ||
6 | -- END OF SOURCE -- | ||
7 | |||
8 | -- TOP: begin | ||
9 | open_func | ||
10 | |||
11 | chunk: | ||
12 | -- STATEMENT: begin 'local' line=1 | ||
13 | local_stat: local statement | ||
14 | localstat: begin | ||
15 | str_checkname: 'c' | ||
16 | new_localvar: 'c' | ||
17 | str_checkname: 'd' | ||
18 | new_localvar: 'd' | ||
19 | localstat: end | ||
20 | -- STATEMENT: end 'local' | ||
21 | |||
22 | -- STATEMENT: begin 'function' line=2 | ||
23 | function_stat: begin | ||
24 | funcname: begin | ||
25 | str_checkname: 'foo' | ||
26 | singlevar(kind): 'VGLOBAL' | ||
27 | funcname: end | ||
28 | function_stat: body needself='false' | ||
29 | open_func | ||
30 | body: begin | ||
31 | body: parlist | ||
32 | parlist: begin | ||
33 | str_checkname: 'a' | ||
34 | new_localvar: 'a' | ||
35 | str_checkname: 'b' | ||
36 | new_localvar: 'b' | ||
37 | str_checkname: 'c' | ||
38 | new_localvar: 'c' | ||
39 | parlist: end | ||
40 | body: chunk | ||
41 | chunk: | ||
42 | -- STATEMENT: begin 'expr' line=3 | ||
43 | prefixexp: <name> | ||
44 | str_checkname: 'print' | ||
45 | singlevar(kind): 'VGLOBAL' | ||
46 | primaryexp: ( funcargs | ||
47 | funcargs: begin '(' | ||
48 | explist1: begin | ||
49 | expr: | ||
50 | prefixexp: <name> | ||
51 | str_checkname: 'a' | ||
52 | singlevar(kind): 'VLOCAL' | ||
53 | explist1: ',' -- continuation | ||
54 | expr: | ||
55 | prefixexp: <name> | ||
56 | str_checkname: 'c' | ||
57 | singlevar(kind): 'VLOCAL' | ||
58 | explist1: ',' -- continuation | ||
59 | expr: | ||
60 | prefixexp: <name> | ||
61 | str_checkname: 'd' | ||
62 | singlevar(kind): 'VUPVAL' | ||
63 | explist1: ',' -- continuation | ||
64 | expr: | ||
65 | prefixexp: <name> | ||
66 | str_checkname: 'e' | ||
67 | singlevar(kind): 'VGLOBAL' | ||
68 | explist1: end | ||
69 | funcargs: end -- expr is a VCALL | ||
70 | expr_stat: function call k='VCALL' | ||
71 | -- STATEMENT: end 'expr' | ||
72 | |||
73 | body: end | ||
74 | close_func | ||
75 | function_stat: end | ||
76 | -- STATEMENT: end 'function' | ||
77 | |||
78 | close_func | ||
79 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_29.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_29.lua new file mode 100644 index 0000000..b278ba2 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_29.lua | |||
@@ -0,0 +1,94 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | function foo(a,b) | ||
3 | local bar = function(c,d) | ||
4 | print(a,b,c,d) | ||
5 | end | ||
6 | end | ||
7 | -- END OF SOURCE -- | ||
8 | |||
9 | -- TOP: begin | ||
10 | open_func | ||
11 | |||
12 | chunk: | ||
13 | -- STATEMENT: begin 'function' line=1 | ||
14 | function_stat: begin | ||
15 | funcname: begin | ||
16 | str_checkname: 'foo' | ||
17 | singlevar(kind): 'VGLOBAL' | ||
18 | funcname: end | ||
19 | function_stat: body needself='false' | ||
20 | open_func | ||
21 | body: begin | ||
22 | body: parlist | ||
23 | parlist: begin | ||
24 | str_checkname: 'a' | ||
25 | new_localvar: 'a' | ||
26 | str_checkname: 'b' | ||
27 | new_localvar: 'b' | ||
28 | parlist: end | ||
29 | body: chunk | ||
30 | chunk: | ||
31 | -- STATEMENT: begin 'local' line=2 | ||
32 | local_stat: local statement | ||
33 | localstat: begin | ||
34 | str_checkname: 'bar' | ||
35 | new_localvar: 'bar' | ||
36 | localstat: -- assignment | ||
37 | explist1: begin | ||
38 | expr: | ||
39 | simpleexp: function | ||
40 | open_func | ||
41 | body: begin | ||
42 | body: parlist | ||
43 | parlist: begin | ||
44 | str_checkname: 'c' | ||
45 | new_localvar: 'c' | ||
46 | str_checkname: 'd' | ||
47 | new_localvar: 'd' | ||
48 | parlist: end | ||
49 | body: chunk | ||
50 | chunk: | ||
51 | -- STATEMENT: begin 'expr' line=3 | ||
52 | prefixexp: <name> | ||
53 | str_checkname: 'print' | ||
54 | singlevar(kind): 'VGLOBAL' | ||
55 | primaryexp: ( funcargs | ||
56 | funcargs: begin '(' | ||
57 | explist1: begin | ||
58 | expr: | ||
59 | prefixexp: <name> | ||
60 | str_checkname: 'a' | ||
61 | singlevar(kind): 'VUPVAL' | ||
62 | explist1: ',' -- continuation | ||
63 | expr: | ||
64 | prefixexp: <name> | ||
65 | str_checkname: 'b' | ||
66 | singlevar(kind): 'VUPVAL' | ||
67 | explist1: ',' -- continuation | ||
68 | expr: | ||
69 | prefixexp: <name> | ||
70 | str_checkname: 'c' | ||
71 | singlevar(kind): 'VLOCAL' | ||
72 | explist1: ',' -- continuation | ||
73 | expr: | ||
74 | prefixexp: <name> | ||
75 | str_checkname: 'd' | ||
76 | singlevar(kind): 'VLOCAL' | ||
77 | explist1: end | ||
78 | funcargs: end -- expr is a VCALL | ||
79 | expr_stat: function call k='VCALL' | ||
80 | -- STATEMENT: end 'expr' | ||
81 | |||
82 | body: end | ||
83 | close_func | ||
84 | explist1: end | ||
85 | localstat: end | ||
86 | -- STATEMENT: end 'local' | ||
87 | |||
88 | body: end | ||
89 | close_func | ||
90 | function_stat: end | ||
91 | -- STATEMENT: end 'function' | ||
92 | |||
93 | close_func | ||
94 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_30.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_30.lua new file mode 100644 index 0000000..3807d14 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_30.lua | |||
@@ -0,0 +1,119 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | for i = 1,10 do | ||
3 | print(i) | ||
4 | end | ||
5 | for i = 1,10,-2 do | ||
6 | print(i) | ||
7 | end | ||
8 | -- END OF SOURCE -- | ||
9 | |||
10 | -- TOP: begin | ||
11 | open_func | ||
12 | |||
13 | chunk: | ||
14 | -- STATEMENT: begin 'for' line=1 | ||
15 | for_stat: begin | ||
16 | enterblock(isbreakable=true) | ||
17 | str_checkname: 'i' | ||
18 | for_stat: numerical loop | ||
19 | new_localvar: '(for index)' | ||
20 | new_localvar: '(for limit)' | ||
21 | new_localvar: '(for step)' | ||
22 | new_localvar: 'i' | ||
23 | fornum: begin | ||
24 | fornum: index start | ||
25 | exp1: begin | ||
26 | expr: | ||
27 | simpleexp: <number>=1 | ||
28 | exp1: end | ||
29 | fornum: index stop | ||
30 | exp1: begin | ||
31 | expr: | ||
32 | simpleexp: <number>=10 | ||
33 | exp1: end | ||
34 | fornum: body | ||
35 | enterblock(isbreakable=false) | ||
36 | block: begin | ||
37 | enterblock(isbreakable=false) | ||
38 | chunk: | ||
39 | -- STATEMENT: begin 'expr' line=2 | ||
40 | prefixexp: <name> | ||
41 | str_checkname: 'print' | ||
42 | singlevar(kind): 'VGLOBAL' | ||
43 | primaryexp: ( funcargs | ||
44 | funcargs: begin '(' | ||
45 | explist1: begin | ||
46 | expr: | ||
47 | prefixexp: <name> | ||
48 | str_checkname: 'i' | ||
49 | singlevar(kind): 'VLOCAL' | ||
50 | explist1: end | ||
51 | funcargs: end -- expr is a VCALL | ||
52 | expr_stat: function call k='VCALL' | ||
53 | -- STATEMENT: end 'expr' | ||
54 | |||
55 | leaveblock | ||
56 | block: end | ||
57 | leaveblock | ||
58 | fornum: end | ||
59 | leaveblock | ||
60 | for_stat: end | ||
61 | -- STATEMENT: end 'for' | ||
62 | |||
63 | -- STATEMENT: begin 'for' line=4 | ||
64 | for_stat: begin | ||
65 | enterblock(isbreakable=true) | ||
66 | str_checkname: 'i' | ||
67 | for_stat: numerical loop | ||
68 | new_localvar: '(for index)' | ||
69 | new_localvar: '(for limit)' | ||
70 | new_localvar: '(for step)' | ||
71 | new_localvar: 'i' | ||
72 | fornum: begin | ||
73 | fornum: index start | ||
74 | exp1: begin | ||
75 | expr: | ||
76 | simpleexp: <number>=1 | ||
77 | exp1: end | ||
78 | fornum: index stop | ||
79 | exp1: begin | ||
80 | expr: | ||
81 | simpleexp: <number>=10 | ||
82 | exp1: end | ||
83 | fornum: index step | ||
84 | exp1: begin | ||
85 | expr: | ||
86 | subexpr: uop='-' | ||
87 | simpleexp: <number>=2 | ||
88 | exp1: end | ||
89 | fornum: body | ||
90 | enterblock(isbreakable=false) | ||
91 | block: begin | ||
92 | enterblock(isbreakable=false) | ||
93 | chunk: | ||
94 | -- STATEMENT: begin 'expr' line=5 | ||
95 | prefixexp: <name> | ||
96 | str_checkname: 'print' | ||
97 | singlevar(kind): 'VGLOBAL' | ||
98 | primaryexp: ( funcargs | ||
99 | funcargs: begin '(' | ||
100 | explist1: begin | ||
101 | expr: | ||
102 | prefixexp: <name> | ||
103 | str_checkname: 'i' | ||
104 | singlevar(kind): 'VLOCAL' | ||
105 | explist1: end | ||
106 | funcargs: end -- expr is a VCALL | ||
107 | expr_stat: function call k='VCALL' | ||
108 | -- STATEMENT: end 'expr' | ||
109 | |||
110 | leaveblock | ||
111 | block: end | ||
112 | leaveblock | ||
113 | fornum: end | ||
114 | leaveblock | ||
115 | for_stat: end | ||
116 | -- STATEMENT: end 'for' | ||
117 | |||
118 | close_func | ||
119 | -- TOP: end | ||
diff --git a/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_31.lua b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_31.lua new file mode 100644 index 0000000..0d0a602 --- /dev/null +++ b/LuaSL/testLua/yueliang-0.4.1/nat-5.1.3/test/parser_log/sample_31.lua | |||
@@ -0,0 +1,127 @@ | |||
1 | -- START OF SOURCE -- | ||
2 | for foo in bar() do | ||
3 | print(foo) | ||
4 | end | ||
5 | for foo,bar,baz in spring() do | ||
6 | print(foo,bar,baz) | ||
7 | end | ||
8 | -- END OF SOURCE -- | ||
9 | |||
10 | -- TOP: begin | ||
11 | open_func | ||
12 | |||
13 | chunk: | ||
14 | -- STATEMENT: begin 'for' line=1 | ||
15 | for_stat: begin | ||
16 | enterblock(isbreakable=true) | ||
17 | str_checkname: 'foo' | ||
18 | for_stat: list-based loop | ||
19 | forlist: begin | ||
20 | new_localvar: '(for generator)' | ||
21 | new_localvar: '(for state)' | ||
22 | new_localvar: '(for control)' | ||
23 | new_localvar: 'foo' | ||
24 | forlist: explist1 | ||
25 | explist1: begin | ||
26 | expr: | ||
27 | prefixexp: <name> | ||
28 | str_checkname: 'bar' | ||
29 | singlevar(kind): 'VGLOBAL' | ||
30 | primaryexp: ( funcargs | ||
31 | funcargs: begin '(' | ||
32 | funcargs: end -- expr is a VCALL | ||
33 | explist1: end | ||
34 | forlist: body | ||
35 | enterblock(isbreakable=false) | ||
36 | block: begin | ||
37 | enterblock(isbreakable=false) | ||
38 | chunk: | ||
39 | -- STATEMENT: begin 'expr' line=2 | ||
40 | prefixexp: <name> | ||
41 | str_checkname: 'print' | ||
42 | singlevar(kind): 'VGLOBAL' | ||
43 | primaryexp: ( funcargs | ||
44 | funcargs: begin '(' | ||
45 | explist1: begin | ||
46 | expr: | ||
47 | prefixexp: <name> | ||
48 | str_checkname: 'foo' | ||
49 | singlevar(kind): 'VLOCAL' | ||
50 | explist1: end | ||
51 | funcargs: end -- expr is a VCALL | ||
52 | expr_stat: function call k='VCALL' | ||
53 | -- STATEMENT: end 'expr' | ||
54 | |||
55 | leaveblock | ||
56 | block: end | ||
57 | leaveblock | ||
58 | forlist: end | ||
59 | leaveblock | ||
60 | for_stat: end | ||
61 | -- STATEMENT: end 'for' | ||
62 | |||
63 | -- STATEMENT: begin 'for' line=4 | ||
64 | for_stat: begin | ||
65 | enterblock(isbreakable=true) | ||
66 | str_checkname: 'foo' | ||
67 | for_stat: list-based loop | ||
68 | forlist: begin | ||
69 | new_localvar: '(for generator)' | ||
70 | new_localvar: '(for state)' | ||
71 | new_localvar: '(for control)' | ||
72 | new_localvar: 'foo' | ||
73 | str_checkname: 'bar' | ||
74 | new_localvar: 'bar' | ||
75 | str_checkname: 'baz' | ||
76 | new_localvar: 'baz' | ||
77 | forlist: explist1 | ||
78 | explist1: begin | ||
79 | expr: | ||
80 | prefixexp: <name> | ||
81 | str_checkname: 'spring' | ||
82 | singlevar(kind): 'VGLOBAL' | ||
83 | primaryexp: ( funcargs | ||
84 | funcargs: begin '(' | ||
85 | funcargs: end -- expr is a VCALL | ||
86 | explist1: end | ||
87 | forlist: body | ||
88 | enterblock(isbreakable=false) | ||
89 | block: begin | ||
90 | enterblock(isbreakable=false) | ||
91 | chunk: | ||
92 | -- STATEMENT: begin 'expr' line=5 | ||
93 | prefixexp: <name> | ||
94 | str_checkname: 'print' | ||
95 | singlevar(kind): 'VGLOBAL' | ||
96 | primaryexp: ( funcargs | ||
97 | funcargs: begin '(' | ||
98 | explist1: begin | ||
99 | expr: | ||
100 | prefixexp: <name> | ||
101 | str_checkname: 'foo' | ||
102 | singlevar(kind): 'VLOCAL' | ||
103 | explist1: ',' -- continuation | ||
104 | expr: | ||
105 | prefixexp: <name> | ||
106 | str_checkname: 'bar' | ||
107 | singlevar(kind): 'VLOCAL' | ||
108 | explist1: ',' -- continuation | ||
109 | expr: | ||
110 | prefixexp: <name> | ||
111 | str_checkname: 'baz' | ||
112 | singlevar(kind): 'VLOCAL' | ||
113 | explist1: end | ||
114 | funcargs: end -- expr is a VCALL | ||
115 | expr_stat: function call k='VCALL' | ||
116 | -- STATEMENT: end 'expr' | ||
117 | |||
118 | leaveblock | ||
119 | block: end | ||
120 | leaveblock | ||
121 | forlist: end | ||
122 | leaveblock | ||
123 | for_stat: end | ||
124 | -- STATEMENT: end 'for' | ||
125 | |||
126 | close_func | ||
127 | -- TOP: end | ||