ruby2c 1.0.0.9 → 1.1.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (29) hide show
  1. checksums.yaml +7 -0
  2. checksums.yaml.gz.sig +1 -0
  3. data/History.txt +78 -53
  4. data/README.txt +1 -1
  5. data/Rakefile +2 -0
  6. data/lib/crewriter.rb +35 -23
  7. data/lib/r2cenvironment.rb +3 -3
  8. data/lib/rewriter.rb +6 -2
  9. data/lib/ruby_to_ansi_c.rb +18 -18
  10. data/lib/ruby_to_ruby_c.rb +3 -3
  11. data/lib/type.rb +3 -3
  12. data/lib/type_checker.rb +101 -99
  13. data/lib/typed_sexp.rb +49 -25
  14. data/test/r2ctestcase.rb +321 -288
  15. data/test/test_crewriter.rb +127 -128
  16. data/test/test_extras.rb +4 -4
  17. data/test/test_function_table.rb +23 -23
  18. data/test/test_function_type.rb +39 -40
  19. data/test/test_handle.rb +2 -2
  20. data/test/test_r2cenvironment.rb +38 -38
  21. data/test/test_ruby_to_ansi_c.rb +58 -58
  22. data/test/test_ruby_to_ruby_c.rb +26 -26
  23. data/test/test_type.rb +38 -38
  24. data/test/test_type_checker.rb +165 -165
  25. data/test/test_typed_sexp.rb +62 -54
  26. data.tar.gz.sig +2 -1
  27. metadata +101 -153
  28. metadata.gz.sig +0 -0
  29. data/.gemtest +0 -0
data/test/r2ctestcase.rb CHANGED
@@ -7,9 +7,8 @@ require 'unique'
7
7
  # TODO: add tests that mix types up to fuck up RubyC type checker
8
8
 
9
9
  class R2CTestCase < ParseTreeTestCase
10
-
11
10
  def self.add_skipped_tests *names
12
- names.each do |name|
11
+ names.flatten.each do |name|
13
12
  add_tests(name,
14
13
  "Rewriter" => :same,
15
14
  "TypeChecker" => :skip,
@@ -19,6 +18,10 @@ class R2CTestCase < ParseTreeTestCase
19
18
  end
20
19
  end
21
20
 
21
+ def self.add_skipped_tests19 *names
22
+ add_skipped_tests names.map { |s| "#{s}_#{TEST_SUFFIX}" }
23
+ end
24
+
22
25
  testcase_order.push(*%w(Ruby ParseTree Rewriter TypeChecker
23
26
  CRewriter RubyToAnsiC RubyToRubyC))
24
27
 
@@ -27,9 +30,9 @@ class R2CTestCase < ParseTreeTestCase
27
30
  add_tests("and",
28
31
  "Rewriter" => :same,
29
32
  "TypeChecker" => t(:and,
30
- t(:call, nil, :a, t(:arglist), Type.bool),
31
- t(:call, nil, :b, t(:arglist), Type.bool),
32
- Type.bool),
33
+ t(:call, nil, :a, t(:arglist), CType.bool),
34
+ t(:call, nil, :b, t(:arglist), CType.bool),
35
+ CType.bool),
33
36
  "CRewriter" => :same,
34
37
  "RubyToAnsiC" => "a() && b()",
35
38
  "RubyToRubyC" => 'rb_funcall(self, rb_intern("a"), 0) && rb_funcall(self, rb_intern("b"), 0)')
@@ -37,10 +40,10 @@ class R2CTestCase < ParseTreeTestCase
37
40
  add_tests("array",
38
41
  "Rewriter" => :same,
39
42
  "TypeChecker" => t(:array,
40
- t(:lit, 1, Type.long),
41
- t(:lit, :b, Type.symbol),
42
- t(:str, "c", Type.str),
43
- Type.hetero),
43
+ t(:lit, 1, CType.long),
44
+ t(:lit, :b, CType.symbol),
45
+ t(:str, "c", CType.str),
46
+ CType.hetero),
44
47
  "CRewriter" => :same,
45
48
  "RubyToAnsiC" => "1, \"b\", \"c\"",
46
49
  "RubyToRubyC" => "LONG2NUM(1), ID2SYM(rb_intern(\"b\")), rb_str_new2(\"c\")")
@@ -48,9 +51,9 @@ class R2CTestCase < ParseTreeTestCase
48
51
  add_tests("array_pct_W",
49
52
  "Rewriter" => :same,
50
53
  "TypeChecker" => t(:array,
51
- t(:str, "a", Type.str),
52
- t(:str, "b", Type.str),
53
- t(:str, "c", Type.str)),
54
+ t(:str, "a", CType.str),
55
+ t(:str, "b", CType.str),
56
+ t(:str, "c", CType.str)),
54
57
  "CRewriter" => :same,
55
58
  "RubyToAnsiC" => "\"a\", \"b\", \"c\"",
56
59
  "RubyToRubyC" => "rb_str_new2(\"a\"), rb_str_new2(\"b\"), rb_str_new2(\"c\")")
@@ -58,9 +61,9 @@ class R2CTestCase < ParseTreeTestCase
58
61
  add_tests("array_pct_w",
59
62
  "Rewriter" => :same,
60
63
  "TypeChecker" => t(:array,
61
- t(:str, "a", Type.str),
62
- t(:str, "b", Type.str),
63
- t(:str, "c", Type.str)),
64
+ t(:str, "a", CType.str),
65
+ t(:str, "b", CType.str),
66
+ t(:str, "c", CType.str)),
64
67
  "CRewriter" => :same,
65
68
  "RubyToAnsiC" => "\"a\", \"b\", \"c\"",
66
69
  "RubyToRubyC" => "rb_str_new2(\"a\"), rb_str_new2(\"b\"), rb_str_new2(\"c\")")
@@ -68,11 +71,11 @@ class R2CTestCase < ParseTreeTestCase
68
71
  add_tests("attrasgn_index_equals",
69
72
  "Rewriter" => :same,
70
73
  "TypeChecker" => t(:attrasgn,
71
- t(:call, nil, :a, t(:arglist), Type.unknown),
74
+ t(:call, nil, :a, t(:arglist), CType.unknown),
72
75
  :[]=,
73
76
  t(:arglist,
74
- t(:lit, 42, Type.long),
75
- t(:lit, 24, Type.long))),
77
+ t(:lit, 42, CType.long),
78
+ t(:lit, 24, CType.long))),
76
79
  "CRewriter" => :same,
77
80
  "RubyToAnsiC" => :skip,
78
81
  "RubyToRubyC" => :skip) # TODO: rubyc should be ok with this
@@ -80,63 +83,41 @@ class R2CTestCase < ParseTreeTestCase
80
83
  add_tests("attrasgn_index_equals_space",
81
84
  "Rewriter" => :same,
82
85
  "TypeChecker" => t(:block,
83
- t(:lasgn, :a, t(:array), Type.unknown_list),
86
+ t(:lasgn, :a, t(:array), CType.unknown_list),
84
87
  t(:attrasgn,
85
- t(:lvar, :a, Type.unknown_list),
88
+ t(:lvar, :a, CType.unknown_list),
86
89
  :[]=,
87
90
  t(:arglist,
88
- t(:lit, 42, Type.long),
89
- t(:lit, 24, Type.long))), Type.unknown),
91
+ t(:lit, 42, CType.long),
92
+ t(:lit, 24, CType.long))), CType.unknown),
90
93
  "CRewriter" => :same,
91
94
  "RubyToAnsiC" => :skip,
92
95
  "RubyToRubyC" => :skip) # TODO: rubyc should be ok with this
93
96
 
94
- add_tests("attrset",
95
- "Rewriter" => s(:defn, :writer=,
96
- s(:args, :arg),
97
- s(:scope,
98
- s(:block,
99
- s(:return,
100
- s(:iasgn, :@writer, s(:lvar, :arg)))))),
101
- "TypeChecker" => t(:defn, :writer=,
102
- t(:args, t(:arg, Type.unknown)),
103
- t(:scope,
104
- t(:block,
105
- t(:return,
106
- t(:iasgn, :@writer,
107
- t(:lvar, :arg, Type.unknown),
108
- Type.unknown),
109
- Type.void), Type.unknown), Type.void),
110
- Type.function(Type.unknown,
111
- [Type.unknown], Type.unknown)),
112
- "CRewriter" => :same,
113
- "RubyToAnsiC" => "void *\nwriter=(void * arg) {\nreturn self->writer = arg;\n}",
114
- "RubyToRubyC" => "static VALUE\nrrc_c_writer_equals(VALUE self, VALUE arg) {\nreturn self->writer = arg;\n}")
115
-
116
97
  add_tests("bools", # NOTE: not in pttc
117
98
  "Rewriter" => :skip,
118
99
  # TODO: why does return false have type void?
119
100
  "TypeChecker" => t(:defn, :bools,
120
- t(:args, t(:arg1, Type.value)),
101
+ t(:args, t(:arg1, CType.value)),
121
102
  t(:scope,
122
103
  t(:block,
123
104
  t(:if,
124
105
  t(:call,
125
- t(:lvar, :arg1, Type.value),
106
+ t(:lvar, :arg1, CType.value),
126
107
  :nil?,
127
108
  nil,
128
- Type.bool),
109
+ CType.bool),
129
110
  t(:return,
130
- t(:false, Type.bool),
131
- Type.void),
111
+ t(:false, CType.bool),
112
+ CType.void),
132
113
  t(:return,
133
- t(:true, Type.bool),
134
- Type.void),
135
- Type.void),
136
- Type.unknown),
137
- Type.void),
138
- Type.function(Type.unknown,
139
- [Type.value], Type.bool)),
114
+ t(:true, CType.bool),
115
+ CType.void),
116
+ CType.void),
117
+ CType.unknown),
118
+ CType.void),
119
+ CType.function(CType.unknown,
120
+ [CType.value], CType.bool)),
140
121
  "CRewriter" => :same,
141
122
  "RubyToAnsiC" => "bool\nbools(void * arg1) {\nif (arg1) {\nreturn 0;\n} else {\nreturn 1;\n}\n}",
142
123
  "RubyToRubyC" => "static VALUE\nrrc_c_bools(VALUE self, VALUE arg1) {\nif (NIL_P(arg1)) {\nreturn Qfalse;\n} else {\nreturn Qtrue;\n}\n}")
@@ -149,96 +130,96 @@ class R2CTestCase < ParseTreeTestCase
149
130
  t(:block,
150
131
  t(:lasgn,
151
132
  :var,
152
- t(:lit, 2, Type.long),
153
- Type.long),
133
+ t(:lit, 2, CType.long),
134
+ CType.long),
154
135
  t(:lasgn,
155
136
  :result,
156
- t(:str, "", Type.str),
157
- Type.str),
137
+ t(:str, "", CType.str),
138
+ CType.str),
158
139
  t(:if,
159
140
  t(:call,
160
- t(:lvar, :var, Type.long),
141
+ t(:lvar, :var, CType.long),
161
142
  :case_equal_long,
162
- t(:arglist, t(:lit, 1, Type.long)),
163
- Type.bool),
143
+ t(:arglist, t(:lit, 1, CType.long)),
144
+ CType.bool),
164
145
  t(:block,
165
146
  t(:call,
166
147
  nil,
167
148
  :puts,
168
149
  t(:arglist,
169
- t(:str, "something", Type.str)),
170
- Type.void),
150
+ t(:str, "something", CType.str)),
151
+ CType.void),
171
152
  t(:lasgn,
172
153
  :result,
173
- t(:str, "red", Type.str),
174
- Type.str),
175
- Type.str),
154
+ t(:str, "red", CType.str),
155
+ CType.str),
156
+ CType.str),
176
157
  t(:if,
177
158
  t(:or,
178
159
  t(:call,
179
- t(:lvar, :var, Type.long),
160
+ t(:lvar, :var, CType.long),
180
161
  :case_equal_long,
181
- t(:arglist, t(:lit, 2, Type.long)),
182
- Type.bool),
162
+ t(:arglist, t(:lit, 2, CType.long)),
163
+ CType.bool),
183
164
  t(:call,
184
- t(:lvar, :var, Type.long),
165
+ t(:lvar, :var, CType.long),
185
166
  :case_equal_long,
186
- t(:arglist, t(:lit, 3, Type.long)),
187
- Type.bool),
188
- Type.bool),
167
+ t(:arglist, t(:lit, 3, CType.long)),
168
+ CType.bool),
169
+ CType.bool),
189
170
  t(:lasgn,
190
171
  :result,
191
- t(:str, "yellow", Type.str),
192
- Type.str),
172
+ t(:str, "yellow", CType.str),
173
+ CType.str),
193
174
  t(:if,
194
175
  t(:call,
195
- t(:lvar, :var, Type.long),
176
+ t(:lvar, :var, CType.long),
196
177
  :case_equal_long,
197
- t(:arglist, t(:lit, 4, Type.long)),
198
- Type.bool),
178
+ t(:arglist, t(:lit, 4, CType.long)),
179
+ CType.bool),
199
180
  nil,
200
181
  t(:lasgn,
201
182
  :result,
202
- t(:str, "green", Type.str),
203
- Type.str),
204
- Type.str),
205
- Type.str),
206
- Type.str),
183
+ t(:str, "green", CType.str),
184
+ CType.str),
185
+ CType.str),
186
+ CType.str),
187
+ CType.str),
207
188
  t(:if,
208
189
  t(:call,
209
- t(:lvar, :result, Type.str),
190
+ t(:lvar, :result, CType.str),
210
191
  :case_equal_str,
211
- t(:arglist, t(:str, "red", Type.str)),
212
- Type.bool),
213
- t(:lasgn, :var, t(:lit, 1, Type.long), Type.long),
192
+ t(:arglist, t(:str, "red", CType.str)),
193
+ CType.bool),
194
+ t(:lasgn, :var, t(:lit, 1, CType.long), CType.long),
214
195
  t(:if,
215
196
  t(:call,
216
- t(:lvar, :result, Type.str),
197
+ t(:lvar, :result, CType.str),
217
198
  :case_equal_str,
218
- t(:arglist, t(:str, "yellow", Type.str)),
219
- Type.bool),
220
- t(:lasgn, :var, t(:lit, 2, Type.long), Type.long),
199
+ t(:arglist, t(:str, "yellow", CType.str)),
200
+ CType.bool),
201
+ t(:lasgn, :var, t(:lit, 2, CType.long), CType.long),
221
202
  t(:if,
222
203
  t(:call,
223
- t(:lvar, :result, Type.str),
204
+ t(:lvar, :result, CType.str),
224
205
  :case_equal_str,
225
206
  t(:arglist,
226
- t(:str, "green", Type.str)),
227
- Type.bool),
207
+ t(:str, "green", CType.str)),
208
+ CType.bool),
228
209
  t(:lasgn,
229
210
  :var,
230
- t(:lit, 3, Type.long),
231
- Type.long),
211
+ t(:lit, 3, CType.long),
212
+ CType.long),
232
213
  nil,
233
- Type.long),
234
- Type.long),
235
- Type.long),
214
+ CType.long),
215
+ CType.long),
216
+ CType.long),
236
217
  t(:return,
237
- t(:lvar, :result, Type.str),
238
- Type.void),
239
- Type.unknown),
240
- Type.void),
241
- Type.function(Type.unknown, [], Type.str)),
218
+ t(:lvar, :result, CType.str),
219
+ CType.void),
220
+ CType.unknown),
221
+ CType.void),
222
+ CType.function(CType.unknown, [], CType.str)),
242
223
  "CRewriter" => :same,
243
224
  # HACK: I don't like the semis after the if blocks, but it is a compromise right now
244
225
  "RubyToAnsiC" => "str\ncase_stmt() {\nstr result;\nlong var;\nvar = 2;\nresult = \"\";\nif (case_equal_long(var, 1)) {\nputs(\"something\");\nresult = \"red\";\n} else {\nif (case_equal_long(var, 2) || case_equal_long(var, 3)) {\nresult = \"yellow\";\n} else {\nif (case_equal_long(var, 4)) {\n;\n} else {\nresult = \"green\";\n}\n}\n};\nif (case_equal_str(result, \"red\")) {\nvar = 1;\n} else {\nif (case_equal_str(result, \"yellow\")) {\nvar = 2;\n} else {\nif (case_equal_str(result, \"green\")) {\nvar = 3;\n}\n}\n};\nreturn result;\n}",
@@ -250,10 +231,10 @@ class R2CTestCase < ParseTreeTestCase
250
231
  t(:args),
251
232
  t(:scope,
252
233
  t(:block,
253
- t(:nil, Type.value),
254
- Type.unknown),
255
- Type.void),
256
- Type.function(Type.unknown, [], Type.void)),
234
+ t(:nil, CType.value),
235
+ CType.unknown),
236
+ CType.void),
237
+ CType.function(CType.unknown, [], CType.void)),
257
238
  "CRewriter" => :same,
258
239
  "RubyToAnsiC" => "void\nempty() {\nNULL;\n}",
259
240
  "RubyToRubyC" => "static VALUE\nrrc_c_empty(VALUE self) {\nQnil;\n}")
@@ -264,10 +245,10 @@ class R2CTestCase < ParseTreeTestCase
264
245
  t(:args),
265
246
  t(:scope,
266
247
  t(:block,
267
- t(:nil, Type.value),
268
- Type.unknown),
269
- Type.void),
270
- Type.function(Type.unknown, [], Type.void)),
248
+ t(:nil, CType.value),
249
+ CType.unknown),
250
+ CType.void),
251
+ CType.function(CType.unknown, [], CType.void)),
271
252
  "CRewriter" => :same,
272
253
  "RubyToAnsiC" => "void\nis_something() {\nNULL;\n}",
273
254
  "RubyToRubyC" => "static VALUE\nrrc_c_is_something(VALUE self) {\nQnil;\n}")
@@ -275,14 +256,14 @@ class R2CTestCase < ParseTreeTestCase
275
256
  add_tests("defn_or",
276
257
  "Rewriter" => :same,
277
258
  "TypeChecker" => t(:defn, :|,
278
- t(:args, t(:o, Type.unknown)),
259
+ t(:args, t(:o, CType.unknown)),
279
260
  t(:scope,
280
261
  t(:block,
281
- t(:nil, Type.value),
282
- Type.unknown),
283
- Type.void),
284
- Type.function(Type.unknown, [Type.unknown],
285
- Type.void)),
262
+ t(:nil, CType.value),
263
+ CType.unknown),
264
+ CType.void),
265
+ CType.function(CType.unknown, [CType.unknown],
266
+ CType.void)),
286
267
  "CRewriter" => :same,
287
268
  "RubyToAnsiC" => "void\nor(void * o) {\nNULL;\n}",
288
269
  "RubyToRubyC" => "static VALUE\nrrc_c_or(VALUE self, VALUE o) {\nQnil;\n}")
@@ -294,12 +275,12 @@ class R2CTestCase < ParseTreeTestCase
294
275
  t(:args),
295
276
  t(:scope,
296
277
  t(:block,
297
- t(:lasgn, :a, t(:array), Type.unknown_list),
278
+ t(:lasgn, :a, t(:array), CType.unknown_list),
298
279
  t(:return,
299
280
  t(:lvar,
300
- :a, Type.unknown_list), Type.void),
301
- Type.unknown), Type.void),
302
- Type.function(Type.unknown, [], Type.unknown_list)),
281
+ :a, CType.unknown_list), CType.void),
282
+ CType.unknown), CType.void),
283
+ CType.function(CType.unknown, [], CType.unknown_list)),
303
284
  "CRewriter" => :same,
304
285
  "RubyToAnsiC" => "void *\nzarray() {\nvoid * a;\na = (void *) malloc(sizeof(void *) * 0);\nreturn a;\n}",
305
286
  "RubyToRubyC" => "static VALUE\nrrc_c_zarray(VALUE self) {\nVALUE a;\na = rb_ary_new2(0);\nreturn a;\n}")
@@ -314,35 +295,34 @@ class R2CTestCase < ParseTreeTestCase
314
295
  t(:ensure,
315
296
  t(:rescue,
316
297
  t(:call,
317
- t(:lit, 1, Type.long),
298
+ t(:lit, 1, CType.long),
318
299
  :+,
319
- t(:arglist, t(:lit, 1, Type.long)), Type.long),
300
+ t(:arglist, t(:lit, 1, CType.long)), CType.long),
320
301
  t(:resbody,
321
- t(:array, t(:const, :SyntaxError, Type.fucked)),
302
+ t(:array, t(:const, :SyntaxError, CType.fucked)),
322
303
  t(:block,
323
- t(:lasgn, :e1, t(:gvar, :$!, Type.unknown),
324
- Type.unknown),
325
- t(:lit, 2, Type.long), Type.unknown),
304
+ t(:lasgn, :e1, t(:gvar, :$!, CType.unknown),
305
+ CType.unknown),
306
+ t(:lit, 2, CType.long), CType.unknown),
326
307
  t(:resbody,
327
- t(:array, t(:const, :Exception, Type.fucked)),
308
+ t(:array, t(:const, :Exception, CType.fucked)),
328
309
  t(:block,
329
- t(:lasgn, :e2, t(:gvar, :$!, Type.unknown),
330
- Type.unknown),
331
- t(:lit, 3, Type.long), Type.unknown),
332
- Type.unknown), Type.long),
333
- t(:lit, 4, Type.long), Type.long),
334
- t(:lit, 5, Type.long))), Type.unknown),
335
- Type.void),
336
- Type.function(Type.unknown, [], Type.void)),
310
+ t(:lasgn, :e2, t(:gvar, :$!, CType.unknown),
311
+ CType.unknown),
312
+ t(:lit, 3, CType.long), CType.unknown),
313
+ CType.unknown), CType.long),
314
+ t(:lit, 4, CType.long), CType.long),
315
+ t(:lit, 5, CType.long))), CType.unknown),
316
+ CType.void),
317
+ CType.function(CType.unknown, [], CType.void)),
337
318
  "CRewriter" => :same,
338
319
  "RubyToAnsiC" => :unsupported,
339
320
  "RubyToRubyC" => :unsupported)
340
321
 
341
322
  add_tests("global",
342
323
  "Rewriter" => :same,
343
- "TypeChecker" => :skip,
344
- # TODO: test s(:gvar, :$stderr) != t(:gvar, $stderr, Type.file)
345
- "TypeChecker" => t(:gvar, :$stderr, Type.file),
324
+ # TODO: test s(:gvar, :$stderr) != t(:gvar, $stderr, CType.file)
325
+ "TypeChecker" => t(:gvar, :$stderr, CType.file),
346
326
  "CRewriter" => :same,
347
327
  "RubyToAnsiC" => "stderr",
348
328
  "RubyToRubyC" => "rb_gv_get(\"$stderr\")")
@@ -351,9 +331,9 @@ class R2CTestCase < ParseTreeTestCase
351
331
  "Rewriter" => :skip,
352
332
  "TypeChecker" => t(:dstr,
353
333
  "var is ",
354
- t(:lvar, :argl, Type.long),
355
- t(:str, ". So there.", Type.str),
356
- Type.str),
334
+ t(:lvar, :argl, CType.long),
335
+ t(:str, ". So there.", CType.str),
336
+ CType.str),
357
337
  "CRewriter" => :same,
358
338
  "RubyToAnsiC" => :unsupported,
359
339
  "RubyToRubyC" => "rb_funcall(rb_mKernel, rb_intern(\"sprintf\"), 4, rb_str_new2(\"%s%s%s\"), rb_str_new2(\"var is \"), argl, rb_str_new2(\". So there.\"))")
@@ -361,22 +341,22 @@ class R2CTestCase < ParseTreeTestCase
361
341
  add_tests("iter", # TODO: not in pttc
362
342
  "Rewriter" => :skip,
363
343
  "TypeChecker" => t(:iter,
364
- t(:call, nil, :loop, nil, Type.unknown),
365
- t(:dasgn_curr, :temp_1, Type.unknown),
344
+ t(:call, nil, :loop, nil, CType.unknown),
345
+ t(:dasgn_curr, :temp_1, CType.unknown),
366
346
  nil,
367
- Type.unknown),
347
+ CType.unknown),
368
348
  "CRewriter" => :skip, # HACK don't do rb_iterate stuff for loop
369
349
  # "CRewriter" => [:defx,
370
350
  # t(:iter,
371
- # t(:call, nil, :loop, nil, Type.unknown),
351
+ # t(:call, nil, :loop, nil, CType.unknown),
372
352
  # t(:args,
373
- # t(:array, t(:dasgn_curr, :temp_1, Type.unknown), Type.void),
374
- # t(:array, Type.void), Type.void),
353
+ # t(:array, t(:dasgn_curr, :temp_1, CType.unknown), CType.void),
354
+ # t(:array, CType.void), CType.void),
375
355
  # t(:call, nil, :temp_1, nil)),
376
356
  # [t(:defx,
377
357
  # :temp_2,
378
358
  # t(:args, :temp_2, :temp_3),
379
- # t(:scope, t(:block, nil)), Type.void)]],
359
+ # t(:scope, t(:block, nil)), CType.void)]],
380
360
  "RubyToAnsiC" => "",
381
361
  "RubyToRubyC" => "")
382
362
 
@@ -384,20 +364,20 @@ class R2CTestCase < ParseTreeTestCase
384
364
  "Rewriter" => :same,
385
365
  "TypeChecker" => t(:iter,
386
366
  t(:call,
387
- t(:lit, 3, Type.long),
367
+ t(:lit, 3, CType.long),
388
368
  :downto,
389
- t(:arglist, t(:lit, 1, Type.long)),
390
- Type.unknown),
391
- t(:args, t(:lasgn, :n, nil, Type.long)),
369
+ t(:arglist, t(:lit, 1, CType.long)),
370
+ CType.unknown),
371
+ t(:args, t(:lasgn, :n, nil, CType.long)),
392
372
  t(:call, nil, :puts,
393
373
  t(:arglist,
394
374
  t(:call,
395
- t(:lvar, :n, Type.long),
375
+ t(:lvar, :n, CType.long),
396
376
  :to_s,
397
377
  t(:arglist),
398
- Type.str)),
399
- Type.void),
400
- Type.void),
378
+ CType.str)),
379
+ CType.void),
380
+ CType.void),
401
381
  "CRewriter" => :skip,
402
382
  "RubyToAnsiC" => "n = 1;\nwhile (n <= 3) {\nputs(to_s(n));\nn = n + 1;\n}",
403
383
  "RubyToRubyC" => "n = LONG2NUM(1);\nwhile (rb_funcall(n, rb_intern(\"<=\"), 1, LONG2NUM(3))) {\nrb_funcall(self, rb_intern(\"puts\"), 1, rb_funcall(n, rb_intern(\"to_s\"), 0));\nn = rb_funcall(n, rb_intern(\"+\"), 1, LONG2NUM(1));\n}")
@@ -407,76 +387,76 @@ class R2CTestCase < ParseTreeTestCase
407
387
  "TypeChecker" => t(:block,
408
388
  t(:lasgn, :array,
409
389
  t(:array,
410
- t(:lit, 1, Type.long),
411
- t(:lit, 2, Type.long),
412
- t(:lit, 3, Type.long)),
413
- Type.long_list),
390
+ t(:lit, 1, CType.long),
391
+ t(:lit, 2, CType.long),
392
+ t(:lit, 3, CType.long)),
393
+ CType.long_list),
414
394
  t(:iter,
415
395
  t(:call,
416
- t(:lvar, :array, Type.long_list),
396
+ t(:lvar, :array, CType.long_list),
417
397
  :each,
418
- t(:arglist), Type.unknown),
419
- t(:args, t(:lasgn, :x, nil, Type.long)),
398
+ t(:arglist), CType.unknown),
399
+ t(:args, t(:lasgn, :x, nil, CType.long)),
420
400
  t(:call, nil, :puts,
421
401
  t(:arglist,
422
402
  t(:call,
423
- t(:lvar, :x, Type.long),
403
+ t(:lvar, :x, CType.long),
424
404
  :to_s,
425
405
  t(:arglist),
426
- Type.str)),
427
- Type.void),
428
- Type.void),
429
- Type.unknown),
430
- "CRewriter" => [:defx,
406
+ CType.str)),
407
+ CType.void),
408
+ CType.void),
409
+ CType.unknown),
410
+ "CRewriter" => s(:defx,
431
411
  t(:block,
432
412
  t(:lasgn, :array,
433
413
  t(:array,
434
- t(:lit, 1, Type.long),
435
- t(:lit, 2, Type.long),
436
- t(:lit, 3, Type.long)),
437
- Type.long_list),
414
+ t(:lit, 1, CType.long),
415
+ t(:lit, 2, CType.long),
416
+ t(:lit, 3, CType.long)),
417
+ CType.long_list),
438
418
  t(:iter,
439
419
  t(:call,
440
- t(:lvar, :array, Type.long_list),
420
+ t(:lvar, :array, CType.long_list),
441
421
  :each,
442
- t(:arglist), Type.unknown),
422
+ t(:arglist), CType.unknown),
443
423
  t(:args,
444
- t(:array, t(:lvar, :x, Type.value), Type.void),
445
- t(:array, t(:lvar, :static_temp_4, Type.value), Type.void),
446
- Type.void),
447
- :temp_1),
448
- Type.unknown),
449
- [t(:static, "static VALUE static_temp_4;", Type.fucked),
424
+ t(:array, t(:lvar, :x, CType.value), CType.void),
425
+ t(:array, t(:lvar, :static_temp_4, CType.value), CType.void),
426
+ CType.void),
427
+ :temp_1, CType.void),
428
+ CType.unknown),
429
+ [t(:static, "static VALUE static_temp_4;", CType.fucked),
450
430
  t(:defx,
451
431
  :temp_1,
452
432
  t(:args,
453
- t(:temp_2, Type.value),
454
- t(:temp_3, Type.value)),
433
+ t(:temp_2, CType.value),
434
+ t(:temp_3, CType.value)),
455
435
  t(:scope,
456
436
  t(:block,
457
437
  t(:lasgn, :x,
458
- t(:lvar, :static_temp_4, Type.value),
459
- Type.value),
438
+ t(:lvar, :static_temp_4, CType.value),
439
+ CType.value),
460
440
  t(:masgn,
461
441
  t(:array),
462
442
  t(:to_ary,
463
- t(:lvar, :temp_2, Type.value))),
443
+ t(:lvar, :temp_2, CType.value))),
464
444
  t(:call,
465
445
  nil,
466
446
  :puts,
467
447
  t(:arglist,
468
448
  t(:call,
469
- t(:lvar, :x, Type.long),
449
+ t(:lvar, :x, CType.long),
470
450
  :to_s,
471
451
  t(:arglist),
472
- Type.str)),
473
- Type.void),
452
+ CType.str)),
453
+ CType.void),
474
454
  t(:lasgn,
475
455
  :static_temp_4,
476
- t(:lvar, :x, Type.value),
477
- Type.value),
478
- t(:return, t(:nil, Type.value)))),
479
- Type.void)]],
456
+ t(:lvar, :x, CType.value),
457
+ CType.value),
458
+ t(:return, t(:nil, CType.value)))),
459
+ CType.void)]),
480
460
  "RubyToAnsiC" => :skip, # because eric sucks soooo much
481
461
  # 'unsigned long index_x;
482
462
  # for (index_x = 0; arrays[index_x] != NULL; ++index_x) {
@@ -511,46 +491,46 @@ class R2CTestCase < ParseTreeTestCase
511
491
  "TypeChecker" => t(:block,
512
492
  t(:lasgn, :array1,
513
493
  t(:array,
514
- t(:lit, 1, Type.long),
515
- t(:lit, 2, Type.long),
516
- t(:lit, 3, Type.long)), Type.long_list),
494
+ t(:lit, 1, CType.long),
495
+ t(:lit, 2, CType.long),
496
+ t(:lit, 3, CType.long)), CType.long_list),
517
497
  t(:lasgn, :array2,
518
498
  t(:array,
519
- t(:lit, 4, Type.long),
520
- t(:lit, 5, Type.long),
521
- t(:lit, 6, Type.long),
522
- t(:lit, 7, Type.long)), Type.long_list),
499
+ t(:lit, 4, CType.long),
500
+ t(:lit, 5, CType.long),
501
+ t(:lit, 6, CType.long),
502
+ t(:lit, 7, CType.long)), CType.long_list),
523
503
  t(:iter,
524
504
  t(:call,
525
- t(:lvar, :array1, Type.long_list),
505
+ t(:lvar, :array1, CType.long_list),
526
506
  :each,
527
- t(:arglist), Type.unknown),
528
- t(:args, t(:lasgn, :x, nil, Type.long)),
507
+ t(:arglist), CType.unknown),
508
+ t(:args, t(:lasgn, :x, nil, CType.long)),
529
509
  t(:iter,
530
510
  t(:call,
531
- t(:lvar, :array2, Type.long_list),
511
+ t(:lvar, :array2, CType.long_list),
532
512
  :each,
533
- t(:arglist), Type.unknown),
534
- t(:args, t(:lasgn, :y, nil, Type.long)),
513
+ t(:arglist), CType.unknown),
514
+ t(:args, t(:lasgn, :y, nil, CType.long)),
535
515
  t(:block,
536
516
  t(:call, nil, :puts,
537
517
  t(:arglist,
538
518
  t(:call,
539
- t(:lvar, :x, Type.long),
519
+ t(:lvar, :x, CType.long),
540
520
  :to_s,
541
- t(:arglist), Type.str)),
542
- Type.void),
521
+ t(:arglist), CType.str)),
522
+ CType.void),
543
523
  t(:call, nil, :puts,
544
524
  t(:arglist,
545
525
  t(:call,
546
- t(:lvar, :y, Type.long),
526
+ t(:lvar, :y, CType.long),
547
527
  :to_s,
548
- t(:arglist), Type.str)),
549
- Type.void),
550
- Type.unknown),
551
- Type.void),
552
- Type.void),
553
- Type.unknown),
528
+ t(:arglist), CType.str)),
529
+ CType.void),
530
+ CType.unknown),
531
+ CType.void),
532
+ CType.void),
533
+ CType.unknown),
554
534
  "CRewriter" => :skip,
555
535
  "RubyToAnsiC" => 'while (argl >= 1) {
556
536
  puts("hello");
@@ -565,26 +545,26 @@ argl = rb_funcall(argl, rb_intern("-"), 1, LONG2NUM(1));
565
545
  "Rewriter" => :same,
566
546
  "TypeChecker" => t(:block,
567
547
  t(:lasgn, :argl,
568
- t(:lit, 10, Type.long), Type.long),
548
+ t(:lit, 10, CType.long), CType.long),
569
549
  t(:while,
570
550
  t(:call,
571
- t(:lvar, :argl, Type.long),
551
+ t(:lvar, :argl, CType.long),
572
552
  :>=,
573
- t(:arglist, t(:lit, 1, Type.long)), Type.bool),
553
+ t(:arglist, t(:lit, 1, CType.long)), CType.bool),
574
554
  t(:block,
575
555
  t(:call, nil, :puts,
576
556
  t(:arglist,
577
- t(:str, 'hello', Type.str)),
578
- Type.void),
557
+ t(:str, 'hello', CType.str)),
558
+ CType.void),
579
559
  t(:lasgn, :argl,
580
560
  t(:call,
581
- t(:lvar, :argl, Type.long),
561
+ t(:lvar, :argl, CType.long),
582
562
  :-,
583
- t(:arglist, t(:lit, 1, Type.long)),
584
- Type.long),
585
- Type.long),
586
- Type.unknown), true),
587
- Type.unknown),
563
+ t(:arglist, t(:lit, 1, CType.long)),
564
+ CType.long),
565
+ CType.long),
566
+ CType.unknown), true),
567
+ CType.unknown),
588
568
  "CRewriter" => :same,
589
569
  "RubyToAnsiC" => "argl = 10;\nwhile (argl >= 1) {\nputs(\"hello\");\nargl = argl - 1;\n}\n",
590
570
  "RubyToRubyC" => "argl = LONG2NUM(10);\nwhile (rb_funcall(argl, rb_intern(\">=\"), 1, LONG2NUM(1))) {\nrb_funcall(self, rb_intern(\"puts\"), 1, rb_str_new2(\"hello\"));\nargl = rb_funcall(argl, rb_intern(\"-\"), 1, LONG2NUM(1));\n}\n")
@@ -605,9 +585,9 @@ argl = rb_funcall(argl, rb_intern("-"), 1, LONG2NUM(1));
605
585
  "TypeChecker" => t(:lasgn,
606
586
  :var,
607
587
  t(:array,
608
- t(:str, "foo", Type.str),
609
- t(:str, "bar", Type.str)),
610
- Type.str_list),
588
+ t(:str, "foo", CType.str),
589
+ t(:str, "bar", CType.str)),
590
+ CType.str_list),
611
591
  "CRewriter" => :same,
612
592
  "RubyToRubyC" => 'var = rb_ary_new2(2);
613
593
  rb_ary_store(var, 0, rb_str_new2("foo"));
@@ -620,68 +600,68 @@ var[1] = "bar"')
620
600
  "Rewriter" => :same,
621
601
  "TypeChecker" => t(:lasgn, :c,
622
602
  t(:call,
623
- t(:lit, 2, Type.long),
603
+ t(:lit, 2, CType.long),
624
604
  :+,
625
605
  t(:arglist,
626
- t(:lit, 3, Type.long)),
627
- Type.long),
628
- Type.long),
606
+ t(:lit, 3, CType.long)),
607
+ CType.long),
608
+ CType.long),
629
609
  "CRewriter" => :same,
630
610
  "RubyToAnsiC" => "c = 2 + 3", # FIX: probably not "c =
631
611
  "RubyToRubyC" => 'c = rb_funcall(LONG2NUM(2), rb_intern("+"), 1, LONG2NUM(3))')
632
612
 
633
613
  add_tests("lit_bool_false",
634
614
  "Rewriter" => :same,
635
- "TypeChecker" => t(:false, Type.bool),
615
+ "TypeChecker" => t(:false, CType.bool),
636
616
  "CRewriter" => :same,
637
617
  "RubyToAnsiC" => "0",
638
618
  "RubyToRubyC" => "Qfalse")
639
619
 
640
620
  add_tests("lit_bool_true",
641
621
  "Rewriter" => :same,
642
- "TypeChecker" => t(:true, Type.bool),
622
+ "TypeChecker" => t(:true, CType.bool),
643
623
  "CRewriter" => :same,
644
624
  "RubyToAnsiC" => "1",
645
625
  "RubyToRubyC" => "Qtrue")
646
626
 
647
627
  add_tests("lit_float",
648
628
  "Rewriter" => :same,
649
- "TypeChecker" => t(:lit, 1.1, Type.float),
629
+ "TypeChecker" => t(:lit, 1.1, CType.float),
650
630
  "CRewriter" => :same,
651
631
  "RubyToAnsiC" => "1.1",
652
632
  "RubyToRubyC" => "rb_float_new(1.1)")
653
633
 
654
634
  add_tests("lit_long",
655
635
  "Rewriter" => :same,
656
- "TypeChecker" => t(:lit, 1, Type.long),
636
+ "TypeChecker" => t(:lit, 1, CType.long),
657
637
  "CRewriter" => :same,
658
638
  "RubyToAnsiC" => "1",
659
639
  "RubyToRubyC" => "LONG2NUM(1)")
660
640
 
661
641
  add_tests("lit_long_negative",
662
642
  "Rewriter" => :same,
663
- "TypeChecker" => t(:lit, -1, Type.long),
643
+ "TypeChecker" => t(:lit, -1, CType.long),
664
644
  "CRewriter" => :same,
665
645
  "RubyToAnsiC" => "-1",
666
646
  "RubyToRubyC" => "LONG2NUM(-1)")
667
647
 
668
648
  add_tests("lit_range2",
669
649
  "Rewriter" => :same,
670
- "TypeChecker" => t(:lit, 1..10, Type.range),
650
+ "TypeChecker" => t(:lit, 1..10, CType.range),
671
651
  "CRewriter" => :same,
672
652
  "RubyToAnsiC" => :skip,
673
653
  "RubyToRubyC" => :skip)
674
654
 
675
655
  add_tests("lit_range3",
676
656
  "Rewriter" => :same,
677
- "TypeChecker" => t(:lit, 1...10, Type.range),
657
+ "TypeChecker" => t(:lit, 1...10, CType.range),
678
658
  "CRewriter" => :same,
679
659
  "RubyToAnsiC" => :skip,
680
660
  "RubyToRubyC" => :skip)
681
661
 
682
662
  add_tests("lit_regexp",
683
663
  "Rewriter" => :same,
684
- "TypeChecker" => t(:lit, /x/, Type.regexp),
664
+ "TypeChecker" => t(:lit, /x/, CType.regexp),
685
665
  "CRewriter" => :same,
686
666
  "RubyToAnsiC" => :skip,
687
667
  "RubyToRubyC" => :skip)
@@ -689,24 +669,24 @@ var[1] = "bar"')
689
669
  add_tests("lit_regexp_i_wwtt",
690
670
  "Rewriter" => :same,
691
671
  "TypeChecker" => t(:call,
692
- t(:call, nil, :str, t(:arglist), Type.unknown),
672
+ t(:call, nil, :str, t(:arglist), CType.unknown),
693
673
  :split,
694
- t(:arglist, t(:lit, //i, Type.regexp)),
695
- Type.unknown),
674
+ t(:arglist, t(:lit, //i, CType.regexp)),
675
+ CType.unknown),
696
676
  "CRewriter" => :same,
697
677
  "RubyToAnsiC" => :skip,
698
678
  "RubyToRubyC" => :skip)
699
679
 
700
680
  add_tests("lit_regexp_n",
701
681
  "Rewriter" => :same,
702
- "TypeChecker" => t(:lit, /x/n, Type.regexp),
682
+ "TypeChecker" => t(:lit, /x/n, CType.regexp),
703
683
  "CRewriter" => :same,
704
684
  "RubyToAnsiC" => :skip,
705
685
  "RubyToRubyC" => :skip)
706
686
 
707
687
  add_tests("lit_regexp_once",
708
688
  "Rewriter" => :same,
709
- "TypeChecker" => t(:lit, /x/, Type.regexp), # HACK - once?
689
+ "TypeChecker" => t(:lit, /x/, CType.regexp), # HACK - once?
710
690
  "CRewriter" => :same,
711
691
  "RubyToAnsiC" => :skip,
712
692
  "RubyToRubyC" => :skip)
@@ -714,21 +694,21 @@ var[1] = "bar"')
714
694
  add_tests("lit_str", # TODO: not in pttc
715
695
  "ParseTree" => s(:str, "x"),
716
696
  "Rewriter" => :same,
717
- "TypeChecker" => t(:str, "x", Type.str),
697
+ "TypeChecker" => t(:str, "x", CType.str),
718
698
  "CRewriter" => :same,
719
699
  "RubyToAnsiC" => '"x"',
720
700
  "RubyToRubyC" => 'rb_str_new2("x")')
721
701
 
722
702
  add_tests("lit_sym",
723
703
  "Rewriter" => :same,
724
- "TypeChecker" => t(:lit, :x, Type.symbol),
704
+ "TypeChecker" => t(:lit, :x, CType.symbol),
725
705
  "CRewriter" => :same,
726
706
  "RubyToAnsiC" => '"x"', # HACK WRONG! (or... is it?
727
707
  "RubyToRubyC" => 'ID2SYM(rb_intern("x"))')
728
708
 
729
709
  add_tests("lit_sym_splat",
730
710
  "Rewriter" => :same,
731
- "TypeChecker" => t(:lit, :"*args", Type.symbol),
711
+ "TypeChecker" => t(:lit, :"*args", CType.symbol),
732
712
  "CRewriter" => :same,
733
713
  "RubyToAnsiC" => '"*args"',
734
714
  "RubyToRubyC" => 'ID2SYM(rb_intern("*args"))')
@@ -761,38 +741,38 @@ var[1] = "bar"')
761
741
  "Rewriter" => :same,
762
742
  "TypeChecker" => t(:defn, :multi_args,
763
743
  t(:args,
764
- t(:arg1, Type.long),
765
- t(:arg2, Type.long)),
744
+ t(:arg1, CType.long),
745
+ t(:arg2, CType.long)),
766
746
  t(:scope,
767
747
  t(:block,
768
748
  t(:lasgn,
769
749
  :arg3,
770
750
  t(:call,
771
751
  t(:call,
772
- t(:lvar, :arg1, Type.long),
752
+ t(:lvar, :arg1, CType.long),
773
753
  :*,
774
- t(:arglist, t(:lvar, :arg2, Type.long)),
775
- Type.long),
754
+ t(:arglist, t(:lvar, :arg2, CType.long)),
755
+ CType.long),
776
756
  :*,
777
- t(:arglist, t(:lit, 7, Type.long)),
778
- Type.long),
779
- Type.long),
757
+ t(:arglist, t(:lit, 7, CType.long)),
758
+ CType.long),
759
+ CType.long),
780
760
  t(:call,
781
761
  nil,
782
762
  :puts,
783
763
  t(:arglist,
784
764
  t(:call,
785
- t(:lvar, :arg3, Type.long),
765
+ t(:lvar, :arg3, CType.long),
786
766
  :to_s,
787
767
  t(:arglist),
788
- Type.str)),
789
- Type.void),
790
- t(:return, t(:str, "foo", Type.str),
791
- Type.void),
792
- Type.unknown),
793
- Type.void),
794
- Type.function(Type.unknown,
795
- [Type.long, Type.long], Type.str)),
768
+ CType.str)),
769
+ CType.void),
770
+ t(:return, t(:str, "foo", CType.str),
771
+ CType.void),
772
+ CType.unknown),
773
+ CType.void),
774
+ CType.function(CType.unknown,
775
+ [CType.long, CType.long], CType.str)),
796
776
  "CRewriter" => :same,
797
777
  "RubyToRubyC" => "static VALUE
798
778
  rrc_c_multi_args(VALUE self, VALUE arg1, VALUE arg2) {
@@ -811,7 +791,7 @@ return \"foo\";
811
791
 
812
792
  add_tests("not__18",
813
793
  "Rewriter" => :same,
814
- "TypeChecker" => t(:not, t(:true, Type.bool), Type.bool),
794
+ "TypeChecker" => t(:not, t(:true, CType.bool), CType.bool),
815
795
  "CRewriter" => :same,
816
796
  "RubyToAnsiC" => "!(1)",
817
797
  "RubyToRubyC" => "!(Qtrue)")
@@ -819,16 +799,16 @@ return \"foo\";
819
799
  add_tests("or",
820
800
  "Rewriter" => :same,
821
801
  "TypeChecker" => t(:or,
822
- t(:call, nil, :a, t(:arglist), Type.bool),
823
- t(:call, nil, :b, t(:arglist), Type.bool),
824
- Type.bool),
802
+ t(:call, nil, :a, t(:arglist), CType.bool),
803
+ t(:call, nil, :b, t(:arglist), CType.bool),
804
+ CType.bool),
825
805
  "CRewriter" => :same,
826
806
  "RubyToAnsiC" => 'a() || b()',
827
807
  "RubyToRubyC" => 'rb_funcall(self, rb_intern("a"), 0) || rb_funcall(self, rb_intern("b"), 0)')
828
808
 
829
809
  add_tests("vcall",
830
810
  "Rewriter" => :same,
831
- "TypeChecker" => t(:call, nil, :method, t(:arglist), Type.unknown),
811
+ "TypeChecker" => t(:call, nil, :method, t(:arglist), CType.unknown),
832
812
  "CRewriter" => :same,
833
813
  "RubyToAnsiC" => "method()",
834
814
  "RubyToRubyC" => "rb_funcall(self, rb_intern(\"method\"), 0)")
@@ -862,29 +842,29 @@ return \"foo\";
862
842
  t(:scope,
863
843
  t(:block,
864
844
  t(:while,
865
- t(:false, Type.bool),
845
+ t(:false, CType.bool),
866
846
  t(:call,
867
847
  nil,
868
848
  :puts,
869
- t(:arglist, t(:str, "false", Type.str)), Type.void),
849
+ t(:arglist, t(:str, "false", CType.str)), CType.void),
870
850
  true),
871
851
  t(:while,
872
- t(:false, Type.bool),
852
+ t(:false, CType.bool),
873
853
  t(:call,
874
854
  nil,
875
855
  :puts,
876
- t(:arglist, t(:str, "true", Type.str)), Type.void),
856
+ t(:arglist, t(:str, "true", CType.str)), CType.void),
877
857
  false),
878
- Type.unknown),
879
- Type.void),
880
- Type.function(Type.unknown, [], Type.void)),
858
+ CType.unknown),
859
+ CType.void),
860
+ CType.function(CType.unknown, [], CType.void)),
881
861
  "CRewriter" => :same,
882
862
  "RubyToAnsiC" => "void\nwhiles() {\nwhile (0) {\nputs(\"false\");\n};\n{\nputs(\"true\");\n} while (0);\n}",
883
863
  "RubyToRubyC" => "static VALUE\nrrc_c_whiles(VALUE self) {\nwhile (Qfalse) {\nrb_funcall(self, rb_intern(\"puts\"), 1, rb_str_new2(\"false\"));\n};\n{\nrb_funcall(self, rb_intern(\"puts\"), 1, rb_str_new2(\"true\"));\n} while (Qfalse);\n}")
884
864
 
885
865
  add_tests("zarray",
886
866
  "Rewriter" => :same,
887
- "TypeChecker" => t(:lasgn, :a, t(:array), Type.unknown_list),
867
+ "TypeChecker" => t(:lasgn, :a, t(:array), CType.unknown_list),
888
868
  "CRewriter" => :same,
889
869
  # TODO: need to verify that our variable decl will be correct
890
870
  "RubyToAnsiC" => "a = (void *) malloc(sizeof(void *) * 0)",
@@ -892,21 +872,21 @@ return \"foo\";
892
872
 
893
873
  add_tests("str_question_control__18",
894
874
  "Rewriter" => :same,
895
- "TypeChecker" => t(:lit, 129, Type.long),
875
+ "TypeChecker" => t(:lit, 129, CType.long),
896
876
  "CRewriter" => :same,
897
877
  "RubyToAnsiC" => "129",
898
878
  "RubyToRubyC" => "LONG2NUM(129)")
899
879
 
900
880
  add_tests("str_question_escape__18",
901
881
  "Rewriter" => :same,
902
- "TypeChecker" => t(:lit, 10, Type.long),
882
+ "TypeChecker" => t(:lit, 10, CType.long),
903
883
  "CRewriter" => :same,
904
884
  "RubyToAnsiC" => "10",
905
885
  "RubyToRubyC" => "LONG2NUM(10)")
906
886
 
907
887
  add_tests("str_question_literal__18",
908
888
  "Rewriter" => :same,
909
- "TypeChecker" => t(:lit, 97, Type.long),
889
+ "TypeChecker" => t(:lit, 97, CType.long),
910
890
  "CRewriter" => :same,
911
891
  "RubyToAnsiC" => "97",
912
892
  "RubyToRubyC" => "LONG2NUM(97)")
@@ -1156,6 +1136,7 @@ return \"foo\";
1156
1136
  "return_1_splatted",
1157
1137
  "return_n",
1158
1138
  "sclass",
1139
+ "sclass_multiple",
1159
1140
  "sclass_trailing_class",
1160
1141
  "splat",
1161
1142
  "splat_array",
@@ -1187,7 +1168,6 @@ return \"foo\";
1187
1168
  "structure_extra_block_for_dvar_scoping",
1188
1169
  "structure_remove_begin_1",
1189
1170
  "structure_remove_begin_2",
1190
- "structure_unused_literal_wwtt",
1191
1171
  "super_0",
1192
1172
  "super_1",
1193
1173
  "super_1_array",
@@ -1233,5 +1213,58 @@ return \"foo\";
1233
1213
  "yield_array_1",
1234
1214
  "yield_array_n",
1235
1215
  "yield_n",
1216
+ "if_args_no_space_symbol__18",
1236
1217
  "zsuper")
1218
+
1219
+ add_skipped_tests19("array_bare_hash",
1220
+ "array_bare_hash_labels",
1221
+ "call_arglist_norm_hash_colons",
1222
+ "call_arglist_trailing_comma",
1223
+ "call_bang",
1224
+ "call_bang_empty",
1225
+ "call_fonz",
1226
+ "call_fonz_cm",
1227
+ "call_not",
1228
+ "call_not_equal",
1229
+ "call_splat_mid",
1230
+ "defn_args_mand_opt_mand",
1231
+ "defn_args_mand_opt_splat_mand",
1232
+ "defn_args_opt_mand",
1233
+ "defn_args_opt_splat_mand",
1234
+ "defn_args_splat_mand",
1235
+ "defn_args_splat_middle",
1236
+ "fcall_arglist_hash_colons",
1237
+ "hash_new",
1238
+ "hash_new_no_space",
1239
+ "hash_new_with_keyword",
1240
+ "if_post_not",
1241
+ "if_pre_not",
1242
+ "label_in_bare_hash_in_array_in_ternary",
1243
+ "label_in_callargs_in_ternary",
1244
+ "not",
1245
+ "splat_fcall_middle",
1246
+ "stabby_args_0_no_parens",
1247
+ "stabby_args_0_no_parens_doend",
1248
+ "stabby_args_0_spacebar_broken",
1249
+ "stabby_args_1",
1250
+ "stabby_args_1_doend",
1251
+ "stabby_args_1_no_parens",
1252
+ "stabby_args_1_no_parens_doend",
1253
+ "stabby_args_2",
1254
+ "stabby_args_2_doend",
1255
+ "stabby_args_2_no_parens",
1256
+ "stabby_args_2_no_parens_doend",
1257
+ "stabby_args",
1258
+ "stabby_args_doend",
1259
+ "str_question_control",
1260
+ "str_question_escape",
1261
+ "str_question_literal",
1262
+ "unless_post_not",
1263
+ "unless_pre_not",
1264
+ "until_post_not",
1265
+ "until_pre_not",
1266
+ "until_pre_not_mod",
1267
+ "while_post_not",
1268
+ "while_pre_not",
1269
+ "while_pre_not_mod")
1237
1270
  end