nendo 0.7.0 → 0.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
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