nendo 0.7.0 → 0.7.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (22) hide show
  1. checksums.yaml +4 -4
  2. data/Rakefile +5 -37
  3. data/VERSION.yml +1 -1
  4. data/lib/nendo.rb +1 -0
  5. data/lib/nendo/debug/null.nndc +1 -1
  6. data/lib/nendo/debug/syslog.nndc +19 -35
  7. data/lib/nendo/init.nndc +8828 -16708
  8. data/lib/nendo/nendo/experimental.nndc +3009 -4669
  9. data/lib/nendo/nendo/test.nndc +691 -1277
  10. data/lib/nendo/rfc/json.nndc +211 -423
  11. data/lib/nendo/ruby/core.rb +1 -1
  12. data/lib/nendo/ruby/evaluator.rb +49 -63
  13. data/lib/nendo/ruby/optimized_func.rb +98 -0
  14. data/lib/nendo/srfi-1.nndc +5634 -11182
  15. data/lib/nendo/srfi-2.nndc +492 -720
  16. data/lib/nendo/srfi-26.nndc +1531 -2257
  17. data/lib/nendo/text/html-lite.nndc +1205 -2009
  18. data/lib/nendo/text/tree.nndc +67 -135
  19. data/lib/nendo/util/combinations.nndc +2365 -4427
  20. data/lib/nendo/util/list.nndc +1870 -3132
  21. data/lib/nendo/util/match.nndc +32076 -47256
  22. metadata +8 -7
data/lib/nendo/nendo/test.nndc CHANGED
@@ -4,19 +4,15 @@
4
4
  #
5
5
 
6
6
  trampCall(
7
- begin
7
+ begin #execFunc
8
8
  def self._test_MIMARKerror_QUMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test_MIMARKerror_QUMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
9
9
  @global_lisp_binding['_test_MIMARKerror_QUMARK'] = self.method( :_test_MIMARKerror_QUMARK_METHOD )
10
10
  @_test_MIMARKerror_QUMARK =
11
11
  trampCall(
12
12
  Proc.new { |_obj|
13
- begin
14
- trampCall(_obj).is_a?(
15
- begin
16
- trampCall(Nendo::NendoTestError)
17
- end
18
- )
19
- end
13
+ trampCall(_obj).is_a?(
14
+ trampCall(Nendo::NendoTestError)
15
+ )
20
16
  }
21
17
  )
22
18
  end
@@ -24,71 +20,49 @@ trampCall(
24
20
  #--------------------
25
21
 
26
22
  trampCall(
27
- begin
23
+ begin #execFunc
28
24
  def self._test_MIMARKerror_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test_MIMARKerror', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
29
25
  @global_lisp_binding['_test_MIMARKerror'] = self.method( :_test_MIMARKerror_METHOD )
30
26
  @_test_MIMARKerror =
31
27
  trampCall(
32
28
  Proc.new { |*__rest__| _maybe_MIMARKclass = __rest__[0] ;
33
- begin
29
+ begin #makeLet
34
30
  ___lambda = lambda { |_cl,_err|
35
31
  if (
36
- begin
37
- trampCall(_cl)
38
- end
32
+ trampCall(_cl)
39
33
  ) then
40
- begin
41
- begin
42
-
43
- _err.type =
44
- trampCall(
45
- begin
46
- trampCall(_cl)
47
- end
48
- )
49
- end
50
- end
51
- end
52
- begin
53
- trampCall(_err)
34
+ begin #execFunc
35
+
36
+ _err.type =
37
+ trampCall(
38
+ trampCall(_cl)
39
+ )
40
+ end
54
41
  end
42
+ trampCall(_err)
55
43
  } ; ___lambda.call(
56
- begin
44
+ begin #makeLet
57
45
  ___lambda = lambda { |___gensym__5d616449e4cd5ff7562e60dbfcf1c628e32cc41d_30178|
58
46
  if (
59
- begin
60
- _null_QUMARK(
61
- begin
62
- trampCall(___gensym__5d616449e4cd5ff7562e60dbfcf1c628e32cc41d_30178)
63
- end
64
- )
65
- end
47
+ _null_QUMARK(
48
+ trampCall(___gensym__5d616449e4cd5ff7562e60dbfcf1c628e32cc41d_30178)
49
+ )
66
50
  ) then
67
51
  false
68
52
  else
69
- begin
70
- delayCall( '_car', 'car',
71
- begin
72
- trampCall(@_car)
73
- end ,
74
- [
75
- begin
76
- trampCall(___gensym__5d616449e4cd5ff7562e60dbfcf1c628e32cc41d_30178)
77
- end
78
- ]
79
- )
80
- end
53
+ delayCall( '_car', 'car',
54
+ trampCall(@_car) ,
55
+ [
56
+ trampCall(___gensym__5d616449e4cd5ff7562e60dbfcf1c628e32cc41d_30178)
57
+ ]
58
+ )
81
59
  end
82
60
  } ; ___lambda.call(
83
- begin
84
- trampCall(_maybe_MIMARKclass)
85
- end
61
+ trampCall(_maybe_MIMARKclass)
86
62
  )
87
63
  end ,
88
- begin
89
- trampCall(Nendo::NendoTestError).new(
90
- )
91
- end
64
+ trampCall(Nendo::NendoTestError).new(
65
+ )
92
66
  )
93
67
  end
94
68
  }
@@ -98,120 +72,74 @@ trampCall(
98
72
  #--------------------
99
73
 
100
74
  trampCall(
101
- begin
75
+ begin #execFunc
102
76
  def self._test_MIMARKcheck_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test_MIMARKcheck', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
103
77
  @global_lisp_binding['_test_MIMARKcheck'] = self.method( :_test_MIMARKcheck_METHOD )
104
78
  @_test_MIMARKcheck =
105
79
  trampCall(
106
80
  Proc.new { |_expected,_result|
107
81
  if (
108
- begin
109
- trampCall( self._test_MIMARKerror_QUMARK_METHOD( 'test-error?',
110
- begin
111
- trampCall(@_test_MIMARKerror_QUMARK)
112
- end ,
113
- [
114
- begin
115
- trampCall(_expected)
116
- end
117
- ]
118
- ))
119
- end
82
+ trampCall( self._test_MIMARKerror_QUMARK_METHOD( 'test-error?',
83
+ trampCall(@_test_MIMARKerror_QUMARK) ,
84
+ [
85
+ trampCall(_expected)
86
+ ]
87
+ ))
120
88
  ) then
121
- begin
122
- if (
123
- begin
124
- _not(
125
- begin
126
- _eq_QUMARK(
127
- false ,
128
- begin
129
- trampCall( self._test_MIMARKerror_QUMARK_METHOD( 'test-error?',
130
- begin
131
- trampCall(@_test_MIMARKerror_QUMARK)
132
- end ,
133
- [
134
- begin
135
- trampCall(_result)
136
- end
137
- ]
138
- ))
139
- end
140
- )
141
- end
142
- )
143
- end
144
- ) then
145
- begin
146
- ___lambda = lambda { |_ex,_ey|
147
- if (
148
- begin
149
- _not(
150
- begin
151
- _eq_QUMARK(
152
- false ,
153
- begin
154
- trampCall(_ex)
155
- end
156
- )
157
- end
158
- )
159
- end
160
- ) then
161
- begin
162
- delayCall( '_eq_QUMARK', 'eq?',
163
- begin
164
- trampCall(@_eq_QUMARK)
165
- end ,
166
- [
167
- begin
168
- trampCall(_ex)
169
- end ,
170
- begin
171
- trampCall(_ey)
172
- end
173
- ]
174
- )
175
- end
176
- else
177
- false
178
- end
179
- } ; ___lambda.call(
180
- begin
181
- trampCall(_expected).type(
182
- )
183
- end ,
184
- begin
185
- trampCall(_result).type(
89
+ if (
90
+ _not(
91
+ _eq_QUMARK(
92
+ false ,
93
+ trampCall( self._test_MIMARKerror_QUMARK_METHOD( 'test-error?',
94
+ trampCall(@_test_MIMARKerror_QUMARK) ,
95
+ [
96
+ trampCall(_result)
97
+ ]
98
+ ))
99
+ )
100
+ )
101
+ ) then
102
+ begin #makeLet
103
+ ___lambda = lambda { |_ex,_ey|
104
+ if (
105
+ _not(
106
+ _eq_QUMARK(
107
+ false ,
108
+ trampCall(_ex)
186
109
  )
187
- end
188
- )
189
- end
190
- else
191
- false
192
- end
193
- end
110
+ )
111
+ ) then
112
+ delayCall( '_eq_QUMARK', 'eq?',
113
+ trampCall(@_eq_QUMARK) ,
114
+ [
115
+ trampCall(_ex) ,
116
+ trampCall(_ey)
117
+ ]
118
+ )
119
+ else
120
+ false
121
+ end
122
+ } ; ___lambda.call(
123
+ trampCall(_expected).type(
124
+ ) ,
125
+ trampCall(_result).type(
126
+ )
127
+ )
128
+ end
129
+ else
130
+ false
131
+ end
194
132
  else
195
133
  if (
196
134
  true
197
135
  ) then
198
- begin
199
- begin
200
- delayCall( '_equal_QUMARK', 'equal?',
201
- begin
202
- trampCall(@_equal_QUMARK)
203
- end ,
204
- [
205
- begin
206
- trampCall(_expected)
207
- end ,
208
- begin
209
- trampCall(_result)
210
- end
211
- ]
212
- )
213
- end
214
- end
136
+ delayCall( '_equal_QUMARK', 'equal?',
137
+ trampCall(@_equal_QUMARK) ,
138
+ [
139
+ trampCall(_expected) ,
140
+ trampCall(_result)
141
+ ]
142
+ )
215
143
  else
216
144
  Cell.new()
217
145
  end
@@ -223,7 +151,7 @@ trampCall(
223
151
  #--------------------
224
152
 
225
153
  trampCall(
226
- begin
154
+ begin #execFunc
227
155
  def self.__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
228
156
  @global_lisp_binding['__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK'] = self.method( :__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK_METHOD )
229
157
  @__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK =
@@ -235,21 +163,19 @@ trampCall(
235
163
  #--------------------
236
164
 
237
165
  trampCall(
238
- begin
166
+ begin #execFunc
239
167
  def self.__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
240
168
  @global_lisp_binding['__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK'] = self.method( :__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK_METHOD )
241
169
  @__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK =
242
170
  trampCall(
243
- begin
244
- trampCall(STDOUT)
245
- end
171
+ trampCall(STDOUT)
246
172
  )
247
173
  end
248
174
  )
249
175
  #--------------------
250
176
 
251
177
  trampCall(
252
- begin
178
+ begin #execFunc
253
179
  def self.__ASMARKdiscrepancy_MIMARKlist_ASMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '__ASMARKdiscrepancy_MIMARKlist_ASMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
254
180
  @global_lisp_binding['__ASMARKdiscrepancy_MIMARKlist_ASMARK'] = self.method( :__ASMARKdiscrepancy_MIMARKlist_ASMARK_METHOD )
255
181
  @__ASMARKdiscrepancy_MIMARKlist_ASMARK =
@@ -261,20 +187,18 @@ trampCall(
261
187
  #--------------------
262
188
 
263
189
  trampCall(
264
- begin
190
+ begin #execFunc
265
191
  def self._test_MIMARKrecord_MIMARKfile_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test_MIMARKrecord_MIMARKfile', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
266
192
  @global_lisp_binding['_test_MIMARKrecord_MIMARKfile'] = self.method( :_test_MIMARKrecord_MIMARKfile_METHOD )
267
193
  @_test_MIMARKrecord_MIMARKfile =
268
194
  trampCall(
269
195
  Proc.new { |_file|
270
- begin
196
+ begin #execFunc
271
197
  def self.__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
272
198
  @global_lisp_binding['__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK'] = self.method( :__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK_METHOD )
273
199
  @__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK =
274
200
  trampCall(
275
- begin
276
- trampCall(_file)
277
- end
201
+ trampCall(_file)
278
202
  )
279
203
  end
280
204
  }
@@ -284,20 +208,18 @@ trampCall(
284
208
  #--------------------
285
209
 
286
210
  trampCall(
287
- begin
211
+ begin #execFunc
288
212
  def self._test_MIMARKoutput_MIMARKfile_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test_MIMARKoutput_MIMARKfile', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
289
213
  @global_lisp_binding['_test_MIMARKoutput_MIMARKfile'] = self.method( :_test_MIMARKoutput_MIMARKfile_METHOD )
290
214
  @_test_MIMARKoutput_MIMARKfile =
291
215
  trampCall(
292
216
  Proc.new { |_file|
293
- begin
217
+ begin #execFunc
294
218
  def self.__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
295
219
  @global_lisp_binding['__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK'] = self.method( :__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK_METHOD )
296
220
  @__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK =
297
221
  trampCall(
298
- begin
299
- trampCall(_file)
300
- end
222
+ trampCall(_file)
301
223
  )
302
224
  end
303
225
  }
@@ -307,67 +229,49 @@ trampCall(
307
229
  #--------------------
308
230
 
309
231
  trampCall(
310
- begin
232
+ begin #execFunc
311
233
  def self.__ASMARKtest_MIMARKcounts_ASMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '__ASMARKtest_MIMARKcounts_ASMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
312
234
  @global_lisp_binding['__ASMARKtest_MIMARKcounts_ASMARK'] = self.method( :__ASMARKtest_MIMARKcounts_ASMARK_METHOD )
313
235
  @__ASMARKtest_MIMARKcounts_ASMARK =
314
236
  trampCall(
315
- begin
316
- trampCall( self._vector_METHOD( 'vector',
317
- begin
318
- trampCall(@_vector)
319
- end ,
320
- [
321
- 0 ,
322
- 0 ,
323
- 0 ,
324
- 0
325
- ]
326
- ))
327
- end
237
+ trampCall( self._vector_METHOD( 'vector',
238
+ trampCall(@_vector) ,
239
+ [
240
+ 0 ,
241
+ 0 ,
242
+ 0 ,
243
+ 0
244
+ ]
245
+ ))
328
246
  )
329
247
  end
330
248
  )
331
249
  #--------------------
332
250
 
333
251
  trampCall(
334
- begin
252
+ begin #execFunc
335
253
  def self._test_MIMARKcount_PLMARK_PLMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test_MIMARKcount_PLMARK_PLMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
336
254
  @global_lisp_binding['_test_MIMARKcount_PLMARK_PLMARK'] = self.method( :_test_MIMARKcount_PLMARK_PLMARK_METHOD )
337
255
  @_test_MIMARKcount_PLMARK_PLMARK =
338
256
  trampCall(
339
257
  Proc.new { ||
340
- begin
341
- delayCall( '_vector_MIMARKset_EXMARK', 'vector-set!',
342
- begin
343
- trampCall(@_vector_MIMARKset_EXMARK)
344
- end ,
345
- [
346
- begin
347
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
348
- end ,
349
- 0 ,
350
- begin
351
- __PLMARK_ARGS2(
352
- begin
353
- trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
354
- begin
355
- trampCall(@_vector_MIMARKref)
356
- end ,
357
- [
358
- begin
359
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
360
- end ,
361
- 0
362
- ]
363
- ))
364
- end ,
365
- 1
366
- )
367
- end
368
- ]
369
- )
370
- end
258
+ delayCall( '_vector_MIMARKset_EXMARK', 'vector-set!',
259
+ trampCall(@_vector_MIMARKset_EXMARK) ,
260
+ [
261
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
262
+ 0 ,
263
+ (
264
+ trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
265
+ trampCall(@_vector_MIMARKref) ,
266
+ [
267
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
268
+ 0
269
+ ]
270
+ )) +
271
+ 1
272
+ )
273
+ ]
274
+ )
371
275
  }
372
276
  )
373
277
  end
@@ -375,43 +279,29 @@ trampCall(
375
279
  #--------------------
376
280
 
377
281
  trampCall(
378
- begin
282
+ begin #execFunc
379
283
  def self._test_MIMARKpass_PLMARK_PLMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test_MIMARKpass_PLMARK_PLMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
380
284
  @global_lisp_binding['_test_MIMARKpass_PLMARK_PLMARK'] = self.method( :_test_MIMARKpass_PLMARK_PLMARK_METHOD )
381
285
  @_test_MIMARKpass_PLMARK_PLMARK =
382
286
  trampCall(
383
287
  Proc.new { ||
384
- begin
385
- delayCall( '_vector_MIMARKset_EXMARK', 'vector-set!',
386
- begin
387
- trampCall(@_vector_MIMARKset_EXMARK)
388
- end ,
389
- [
390
- begin
391
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
392
- end ,
393
- 1 ,
394
- begin
395
- __PLMARK_ARGS2(
396
- begin
397
- trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
398
- begin
399
- trampCall(@_vector_MIMARKref)
400
- end ,
401
- [
402
- begin
403
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
404
- end ,
405
- 1
406
- ]
407
- ))
408
- end ,
409
- 1
410
- )
411
- end
412
- ]
413
- )
414
- end
288
+ delayCall( '_vector_MIMARKset_EXMARK', 'vector-set!',
289
+ trampCall(@_vector_MIMARKset_EXMARK) ,
290
+ [
291
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
292
+ 1 ,
293
+ (
294
+ trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
295
+ trampCall(@_vector_MIMARKref) ,
296
+ [
297
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
298
+ 1
299
+ ]
300
+ )) +
301
+ 1
302
+ )
303
+ ]
304
+ )
415
305
  }
416
306
  )
417
307
  end
@@ -419,43 +309,29 @@ trampCall(
419
309
  #--------------------
420
310
 
421
311
  trampCall(
422
- begin
312
+ begin #execFunc
423
313
  def self._test_MIMARKfail_PLMARK_PLMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test_MIMARKfail_PLMARK_PLMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
424
314
  @global_lisp_binding['_test_MIMARKfail_PLMARK_PLMARK'] = self.method( :_test_MIMARKfail_PLMARK_PLMARK_METHOD )
425
315
  @_test_MIMARKfail_PLMARK_PLMARK =
426
316
  trampCall(
427
317
  Proc.new { ||
428
- begin
429
- delayCall( '_vector_MIMARKset_EXMARK', 'vector-set!',
430
- begin
431
- trampCall(@_vector_MIMARKset_EXMARK)
432
- end ,
433
- [
434
- begin
435
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
436
- end ,
437
- 2 ,
438
- begin
439
- __PLMARK_ARGS2(
440
- begin
441
- trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
442
- begin
443
- trampCall(@_vector_MIMARKref)
444
- end ,
445
- [
446
- begin
447
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
448
- end ,
449
- 2
450
- ]
451
- ))
452
- end ,
453
- 1
454
- )
455
- end
456
- ]
457
- )
458
- end
318
+ delayCall( '_vector_MIMARKset_EXMARK', 'vector-set!',
319
+ trampCall(@_vector_MIMARKset_EXMARK) ,
320
+ [
321
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
322
+ 2 ,
323
+ (
324
+ trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
325
+ trampCall(@_vector_MIMARKref) ,
326
+ [
327
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
328
+ 2
329
+ ]
330
+ )) +
331
+ 1
332
+ )
333
+ ]
334
+ )
459
335
  }
460
336
  )
461
337
  end
@@ -463,43 +339,29 @@ trampCall(
463
339
  #--------------------
464
340
 
465
341
  trampCall(
466
- begin
342
+ begin #execFunc
467
343
  def self._test_MIMARKabort_PLMARK_PLMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test_MIMARKabort_PLMARK_PLMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
468
344
  @global_lisp_binding['_test_MIMARKabort_PLMARK_PLMARK'] = self.method( :_test_MIMARKabort_PLMARK_PLMARK_METHOD )
469
345
  @_test_MIMARKabort_PLMARK_PLMARK =
470
346
  trampCall(
471
347
  Proc.new { ||
472
- begin
473
- delayCall( '_vector_MIMARKset_EXMARK', 'vector-set!',
474
- begin
475
- trampCall(@_vector_MIMARKset_EXMARK)
476
- end ,
477
- [
478
- begin
479
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
480
- end ,
481
- 3 ,
482
- begin
483
- __PLMARK_ARGS2(
484
- begin
485
- trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
486
- begin
487
- trampCall(@_vector_MIMARKref)
488
- end ,
489
- [
490
- begin
491
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
492
- end ,
493
- 3
494
- ]
495
- ))
496
- end ,
497
- 1
498
- )
499
- end
500
- ]
501
- )
502
- end
348
+ delayCall( '_vector_MIMARKset_EXMARK', 'vector-set!',
349
+ trampCall(@_vector_MIMARKset_EXMARK) ,
350
+ [
351
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
352
+ 3 ,
353
+ (
354
+ trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
355
+ trampCall(@_vector_MIMARKref) ,
356
+ [
357
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
358
+ 3
359
+ ]
360
+ )) +
361
+ 1
362
+ )
363
+ ]
364
+ )
503
365
  }
504
366
  )
505
367
  end
@@ -507,75 +369,47 @@ trampCall(
507
369
  #--------------------
508
370
 
509
371
  trampCall(
510
- begin
372
+ begin #execFunc
511
373
  def self._format_MIMARKsummary_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_format_MIMARKsummary', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
512
374
  @global_lisp_binding['_format_MIMARKsummary'] = self.method( :_format_MIMARKsummary_METHOD )
513
375
  @_format_MIMARKsummary =
514
376
  trampCall(
515
377
  Proc.new { ||
516
- begin
517
- delayCall( '_sprintf', 'sprintf',
518
- begin
519
- trampCall(@_sprintf)
520
- end ,
521
- [
522
- "Total: %5d tests, %5d passed, %5d failed, %5d aborted.
523
- " ,
524
- begin
525
- trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
526
- begin
527
- trampCall(@_vector_MIMARKref)
528
- end ,
529
- [
530
- begin
531
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
532
- end ,
533
- 0
534
- ]
535
- ))
536
- end ,
537
- begin
538
- trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
539
- begin
540
- trampCall(@_vector_MIMARKref)
541
- end ,
542
- [
543
- begin
544
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
545
- end ,
546
- 1
547
- ]
548
- ))
549
- end ,
550
- begin
551
- trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
552
- begin
553
- trampCall(@_vector_MIMARKref)
554
- end ,
555
- [
556
- begin
557
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
558
- end ,
559
- 2
560
- ]
561
- ))
562
- end ,
563
- begin
564
- trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
565
- begin
566
- trampCall(@_vector_MIMARKref)
567
- end ,
568
- [
569
- begin
570
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
571
- end ,
572
- 3
573
- ]
574
- ))
575
- end
576
- ]
577
- )
578
- end
378
+ delayCall( '_sprintf', 'sprintf',
379
+ trampCall(@_sprintf) ,
380
+ [
381
+ "Total: %5d tests, %5d passed, %5d failed, %5d aborted.
382
+ " ,
383
+ trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
384
+ trampCall(@_vector_MIMARKref) ,
385
+ [
386
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
387
+ 0
388
+ ]
389
+ )) ,
390
+ trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
391
+ trampCall(@_vector_MIMARKref) ,
392
+ [
393
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
394
+ 1
395
+ ]
396
+ )) ,
397
+ trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
398
+ trampCall(@_vector_MIMARKref) ,
399
+ [
400
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
401
+ 2
402
+ ]
403
+ )) ,
404
+ trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
405
+ trampCall(@_vector_MIMARKref) ,
406
+ [
407
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
408
+ 3
409
+ ]
410
+ ))
411
+ ]
412
+ )
579
413
  }
580
414
  )
581
415
  end
@@ -583,7 +417,7 @@ trampCall(
583
417
  #--------------------
584
418
 
585
419
  trampCall(
586
- begin
420
+ begin #execFunc
587
421
  def self._read_MIMARKsummary_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_read_MIMARKsummary', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
588
422
  @global_lisp_binding['_read_MIMARKsummary'] = self.method( :_read_MIMARKsummary_METHOD )
589
423
  @_read_MIMARKsummary =
@@ -591,191 +425,109 @@ trampCall(
591
425
  Proc.new { ||
592
426
  if (
593
427
  if (
594
- begin
595
- _not(
596
- begin
597
- _eq_QUMARK(
598
- false ,
599
- begin
600
- _string_QUMARK(
601
- begin
602
- trampCall(@__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK)
603
- end
604
- )
605
- end
606
- )
607
- end
608
- )
609
- end
610
- ) then
611
- begin
612
- trampCall(File).exist?(
613
- begin
614
- trampCall(@__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK)
615
- end
428
+ _not(
429
+ _eq_QUMARK(
430
+ false ,
431
+ _string_QUMARK(
432
+ trampCall(@__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK)
433
+ )
616
434
  )
617
- end
435
+ )
436
+ ) then
437
+ trampCall(File).exist?(
438
+ trampCall(@__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK)
439
+ )
618
440
  else
619
441
  false
620
442
  end
621
443
  ) then
622
- begin
623
- begin
624
- trampCall( self._with_MIMARKopen_METHOD( 'with-open',
625
- begin
626
- trampCall(@_with_MIMARKopen)
627
- end ,
628
- [
629
- begin
630
- trampCall(@__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK)
631
- end ,
632
- Proc.new { |_f|
633
- begin
634
- ___lambda = lambda { |_m|
635
- if (
636
- begin
637
- trampCall(_m)
638
- end
639
- ) then
640
- begin
641
- begin
642
- trampCall( self._for_MIMARKeach_METHOD( 'for-each',
643
- begin
644
- trampCall(@_for_MIMARKeach)
645
- end ,
646
- [
647
- Proc.new { |_i|
648
- begin
649
- trampCall( self._vector_MIMARKset_EXMARK_METHOD( 'vector-set!',
650
- begin
651
- trampCall(@_vector_MIMARKset_EXMARK)
652
- end ,
653
- [
654
- begin
655
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
656
- end ,
657
- begin
658
- trampCall(_i)
659
- end ,
660
- begin
661
- _to_MIMARKi(
662
- begin
663
- trampCall( self._rxmatch_MIMARKsubstring_METHOD( 'rxmatch-substring',
664
- begin
665
- trampCall(@_rxmatch_MIMARKsubstring)
666
- end ,
667
- [
668
- begin
669
- trampCall(_m)
670
- end ,
671
- begin
672
- __PLMARK_ARGS2(
673
- begin
674
- trampCall(_i)
675
- end ,
676
- 1
677
- )
678
- end
679
- ]
680
- ))
681
- end
682
- )
683
- end
684
- ]
685
- ))
686
- end
687
- } ,
688
- Cell.new(0,Cell.new(1,Cell.new(2,Cell.new(3))))
689
- ]
690
- ))
691
- end
692
- end
693
- end
694
- } ; ___lambda.call(
695
- begin
696
- trampCall( self._rxmatch_METHOD( 'rxmatch',
697
- begin
698
- trampCall(@_rxmatch)
699
- end ,
700
- [
701
- Regexp.new( "Total:\\s+(\\d+)\\s+tests,\\s+(\\d+)\\s+passed,\\s+(\\d+)\\s+failed,\\s+(\\d+)\\s+aborted") ,
702
- begin
703
- trampCall(_f).readline.chomp(
704
- )
705
- end
706
- ]
707
- ))
708
- end
709
- )
710
- end
711
- }
712
- ]
713
- ))
714
- end
715
- end
444
+ trampCall( self._with_MIMARKopen_METHOD( 'with-open',
445
+ trampCall(@_with_MIMARKopen) ,
446
+ [
447
+ trampCall(@__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK) ,
448
+ Proc.new { |_f|
449
+ begin #makeLet
450
+ ___lambda = lambda { |_m|
451
+ if (
452
+ trampCall(_m)
453
+ ) then
454
+ trampCall( self._for_MIMARKeach_METHOD( 'for-each',
455
+ trampCall(@_for_MIMARKeach) ,
456
+ [
457
+ Proc.new { |_i|
458
+ trampCall( self._vector_MIMARKset_EXMARK_METHOD( 'vector-set!',
459
+ trampCall(@_vector_MIMARKset_EXMARK) ,
460
+ [
461
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
462
+ trampCall(_i) ,
463
+ _to_MIMARKi(
464
+ trampCall( self._rxmatch_MIMARKsubstring_METHOD( 'rxmatch-substring',
465
+ trampCall(@_rxmatch_MIMARKsubstring) ,
466
+ [
467
+ trampCall(_m) ,
468
+ (
469
+ trampCall(_i) +
470
+ 1
471
+ )
472
+ ]
473
+ ))
474
+ )
475
+ ]
476
+ ))
477
+ } ,
478
+ Cell.new(0,Cell.new(1,Cell.new(2,Cell.new(3))))
479
+ ]
480
+ ))
481
+ end
482
+ } ; ___lambda.call(
483
+ trampCall( self._rxmatch_METHOD( 'rxmatch',
484
+ trampCall(@_rxmatch) ,
485
+ [
486
+ Regexp.new( "Total:\\s+(\\d+)\\s+tests,\\s+(\\d+)\\s+passed,\\s+(\\d+)\\s+failed,\\s+(\\d+)\\s+aborted") ,
487
+ trampCall(_f).readline.chomp(
488
+ )
489
+ ]
490
+ ))
491
+ )
492
+ end
493
+ }
494
+ ]
495
+ ))
716
496
  end
717
- begin
497
+ begin #makeLet
718
498
  ___lambda = lambda { |_orig_MIMARKabort|
719
- begin
720
- trampCall( self._vector_MIMARKset_EXMARK_METHOD( 'vector-set!',
721
- begin
722
- trampCall(@_vector_MIMARKset_EXMARK)
723
- end ,
724
- [
725
- begin
726
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
727
- end ,
728
- 3 ,
729
- begin
730
- __PLMARK_ARGS2(
731
- begin
732
- trampCall(_orig_MIMARKabort)
733
- end ,
734
- 1
735
- )
736
- end
737
- ]
738
- ))
739
- end
740
- begin
741
- trampCall( self._write_MIMARKsummary_METHOD( 'write-summary',
742
- begin
743
- trampCall(@_write_MIMARKsummary)
744
- end ,
499
+ trampCall( self._vector_MIMARKset_EXMARK_METHOD( 'vector-set!',
500
+ trampCall(@_vector_MIMARKset_EXMARK) ,
501
+ [
502
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
503
+ 3 ,
504
+ (
505
+ trampCall(_orig_MIMARKabort) +
506
+ 1
507
+ )
508
+ ]
509
+ ))
510
+ trampCall( self._write_MIMARKsummary_METHOD( 'write-summary',
511
+ trampCall(@_write_MIMARKsummary) ,
512
+ [
513
+ ]
514
+ ))
515
+ delayCall( '_vector_MIMARKset_EXMARK', 'vector-set!',
516
+ trampCall(@_vector_MIMARKset_EXMARK) ,
517
+ [
518
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
519
+ 3 ,
520
+ trampCall(_orig_MIMARKabort)
521
+ ]
522
+ )
523
+ } ; ___lambda.call(
524
+ trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
525
+ trampCall(@_vector_MIMARKref) ,
745
526
  [
527
+ trampCall(@__ASMARKtest_MIMARKcounts_ASMARK) ,
528
+ 3
746
529
  ]
747
530
  ))
748
- end
749
- begin
750
- delayCall( '_vector_MIMARKset_EXMARK', 'vector-set!',
751
- begin
752
- trampCall(@_vector_MIMARKset_EXMARK)
753
- end ,
754
- [
755
- begin
756
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
757
- end ,
758
- 3 ,
759
- begin
760
- trampCall(_orig_MIMARKabort)
761
- end
762
- ]
763
- )
764
- end
765
- } ; ___lambda.call(
766
- begin
767
- trampCall( self._vector_MIMARKref_METHOD( 'vector-ref',
768
- begin
769
- trampCall(@_vector_MIMARKref)
770
- end ,
771
- [
772
- begin
773
- trampCall(@__ASMARKtest_MIMARKcounts_ASMARK)
774
- end ,
775
- 3
776
- ]
777
- ))
778
- end
779
531
  )
780
532
  end
781
533
  }
@@ -785,52 +537,34 @@ trampCall(
785
537
  #--------------------
786
538
 
787
539
  trampCall(
788
- begin
540
+ begin #execFunc
789
541
  def self._write_MIMARKsummary_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_write_MIMARKsummary', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
790
542
  @global_lisp_binding['_write_MIMARKsummary'] = self.method( :_write_MIMARKsummary_METHOD )
791
543
  @_write_MIMARKsummary =
792
544
  trampCall(
793
545
  Proc.new { ||
794
546
  if (
795
- begin
796
- _string_QUMARK(
797
- begin
798
- trampCall(@__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK)
799
- end
800
- )
801
- end
547
+ _string_QUMARK(
548
+ trampCall(@__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK)
549
+ )
802
550
  ) then
803
- begin
804
- begin
805
- delayCall( '_with_MIMARKopen', 'with-open',
806
- begin
807
- trampCall(@_with_MIMARKopen)
808
- end ,
809
- [
810
- begin
811
- trampCall(@__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK)
812
- end ,
813
- Proc.new { |_f|
814
- begin
815
- trampCall(_f).printf(
816
- "%s" ,
817
- begin
818
- trampCall( self._format_MIMARKsummary_METHOD( 'format-summary',
819
- begin
820
- trampCall(@_format_MIMARKsummary)
821
- end ,
822
- [
823
- ]
824
- ))
825
- end
826
- )
827
- end
828
- } ,
829
- "w"
830
- ]
831
- )
832
- end
833
- end
551
+ delayCall( '_with_MIMARKopen', 'with-open',
552
+ trampCall(@_with_MIMARKopen) ,
553
+ [
554
+ trampCall(@__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK) ,
555
+ Proc.new { |_f|
556
+ trampCall(_f).printf(
557
+ "%s" ,
558
+ trampCall( self._format_MIMARKsummary_METHOD( 'format-summary',
559
+ trampCall(@_format_MIMARKsummary) ,
560
+ [
561
+ ]
562
+ ))
563
+ )
564
+ } ,
565
+ "w"
566
+ ]
567
+ )
834
568
  end
835
569
  }
836
570
  )
@@ -839,199 +573,123 @@ trampCall(
839
573
  #--------------------
840
574
 
841
575
  trampCall(
842
- begin
576
+ begin #execFunc
843
577
  def self._prim_MIMARKtest_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_prim_MIMARKtest', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
844
578
  @global_lisp_binding['_prim_MIMARKtest'] = self.method( :_prim_MIMARKtest_METHOD )
845
579
  @_prim_MIMARKtest =
846
580
  trampCall(
847
581
  Proc.new { |_msg,_expect,_thunk,*__rest__| _compare = __rest__[0] ;
848
- begin
582
+ begin #makeLet
849
583
  ___lambda = lambda { |_cmp,_f|
850
- begin
851
- trampCall(_f).printf(
852
- "test %s, expects %s ==> " ,
853
- begin
854
- trampCall(_msg)
855
- end ,
856
- begin
857
- _write_MIMARKto_MIMARKstring(
858
- begin
859
- trampCall(_expect)
860
- end
861
- )
862
- end
863
- )
864
- end
865
- begin
866
- trampCall(_f).flush(
867
- )
868
- end
869
- begin
870
- trampCall( self._test_MIMARKcount_PLMARK_PLMARK_METHOD( 'test-count++',
871
- begin
872
- trampCall(@_test_MIMARKcount_PLMARK_PLMARK)
873
- end ,
874
- [
875
- ]
876
- ))
877
- end
878
- begin
879
- ___lambda = lambda { |_r|
880
- begin
584
+ trampCall(_f).printf(
585
+ "test %s, expects %s ==> " ,
586
+ trampCall(_msg) ,
587
+ _write_MIMARKto_MIMARKstring(
588
+ trampCall(_expect)
589
+ )
590
+ )
591
+ trampCall(_f).flush(
592
+ )
593
+ trampCall( self._test_MIMARKcount_PLMARK_PLMARK_METHOD( 'test-count++',
594
+ trampCall(@_test_MIMARKcount_PLMARK_PLMARK) ,
595
+ [
596
+ ]
597
+ ))
598
+ begin #makeLet
599
+ ___lambda = lambda { |_r|
600
+ begin #makeLet
881
601
  ___lambda = lambda { |_ret|
882
602
  if (
883
- begin
884
- trampCall(_ret)
885
- end
603
+ trampCall(_ret)
886
604
  ) then
887
- begin
888
- begin
889
- trampCall(_f).printf(
890
- "ok
605
+ begin #makeBegin
606
+ trampCall(_f).printf(
607
+ "ok
891
608
  "
892
- )
893
- end
894
- begin
895
- trampCall( self._test_MIMARKpass_PLMARK_PLMARK_METHOD( 'test-pass++',
896
- begin
897
- trampCall(@_test_MIMARKpass_PLMARK_PLMARK)
898
- end ,
899
- [
900
- ]
901
- ))
902
- end
609
+ )
610
+ trampCall( self._test_MIMARKpass_PLMARK_PLMARK_METHOD( 'test-pass++',
611
+ trampCall(@_test_MIMARKpass_PLMARK_PLMARK) ,
612
+ [
613
+ ]
614
+ ))
903
615
  end
904
616
  else
905
617
  if (
906
618
  true
907
619
  ) then
908
- begin
909
- begin
910
- trampCall(_f).printf(
911
- "ERROR: GOT %s
912
- " ,
913
- begin
914
- _write_MIMARKto_MIMARKstring(
915
- begin
916
- trampCall(_r)
917
- end
918
- )
919
- end
920
- )
921
- end
922
- begin
620
+ begin #makeBegin
621
+ trampCall(_f).printf(
622
+ "ERROR: GOT %s
623
+ " ,
624
+ _write_MIMARKto_MIMARKstring(
625
+ trampCall(_r)
626
+ )
627
+ )
628
+ begin #execFunc
923
629
  def self.__ASMARKdiscrepancy_MIMARKlist_ASMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '__ASMARKdiscrepancy_MIMARKlist_ASMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
924
630
  @global_lisp_binding['__ASMARKdiscrepancy_MIMARKlist_ASMARK'] = self.method( :__ASMARKdiscrepancy_MIMARKlist_ASMARK_METHOD )
925
631
  @__ASMARKdiscrepancy_MIMARKlist_ASMARK =
926
632
  trampCall(
927
- begin
928
- _cons(
929
- begin
930
- trampCall( self._list_METHOD( 'list',
931
- begin
932
- trampCall(@_list)
933
- end ,
934
- [
935
- begin
936
- trampCall(_msg)
937
- end ,
938
- begin
939
- trampCall(_expect)
940
- end ,
941
- begin
942
- trampCall(_r)
943
- end
944
- ]
945
- ))
946
- end ,
947
- begin
948
- trampCall(@__ASMARKdiscrepancy_MIMARKlist_ASMARK)
949
- end
950
- )
951
- end
633
+ _cons(
634
+ trampCall( self._list_METHOD( 'list',
635
+ trampCall(@_list) ,
636
+ [
637
+ trampCall(_msg) ,
638
+ trampCall(_expect) ,
639
+ trampCall(_r)
640
+ ]
641
+ )) ,
642
+ trampCall(@__ASMARKdiscrepancy_MIMARKlist_ASMARK)
643
+ )
952
644
  )
953
645
  end
954
- begin
955
- trampCall( self._test_MIMARKfail_PLMARK_PLMARK_METHOD( 'test-fail++',
956
- begin
957
- trampCall(@_test_MIMARKfail_PLMARK_PLMARK)
958
- end ,
959
- [
960
- ]
961
- ))
962
- end
646
+ trampCall( self._test_MIMARKfail_PLMARK_PLMARK_METHOD( 'test-fail++',
647
+ trampCall(@_test_MIMARKfail_PLMARK_PLMARK) ,
648
+ [
649
+ ]
650
+ ))
963
651
  end
964
652
  else
965
653
  Cell.new()
966
654
  end
967
655
  end
968
- begin
969
- trampCall(_f).flush(
970
- )
971
- end
972
- begin
973
- trampCall(_ret)
974
- end
656
+ trampCall(_f).flush(
657
+ )
658
+ trampCall(_ret)
975
659
  } ; ___lambda.call(
976
- begin
977
- trampCall( callProcedure( '_cmp', 'cmp',
978
- begin
979
- trampCall(_cmp)
980
- end ,
981
- [
982
- begin
983
- trampCall(_expect)
984
- end ,
985
- begin
986
- trampCall(_r)
987
- end
988
- ]
989
- ))
990
- end
660
+ trampCall( callProcedure( '_cmp', 'cmp',
661
+ trampCall(_cmp) ,
662
+ [
663
+ trampCall(_expect) ,
664
+ trampCall(_r)
665
+ ]
666
+ ))
991
667
  )
992
668
  end
993
669
  } ; ___lambda.call(
994
- begin
995
- trampCall( callProcedure( '_thunk', 'thunk',
996
- begin
997
- trampCall(_thunk)
998
- end ,
999
- [
1000
- ]
1001
- ))
1002
- end
670
+ trampCall( callProcedure( '_thunk', 'thunk',
671
+ trampCall(_thunk) ,
672
+ [
673
+ ]
674
+ ))
1003
675
  )
1004
676
  end
1005
677
  } ; ___lambda.call(
1006
678
  if (
1007
- begin
1008
- _pair_QUMARK(
1009
- begin
1010
- trampCall(_compare)
1011
- end
1012
- )
1013
- end
679
+ _pair_QUMARK(
680
+ trampCall(_compare)
681
+ )
1014
682
  ) then
1015
- begin
1016
- delayCall( '_car', 'car',
1017
- begin
1018
- trampCall(@_car)
1019
- end ,
1020
- [
1021
- begin
1022
- trampCall(_compare)
1023
- end
1024
- ]
1025
- )
1026
- end
683
+ delayCall( '_car', 'car',
684
+ trampCall(@_car) ,
685
+ [
686
+ trampCall(_compare)
687
+ ]
688
+ )
1027
689
  else
1028
- begin
1029
- trampCall(@_test_MIMARKcheck)
1030
- end
690
+ trampCall(@_test_MIMARKcheck)
1031
691
  end ,
1032
- begin
1033
- trampCall(@__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK)
1034
- end
692
+ trampCall(@__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK)
1035
693
  )
1036
694
  end
1037
695
  }
@@ -1041,144 +699,86 @@ trampCall(
1041
699
  #--------------------
1042
700
 
1043
701
  trampCall(
1044
- begin
702
+ begin #execFunc
1045
703
  def self._test_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1046
704
  @global_lisp_binding['_test'] = self.method( :_test_METHOD )
1047
705
  @_test =
1048
706
  trampCall(
1049
707
  Proc.new { |_msg,_expect,_thunk,*__rest__| _compare = __rest__[0] ;
1050
- begin
1051
- delayCall( '_apply', 'apply',
1052
- begin
1053
- trampCall(@_apply)
1054
- end ,
1055
- [
1056
- begin
1057
- trampCall(@_prim_MIMARKtest)
1058
- end ,
1059
- begin
1060
- trampCall(_msg)
1061
- end ,
1062
- begin
1063
- trampCall(_expect)
1064
- end ,
1065
- Proc.new { ||
1066
- begin
1067
- begin
1068
- trampCall( callProcedure( '_thunk', 'thunk',
1069
- begin
1070
- trampCall(_thunk)
1071
- end ,
1072
- [
1073
- ]
1074
- ))
1075
- end
1076
- rescue => _exc
1077
- if (
1078
- true
1079
- ) then
1080
- begin
1081
- begin
1082
- trampCall(Nendo::NendoTestError).new(
1083
- begin
1084
- trampCall(_exc).class(
1085
- )
1086
- end
1087
- )
1088
- end
1089
- end
1090
- else
1091
- if (
1092
- true
1093
- ) then
1094
- begin
1095
- begin
1096
- trampCall( self.__PAMARKraise_METHOD( '%raise',
1097
- begin
1098
- trampCall(@__PAMARKraise)
1099
- end ,
1100
- [
1101
- begin
1102
- trampCall(_exc)
1103
- end ,
1104
- begin
1105
- trampCall( self._sprintf_METHOD( 'sprintf',
1106
- begin
1107
- trampCall(@_sprintf)
1108
- end ,
708
+ delayCall( '_apply', 'apply',
709
+ trampCall(@_apply) ,
710
+ [
711
+ trampCall(@_prim_MIMARKtest) ,
712
+ trampCall(_msg) ,
713
+ trampCall(_expect) ,
714
+ Proc.new { ||
715
+ begin #makeGuard
716
+ trampCall( callProcedure( '_thunk', 'thunk',
717
+ trampCall(_thunk) ,
718
+ [
719
+ ]
720
+ ))
721
+ rescue => _exc
722
+ if (
723
+ true
724
+ ) then
725
+ trampCall(Nendo::NendoTestError).new(
726
+ trampCall(_exc).class(
727
+ )
728
+ )
729
+ else
730
+ if (
731
+ true
732
+ ) then
733
+ trampCall( self.__PAMARKraise_METHOD( '%raise',
734
+ trampCall(@__PAMARKraise) ,
735
+ [
736
+ trampCall(_exc) ,
737
+ trampCall( self._sprintf_METHOD( 'sprintf',
738
+ trampCall(@_sprintf) ,
739
+ [
740
+ "%s:%s raised %s" ,
741
+ trampCall( self.__ASMARKFILE_ASMARK_METHOD( '*FILE*',
742
+ trampCall(@__ASMARKFILE_ASMARK) ,
1109
743
  [
1110
- "%s:%s raised %s" ,
1111
- begin
1112
- trampCall( self.__ASMARKFILE_ASMARK_METHOD( '*FILE*',
1113
- begin
1114
- trampCall(@__ASMARKFILE_ASMARK)
1115
- end ,
1116
- [
1117
- ]
1118
- ))
1119
- end ,
1120
- begin
1121
- trampCall( self.__ASMARKLINE_ASMARK_METHOD( '*LINE*',
1122
- begin
1123
- trampCall(@__ASMARKLINE_ASMARK)
1124
- end ,
1125
- [
1126
- ]
1127
- ))
1128
- end ,
1129
- begin
1130
- trampCall(_exc)
1131
- end
1132
744
  ]
1133
- ))
1134
- end ,
1135
- begin
1136
- trampCall( self._sprintf_METHOD( 'sprintf',
1137
- begin
1138
- trampCall(@_sprintf)
1139
- end ,
745
+ )) ,
746
+ trampCall( self.__ASMARKLINE_ASMARK_METHOD( '*LINE*',
747
+ trampCall(@__ASMARKLINE_ASMARK) ,
1140
748
  [
1141
- "%s:%s raised %s" ,
1142
- begin
1143
- trampCall( self.__ASMARKFILE_ASMARK_METHOD( '*FILE*',
1144
- begin
1145
- trampCall(@__ASMARKFILE_ASMARK)
1146
- end ,
1147
- [
1148
- ]
1149
- ))
1150
- end ,
1151
- begin
1152
- trampCall( self.__ASMARKLINE_ASMARK_METHOD( '*LINE*',
1153
- begin
1154
- trampCall(@__ASMARKLINE_ASMARK)
1155
- end ,
1156
- [
1157
- ]
1158
- ))
1159
- end ,
1160
- begin
1161
- trampCall(_exc)
1162
- end
1163
749
  ]
1164
- ))
1165
- end
1166
- ]
1167
- ))
1168
- end
1169
- end
1170
- else
1171
- Cell.new()
1172
- end
1173
- end
1174
- end
1175
- } ,
1176
- begin
1177
- trampCall(_compare)
1178
- end
1179
- ]
1180
- )
1181
- end
750
+ )) ,
751
+ trampCall(_exc)
752
+ ]
753
+ )) ,
754
+ trampCall( self._sprintf_METHOD( 'sprintf',
755
+ trampCall(@_sprintf) ,
756
+ [
757
+ "%s:%s raised %s" ,
758
+ trampCall( self.__ASMARKFILE_ASMARK_METHOD( '*FILE*',
759
+ trampCall(@__ASMARKFILE_ASMARK) ,
760
+ [
761
+ ]
762
+ )) ,
763
+ trampCall( self.__ASMARKLINE_ASMARK_METHOD( '*LINE*',
764
+ trampCall(@__ASMARKLINE_ASMARK) ,
765
+ [
766
+ ]
767
+ )) ,
768
+ trampCall(_exc)
769
+ ]
770
+ ))
771
+ ]
772
+ ))
773
+ else
774
+ Cell.new()
775
+ end
776
+ end
777
+ end
778
+ } ,
779
+ trampCall(_compare)
780
+ ]
781
+ )
1182
782
  }
1183
783
  )
1184
784
  end
@@ -1186,56 +786,34 @@ trampCall(
1186
786
  #--------------------
1187
787
 
1188
788
  trampCall(
1189
- begin
789
+ begin #execFunc
1190
790
  def self._test_ASMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test_ASMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1191
791
  @global_lisp_binding['_test_ASMARK'] = self.method( :_test_ASMARK_METHOD )
1192
792
  @_test_ASMARK =
1193
793
  trampCall(
1194
794
  LispMacro.new { |_msg,_expect,_form,*__rest__| _compare = __rest__[0] ;
1195
- begin
1196
- _cons(
1197
- :"test" ,
1198
- begin
1199
- _cons(
1200
- begin
1201
- trampCall(_msg)
1202
- end ,
1203
- begin
795
+ _cons(
796
+ :"test" ,
797
+ _cons(
798
+ trampCall(_msg) ,
799
+ _cons(
800
+ trampCall(_expect) ,
1204
801
  _cons(
1205
- begin
1206
- trampCall(_expect)
1207
- end ,
1208
- begin
1209
- _cons(
1210
- begin
1211
- _cons(
1212
- :"lambda" ,
1213
- begin
1214
- _cons(
1215
- Cell.new() ,
1216
- begin
1217
- _cons(
1218
- begin
1219
- trampCall(_form)
1220
- end ,
1221
- Cell.new()
1222
- )
1223
- end
1224
- )
1225
- end
1226
- )
1227
- end ,
1228
- begin
1229
- trampCall(_compare)
1230
- end
1231
- )
1232
- end
802
+ _cons(
803
+ :"lambda" ,
804
+ _cons(
805
+ Cell.new() ,
806
+ _cons(
807
+ trampCall(_form) ,
808
+ Cell.new()
809
+ )
810
+ )
811
+ ) ,
812
+ trampCall(_compare)
1233
813
  )
1234
- end
1235
- )
1236
- end
1237
- )
1238
- end
814
+ )
815
+ )
816
+ )
1239
817
  }
1240
818
  )
1241
819
  end
@@ -1243,47 +821,31 @@ trampCall(
1243
821
  #--------------------
1244
822
 
1245
823
  trampCall(
1246
- begin
824
+ begin #execFunc
1247
825
  def self._make_MIMARKpadding_MIMARKstring_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_make_MIMARKpadding_MIMARKstring', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1248
826
  @global_lisp_binding['_make_MIMARKpadding_MIMARKstring'] = self.method( :_make_MIMARKpadding_MIMARKstring_METHOD )
1249
827
  @_make_MIMARKpadding_MIMARKstring =
1250
828
  trampCall(
1251
829
  Proc.new { |_num,_char|
1252
- begin
1253
- delayCall( '_string_MIMARKjoin', 'string-join',
1254
- begin
1255
- trampCall(@_string_MIMARKjoin)
1256
- end ,
1257
- [
1258
- begin
1259
- trampCall( self._map_METHOD( 'map',
1260
- begin
1261
- trampCall(@_map)
1262
- end ,
1263
- [
1264
- Proc.new { |_x|
1265
- begin
1266
- trampCall(_char)
1267
- end
1268
- } ,
1269
- begin
1270
- trampCall( self._range_METHOD( 'range',
1271
- begin
1272
- trampCall(@_range)
1273
- end ,
1274
- [
1275
- begin
1276
- trampCall(_num)
1277
- end
1278
- ]
1279
- ))
1280
- end
1281
- ]
1282
- ))
1283
- end
1284
- ]
1285
- )
1286
- end
830
+ delayCall( '_string_MIMARKjoin', 'string-join',
831
+ trampCall(@_string_MIMARKjoin) ,
832
+ [
833
+ trampCall( self._map_METHOD( 'map',
834
+ trampCall(@_map) ,
835
+ [
836
+ Proc.new { |_x|
837
+ trampCall(_char)
838
+ } ,
839
+ trampCall( self._range_METHOD( 'range',
840
+ trampCall(@_range) ,
841
+ [
842
+ trampCall(_num)
843
+ ]
844
+ ))
845
+ ]
846
+ ))
847
+ ]
848
+ )
1287
849
  }
1288
850
  )
1289
851
  end
@@ -1291,70 +853,44 @@ trampCall(
1291
853
  #--------------------
1292
854
 
1293
855
  trampCall(
1294
- begin
856
+ begin #execFunc
1295
857
  def self._test_MIMARKsection_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test_MIMARKsection', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1296
858
  @global_lisp_binding['_test_MIMARKsection'] = self.method( :_test_MIMARKsection_METHOD )
1297
859
  @_test_MIMARKsection =
1298
860
  trampCall(
1299
861
  Proc.new { |_msg|
1300
- begin
862
+ begin #makeLet
1301
863
  ___lambda = lambda { |_f,_msglen|
1302
- begin
1303
- trampCall(_f).printf(
1304
- "<%s>%s
1305
- " ,
1306
- begin
1307
- trampCall(_msg)
1308
- end ,
1309
- begin
1310
- trampCall( self._make_MIMARKpadding_MIMARKstring_METHOD( 'make-padding-string',
1311
- begin
1312
- trampCall(@_make_MIMARKpadding_MIMARKstring)
1313
- end ,
1314
- [
1315
- begin
1316
- trampCall( self._max_METHOD( 'max',
1317
- begin
1318
- trampCall(@_max)
1319
- end ,
1320
- [
1321
- 5 ,
1322
- begin
1323
- __MIMARK_ARGS2(
1324
- 77 ,
1325
- begin
1326
- trampCall(_msglen)
1327
- end
1328
- )
1329
- end
1330
- ]
1331
- ))
1332
- end ,
1333
- "-"
1334
- ]
1335
- ))
1336
- end
1337
- )
1338
- end
1339
- begin
1340
- trampCall(_msg)
1341
- end
864
+ trampCall(_f).printf(
865
+ "<%s>%s
866
+ " ,
867
+ trampCall(_msg) ,
868
+ trampCall( self._make_MIMARKpadding_MIMARKstring_METHOD( 'make-padding-string',
869
+ trampCall(@_make_MIMARKpadding_MIMARKstring) ,
870
+ [
871
+ trampCall( self._max_METHOD( 'max',
872
+ trampCall(@_max) ,
873
+ [
874
+ 5 ,
875
+ (
876
+ 77 -
877
+ trampCall(_msglen)
878
+ )
879
+ ]
880
+ )) ,
881
+ "-"
882
+ ]
883
+ ))
884
+ )
885
+ trampCall(_msg)
1342
886
  } ; ___lambda.call(
1343
- begin
1344
- trampCall(@__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK)
1345
- end ,
1346
- begin
1347
- trampCall( self._string_MIMARKlength_METHOD( 'string-length',
1348
- begin
1349
- trampCall(@_string_MIMARKlength)
1350
- end ,
1351
- [
1352
- begin
1353
- trampCall(_msg)
1354
- end
1355
- ]
1356
- ))
1357
- end
887
+ trampCall(@__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK) ,
888
+ trampCall( self._string_MIMARKlength_METHOD( 'string-length',
889
+ trampCall(@_string_MIMARKlength) ,
890
+ [
891
+ trampCall(_msg)
892
+ ]
893
+ ))
1358
894
  )
1359
895
  end
1360
896
  }
@@ -1364,49 +900,35 @@ trampCall(
1364
900
  #--------------------
1365
901
 
1366
902
  trampCall(
1367
- begin
903
+ begin #execFunc
1368
904
  def self._test_MIMARKstart_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test_MIMARKstart', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1369
905
  @global_lisp_binding['_test_MIMARKstart'] = self.method( :_test_MIMARKstart_METHOD )
1370
906
  @_test_MIMARKstart =
1371
907
  trampCall(
1372
908
  Proc.new { |_msg|
1373
- begin
909
+ begin #makeLet
1374
910
  ___lambda = lambda { |_s|
1375
- begin
911
+ begin #makeLet
1376
912
  ___lambda = lambda { |_pad|
1377
- begin
913
+ begin #makeLet
1378
914
  ___lambda = lambda { |_f|
1379
- begin
1380
- trampCall(_f).printf(
1381
- "%s%s" ,
1382
- begin
1383
- trampCall(_s)
1384
- end ,
1385
- begin
1386
- trampCall(_pad)
1387
- end
1388
- )
1389
- end
1390
- begin
1391
- trampCall(_f).flush(
1392
- )
1393
- end
1394
- begin
1395
- trampCall( self._read_MIMARKsummary_METHOD( 'read-summary',
1396
- begin
1397
- trampCall(@_read_MIMARKsummary)
1398
- end ,
1399
- [
1400
- ]
1401
- ))
1402
- end
1403
- begin
1404
- trampCall(_f).printf(
1405
- "
915
+ trampCall(_f).printf(
916
+ "%s%s" ,
917
+ trampCall(_s) ,
918
+ trampCall(_pad)
919
+ )
920
+ trampCall(_f).flush(
921
+ )
922
+ trampCall( self._read_MIMARKsummary_METHOD( 'read-summary',
923
+ trampCall(@_read_MIMARKsummary) ,
924
+ [
925
+ ]
926
+ ))
927
+ trampCall(_f).printf(
928
+ "
1406
929
  "
1407
- )
1408
- end
1409
- begin
930
+ )
931
+ begin #execFunc
1410
932
  def self.__ASMARKdiscrepancy_MIMARKlist_ASMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '__ASMARKdiscrepancy_MIMARKlist_ASMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1411
933
  @global_lisp_binding['__ASMARKdiscrepancy_MIMARKlist_ASMARK'] = self.method( :__ASMARKdiscrepancy_MIMARKlist_ASMARK_METHOD )
1412
934
  @__ASMARKdiscrepancy_MIMARKlist_ASMARK =
@@ -1414,127 +936,77 @@ trampCall(
1414
936
  Cell.new()
1415
937
  )
1416
938
  end
1417
- begin
939
+ begin #makeLet
1418
940
  ___lambda = lambda { |_msglen|
1419
- begin
1420
- trampCall(_f).printf(
1421
- "Testing %s %s
1422
- " ,
1423
- begin
1424
- trampCall(_msg)
1425
- end ,
1426
- begin
1427
- trampCall( self._make_MIMARKpadding_MIMARKstring_METHOD( 'make-padding-string',
1428
- begin
1429
- trampCall(@_make_MIMARKpadding_MIMARKstring)
1430
- end ,
1431
- [
1432
- begin
1433
- trampCall( self._max_METHOD( 'max',
1434
- begin
1435
- trampCall(@_max)
1436
- end ,
1437
- [
1438
- 5 ,
1439
- begin
1440
- __MIMARK_ARGS2(
1441
- 70 ,
1442
- begin
1443
- trampCall(_msglen)
1444
- end
1445
- )
1446
- end
1447
- ]
1448
- ))
1449
- end ,
1450
- "-"
1451
- ]
1452
- ))
1453
- end
1454
- )
1455
- end
1456
- begin
1457
- trampCall(_f).flush(
1458
- )
1459
- end
941
+ trampCall(_f).printf(
942
+ "Testing %s %s
943
+ " ,
944
+ trampCall(_msg) ,
945
+ trampCall( self._make_MIMARKpadding_MIMARKstring_METHOD( 'make-padding-string',
946
+ trampCall(@_make_MIMARKpadding_MIMARKstring) ,
947
+ [
948
+ trampCall( self._max_METHOD( 'max',
949
+ trampCall(@_max) ,
950
+ [
951
+ 5 ,
952
+ (
953
+ 70 -
954
+ trampCall(_msglen)
955
+ )
956
+ ]
957
+ )) ,
958
+ "-"
959
+ ]
960
+ ))
961
+ )
962
+ trampCall(_f).flush(
963
+ )
1460
964
  } ; ___lambda.call(
1461
- begin
1462
- trampCall( self._string_MIMARKlength_METHOD( 'string-length',
1463
- begin
1464
- trampCall(@_string_MIMARKlength)
1465
- end ,
1466
- [
1467
- begin
1468
- trampCall(_msg)
1469
- end
1470
- ]
1471
- ))
1472
- end
965
+ trampCall( self._string_MIMARKlength_METHOD( 'string-length',
966
+ trampCall(@_string_MIMARKlength) ,
967
+ [
968
+ trampCall(_msg)
969
+ ]
970
+ ))
1473
971
  )
1474
972
  end
1475
- begin
1476
- trampCall(_msg)
1477
- end
973
+ trampCall(_msg)
1478
974
  } ; ___lambda.call(
1479
- begin
1480
- trampCall(@__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK)
1481
- end
975
+ trampCall(@__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK)
1482
976
  )
1483
977
  end
1484
978
  } ; ___lambda.call(
1485
- begin
1486
- trampCall( self._make_MIMARKpadding_MIMARKstring_METHOD( 'make-padding-string',
1487
- begin
1488
- trampCall(@_make_MIMARKpadding_MIMARKstring)
1489
- end ,
1490
- [
1491
- begin
1492
- trampCall( self._max_METHOD( 'max',
1493
- begin
1494
- trampCall(@_max)
1495
- end ,
1496
- [
1497
- 3 ,
1498
- begin
1499
- __MIMARK_ARGS2(
1500
- 65 ,
1501
- begin
1502
- trampCall( self._string_MIMARKlength_METHOD( 'string-length',
1503
- begin
1504
- trampCall(@_string_MIMARKlength)
1505
- end ,
1506
- [
1507
- begin
1508
- trampCall(_s)
1509
- end
1510
- ]
1511
- ))
1512
- end
1513
- )
1514
- end
1515
- ]
1516
- ))
1517
- end ,
1518
- " "
1519
- ]
1520
- ))
1521
- end
979
+ trampCall( self._make_MIMARKpadding_MIMARKstring_METHOD( 'make-padding-string',
980
+ trampCall(@_make_MIMARKpadding_MIMARKstring) ,
981
+ [
982
+ trampCall( self._max_METHOD( 'max',
983
+ trampCall(@_max) ,
984
+ [
985
+ 3 ,
986
+ (
987
+ 65 -
988
+ trampCall( self._string_MIMARKlength_METHOD( 'string-length',
989
+ trampCall(@_string_MIMARKlength) ,
990
+ [
991
+ trampCall(_s)
992
+ ]
993
+ ))
994
+ )
995
+ ]
996
+ )) ,
997
+ " "
998
+ ]
999
+ ))
1522
1000
  )
1523
1001
  end
1524
1002
  } ; ___lambda.call(
1525
- begin
1526
- trampCall( self._sprintf_METHOD( 'sprintf',
1527
- begin
1528
- trampCall(@_sprintf)
1529
- end ,
1530
- [
1531
- "Testing %s ... " ,
1532
- begin
1533
- trampCall(_msg)
1534
- end
1535
- ]
1536
- ))
1537
- end
1003
+ trampCall( self._sprintf_METHOD( 'sprintf',
1004
+ trampCall(@_sprintf) ,
1005
+ [
1006
+ "Testing %s ... " ,
1007
+ trampCall(_msg)
1008
+ ]
1009
+ ))
1538
1010
  )
1539
1011
  end
1540
1012
  }
@@ -1544,141 +1016,85 @@ trampCall(
1544
1016
  #--------------------
1545
1017
 
1546
1018
  trampCall(
1547
- begin
1019
+ begin #execFunc
1548
1020
  def self._test_MIMARKend_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test_MIMARKend', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1549
1021
  @global_lisp_binding['_test_MIMARKend'] = self.method( :_test_MIMARKend_METHOD )
1550
1022
  @_test_MIMARKend =
1551
1023
  trampCall(
1552
1024
  Proc.new { ||
1553
- begin
1025
+ begin #makeLet
1554
1026
  ___lambda = lambda { |_f|
1555
1027
  if (
1556
- begin
1557
- _null_QUMARK(
1558
- begin
1559
- trampCall(@__ASMARKdiscrepancy_MIMARKlist_ASMARK)
1560
- end
1561
- )
1562
- end
1028
+ _null_QUMARK(
1029
+ trampCall(@__ASMARKdiscrepancy_MIMARKlist_ASMARK)
1030
+ )
1563
1031
  ) then
1564
- begin
1565
- trampCall(_f).printf(
1566
- "passed.
1032
+ trampCall(_f).printf(
1033
+ "passed.
1567
1034
  "
1568
- )
1569
- end
1035
+ )
1570
1036
  else
1571
- begin
1572
- begin
1573
- trampCall(_f).printf(
1574
- "failed.
1037
+ begin #makeBegin
1038
+ trampCall(_f).printf(
1039
+ "failed.
1575
1040
  discrepancies found. Errors are:
1576
1041
  "
1577
- )
1578
- end
1579
- begin
1580
- trampCall( self._for_MIMARKeach_METHOD( 'for-each',
1581
- begin
1582
- trampCall(@_for_MIMARKeach)
1583
- end ,
1584
- [
1585
- Proc.new { |_r|
1586
- begin
1587
- trampCall(_f).printf(
1588
- "test %s: expects %s => got %s
1589
- " ,
1590
- begin
1591
- trampCall( self._first_METHOD( 'first',
1592
- begin
1593
- trampCall(@_first)
1594
- end ,
1595
- [
1596
- begin
1597
- trampCall(_r)
1598
- end
1599
- ]
1600
- ))
1601
- end ,
1602
- begin
1603
- _write_MIMARKto_MIMARKstring(
1604
- begin
1605
- trampCall( self._second_METHOD( 'second',
1606
- begin
1607
- trampCall(@_second)
1608
- end ,
1609
- [
1610
- begin
1611
- trampCall(_r)
1612
- end
1613
- ]
1614
- ))
1615
- end
1616
- )
1617
- end ,
1618
- begin
1619
- _write_MIMARKto_MIMARKstring(
1620
- begin
1621
- trampCall( self._third_METHOD( 'third',
1622
- begin
1623
- trampCall(@_third)
1624
- end ,
1625
- [
1626
- begin
1627
- trampCall(_r)
1628
- end
1629
- ]
1630
- ))
1631
- end
1632
- )
1633
- end
1042
+ )
1043
+ trampCall( self._for_MIMARKeach_METHOD( 'for-each',
1044
+ trampCall(@_for_MIMARKeach) ,
1045
+ [
1046
+ Proc.new { |_r|
1047
+ trampCall(_f).printf(
1048
+ "test %s: expects %s => got %s
1049
+ " ,
1050
+ trampCall( self._first_METHOD( 'first',
1051
+ trampCall(@_first) ,
1052
+ [
1053
+ trampCall(_r)
1054
+ ]
1055
+ )) ,
1056
+ _write_MIMARKto_MIMARKstring(
1057
+ trampCall( self._second_METHOD( 'second',
1058
+ trampCall(@_second) ,
1059
+ [
1060
+ trampCall(_r)
1061
+ ]
1062
+ ))
1063
+ ) ,
1064
+ _write_MIMARKto_MIMARKstring(
1065
+ trampCall( self._third_METHOD( 'third',
1066
+ trampCall(@_third) ,
1067
+ [
1068
+ trampCall(_r)
1069
+ ]
1070
+ ))
1634
1071
  )
1635
- end
1636
- } ,
1637
- begin
1638
- _reverse(
1639
- begin
1640
- trampCall(@__ASMARKdiscrepancy_MIMARKlist_ASMARK)
1641
- end
1642
1072
  )
1643
- end
1644
- ]
1645
- ))
1646
- end
1073
+ } ,
1074
+ _reverse(
1075
+ trampCall(@__ASMARKdiscrepancy_MIMARKlist_ASMARK)
1076
+ )
1077
+ ]
1078
+ ))
1647
1079
  end
1648
1080
  end
1649
1081
  if (
1650
- begin
1651
- trampCall(@__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK)
1652
- end
1082
+ trampCall(@__ASMARKtest_MIMARKrecord_MIMARKfile_ASMARK)
1653
1083
  ) then
1654
- begin
1655
- begin
1656
- trampCall( self._write_MIMARKsummary_METHOD( 'write-summary',
1657
- begin
1658
- trampCall(@_write_MIMARKsummary)
1659
- end ,
1660
- [
1661
- ]
1662
- ))
1663
- end
1664
- end
1665
- end
1666
- begin
1667
- delayCall( '_length', 'length',
1668
- begin
1669
- trampCall(@_length)
1670
- end ,
1671
- [
1672
- begin
1673
- trampCall(@__ASMARKdiscrepancy_MIMARKlist_ASMARK)
1674
- end
1675
- ]
1676
- )
1084
+ trampCall( self._write_MIMARKsummary_METHOD( 'write-summary',
1085
+ trampCall(@_write_MIMARKsummary) ,
1086
+ [
1087
+ ]
1088
+ ))
1677
1089
  end
1090
+ delayCall( '_length', 'length',
1091
+ trampCall(@_length) ,
1092
+ [
1093
+ trampCall(@__ASMARKdiscrepancy_MIMARKlist_ASMARK)
1094
+ ]
1095
+ )
1678
1096
  } ; ___lambda.call(
1679
- begin
1680
- trampCall(@__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK)
1681
- end
1097
+ trampCall(@__ASMARKtest_MIMARKoutput_MIMARKfile_ASMARK)
1682
1098
  )
1683
1099
  end
1684
1100
  }
@@ -1688,15 +1104,13 @@ discrepancies found. Errors are:
1688
1104
  #--------------------
1689
1105
 
1690
1106
  trampCall(
1691
- begin
1107
+ begin #execFunc
1692
1108
  def self._test_MIMARKmodule_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_test_MIMARKmodule', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1693
1109
  @global_lisp_binding['_test_MIMARKmodule'] = self.method( :_test_MIMARKmodule_METHOD )
1694
1110
  @_test_MIMARKmodule =
1695
1111
  trampCall(
1696
1112
  Proc.new { |_module_MIMARKname|
1697
- begin
1698
- trampCall(_module_MIMARKname)
1699
- end
1113
+ trampCall(_module_MIMARKname)
1700
1114
  }
1701
1115
  )
1702
1116
  end