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