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/text/html-lite.nndc CHANGED
@@ -4,162 +4,110 @@
4
4
  #
5
5
 
6
6
  trampCall(
7
- begin
7
+ begin #execFunc
8
8
  def self._html_MIMARKescape_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_MIMARKescape', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
9
9
  @global_lisp_binding['_html_MIMARKescape'] = self.method( :_html_MIMARKescape_METHOD )
10
10
  @_html_MIMARKescape =
11
11
  trampCall(
12
12
  Proc.new { |_c|
13
- begin
13
+ begin #makeLet
14
14
  ___lambda = lambda { |___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30192|
15
15
  if (
16
- begin
16
+ begin #makeLet
17
17
  ___lambda = lambda { |___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30198|
18
18
  if (
19
- begin
20
- trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30198)
21
- end
19
+ trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30198)
22
20
  ) then
23
- begin
24
- trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30198)
25
- end
21
+ trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30198)
26
22
  else
27
23
  false
28
24
  end
29
25
  } ; ___lambda.call(
30
- begin
31
- trampCall( self._eqv_QUMARK_METHOD( 'eqv?',
32
- begin
33
- trampCall(@_eqv_QUMARK)
34
- end ,
35
- [
36
- "<" ,
37
- begin
38
- trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30192)
39
- end
40
- ]
41
- ))
42
- end
26
+ trampCall( self._eqv_QUMARK_METHOD( 'eqv?',
27
+ trampCall(@_eqv_QUMARK) ,
28
+ [
29
+ "<" ,
30
+ trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30192)
31
+ ]
32
+ ))
43
33
  )
44
34
  end
45
35
  ) then
46
- begin
47
- "&lt;"
48
- end
36
+ "&lt;"
49
37
  else
50
38
  if (
51
- begin
39
+ begin #makeLet
52
40
  ___lambda = lambda { |___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30199|
53
41
  if (
54
- begin
55
- trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30199)
56
- end
42
+ trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30199)
57
43
  ) then
58
- begin
59
- trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30199)
60
- end
44
+ trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30199)
61
45
  else
62
46
  false
63
47
  end
64
48
  } ; ___lambda.call(
65
- begin
66
- trampCall( self._eqv_QUMARK_METHOD( 'eqv?',
67
- begin
68
- trampCall(@_eqv_QUMARK)
69
- end ,
70
- [
71
- ">" ,
72
- begin
73
- trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30192)
74
- end
75
- ]
76
- ))
77
- end
49
+ trampCall( self._eqv_QUMARK_METHOD( 'eqv?',
50
+ trampCall(@_eqv_QUMARK) ,
51
+ [
52
+ ">" ,
53
+ trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30192)
54
+ ]
55
+ ))
78
56
  )
79
57
  end
80
58
  ) then
81
- begin
82
- "&gt;"
83
- end
59
+ "&gt;"
84
60
  else
85
61
  if (
86
- begin
62
+ begin #makeLet
87
63
  ___lambda = lambda { |___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30200|
88
64
  if (
89
- begin
90
- trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30200)
91
- end
65
+ trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30200)
92
66
  ) then
93
- begin
94
- trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30200)
95
- end
67
+ trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30200)
96
68
  else
97
69
  false
98
70
  end
99
71
  } ; ___lambda.call(
100
- begin
101
- trampCall( self._eqv_QUMARK_METHOD( 'eqv?',
102
- begin
103
- trampCall(@_eqv_QUMARK)
104
- end ,
105
- [
106
- "&" ,
107
- begin
108
- trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30192)
109
- end
110
- ]
111
- ))
112
- end
72
+ trampCall( self._eqv_QUMARK_METHOD( 'eqv?',
73
+ trampCall(@_eqv_QUMARK) ,
74
+ [
75
+ "&" ,
76
+ trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30192)
77
+ ]
78
+ ))
113
79
  )
114
80
  end
115
81
  ) then
116
- begin
117
- "&amp;"
118
- end
82
+ "&amp;"
119
83
  else
120
84
  if (
121
- begin
85
+ begin #makeLet
122
86
  ___lambda = lambda { |___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30201|
123
87
  if (
124
- begin
125
- trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30201)
126
- end
88
+ trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30201)
127
89
  ) then
128
- begin
129
- trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30201)
130
- end
90
+ trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30201)
131
91
  else
132
92
  false
133
93
  end
134
94
  } ; ___lambda.call(
135
- begin
136
- trampCall( self._eqv_QUMARK_METHOD( 'eqv?',
137
- begin
138
- trampCall(@_eqv_QUMARK)
139
- end ,
140
- [
141
- "\"" ,
142
- begin
143
- trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30192)
144
- end
145
- ]
146
- ))
147
- end
95
+ trampCall( self._eqv_QUMARK_METHOD( 'eqv?',
96
+ trampCall(@_eqv_QUMARK) ,
97
+ [
98
+ "\"" ,
99
+ trampCall(___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30192)
100
+ ]
101
+ ))
148
102
  )
149
103
  end
150
104
  ) then
151
- begin
152
- "&quot;"
153
- end
105
+ "&quot;"
154
106
  else
155
107
  if (
156
108
  true
157
109
  ) then
158
- begin
159
- begin
160
- trampCall(_c)
161
- end
162
- end
110
+ trampCall(_c)
163
111
  else
164
112
  Cell.new()
165
113
  end
@@ -168,9 +116,7 @@ trampCall(
168
116
  end
169
117
  end
170
118
  } ; ___lambda.call(
171
- begin
172
- trampCall(_c)
173
- end
119
+ trampCall(_c)
174
120
  )
175
121
  end
176
122
  }
@@ -180,43 +126,29 @@ trampCall(
180
126
  #--------------------
181
127
 
182
128
  trampCall(
183
- begin
129
+ begin #execFunc
184
130
  def self._html_MIMARKescape_MIMARKstring_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_MIMARKescape_MIMARKstring', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
185
131
  @global_lisp_binding['_html_MIMARKescape_MIMARKstring'] = self.method( :_html_MIMARKescape_MIMARKstring_METHOD )
186
132
  @_html_MIMARKescape_MIMARKstring =
187
133
  trampCall(
188
134
  Proc.new { |_string|
189
- begin
190
- delayCall( '_string_MIMARKjoin', 'string-join',
191
- begin
192
- trampCall(@_string_MIMARKjoin)
193
- end ,
194
- [
195
- begin
196
- trampCall( self._map_METHOD( 'map',
197
- begin
198
- trampCall(@_map)
199
- end ,
200
- [
201
- begin
202
- trampCall(@_html_MIMARKescape)
203
- end ,
204
- begin
205
- _to_MIMARKlist(
206
- begin
207
- trampCall(_string).to_s.split(
208
- ""
209
- )
210
- end
135
+ delayCall( '_string_MIMARKjoin', 'string-join',
136
+ trampCall(@_string_MIMARKjoin) ,
137
+ [
138
+ trampCall( self._map_METHOD( 'map',
139
+ trampCall(@_map) ,
140
+ [
141
+ trampCall(@_html_MIMARKescape) ,
142
+ _to_MIMARKlist(
143
+ trampCall(_string).to_s.split(
144
+ ""
211
145
  )
212
- end
213
- ]
214
- ))
215
- end ,
216
- ""
217
- ]
218
- )
219
- end
146
+ )
147
+ ]
148
+ )) ,
149
+ ""
150
+ ]
151
+ )
220
152
  }
221
153
  )
222
154
  end
@@ -224,7 +156,7 @@ trampCall(
224
156
  #--------------------
225
157
 
226
158
  trampCall(
227
- begin
159
+ begin #execFunc
228
160
  def self.__ASMARKdoctype_MIMARKalist_ASMARK_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '__ASMARKdoctype_MIMARKalist_ASMARK', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
229
161
  @global_lisp_binding['__ASMARKdoctype_MIMARKalist_ASMARK'] = self.method( :__ASMARKdoctype_MIMARKalist_ASMARK_METHOD )
230
162
  @__ASMARKdoctype_MIMARKalist_ASMARK =
@@ -250,104 +182,72 @@ trampCall(
250
182
  #--------------------
251
183
 
252
184
  trampCall(
253
- begin
185
+ begin #execFunc
254
186
  def self._html_MIMARKdoctype_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_MIMARKdoctype', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
255
187
  @global_lisp_binding['_html_MIMARKdoctype'] = self.method( :_html_MIMARKdoctype_METHOD )
256
188
  @_html_MIMARKdoctype =
257
189
  trampCall(
258
190
  Proc.new { |*__rest__| _type = __rest__[0] ;
259
- begin
191
+ begin #makeLet
260
192
  ___lambda = lambda { |_type|
261
193
  if (
262
- begin
194
+ begin #execFunc
263
195
  def self.___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30203_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30203', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
264
196
  @global_lisp_binding['___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30203'] = self.method( :___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30203_METHOD )
265
197
  @___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30203 =
266
198
  trampCall(
267
- begin
268
- trampCall( self._find_METHOD( 'find',
269
- begin
270
- trampCall(@_find)
271
- end ,
272
- [
273
- Proc.new { |_e|
274
- begin
275
- trampCall( self._memq_METHOD( 'memq',
276
- begin
277
- trampCall(@_memq)
278
- end ,
279
- [
280
- begin
281
- trampCall(_type)
282
- end ,
283
- begin
284
- _car(
285
- begin
286
- trampCall(_e)
287
- end
288
- )
289
- end
290
- ]
291
- ))
292
- end
293
- } ,
294
- begin
295
- trampCall(@__ASMARKdoctype_MIMARKalist_ASMARK)
296
- end
297
- ]
298
- ))
299
- end
199
+ trampCall( self._find_METHOD( 'find',
200
+ trampCall(@_find) ,
201
+ [
202
+ Proc.new { |_e|
203
+ trampCall( self._memq_METHOD( 'memq',
204
+ trampCall(@_memq) ,
205
+ [
206
+ trampCall(_type) ,
207
+ _car(
208
+ trampCall(_e)
209
+ )
210
+ ]
211
+ ))
212
+ } ,
213
+ trampCall(@__ASMARKdoctype_MIMARKalist_ASMARK)
214
+ ]
215
+ ))
300
216
  )
301
217
  end
302
218
  ) then
303
- begin
304
- delayCall( '_caddr', 'caddr',
305
- begin
306
- trampCall(@_caddr)
307
- end ,
308
- [
309
- begin
310
- trampCall(@___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30203)
311
- end
312
- ]
313
- )
314
- end
219
+ delayCall( '_caddr', 'caddr',
220
+ trampCall(@_caddr) ,
221
+ [
222
+ trampCall(@___gensym__95685ec818bb762effb7679d4635458e28ab89ab_30203)
223
+ ]
224
+ )
315
225
  else
316
226
  if (
317
227
  true
318
228
  ) then
319
- begin
320
- begin raise RuntimeError,
321
- "Unknown doctype type spec" ' ' +
322
- _write_MIMARKto_MIMARKstring(
323
- begin
324
- trampCall(_type)
325
- end
326
- )
327
- rescue => __e
328
- __e.set_backtrace( ["./lib/nendo/text/html-lite.nnd:99"] + __e.backtrace )
329
- raise __e
330
- end
331
- end
229
+ begin raise RuntimeError,
230
+ "Unknown doctype type spec" ' ' +
231
+ _write_MIMARKto_MIMARKstring(
232
+ trampCall(_type)
233
+ )
234
+ rescue => __e
235
+ __e.set_backtrace( ["./lib/nendo/text/html-lite.nnd:99"] + __e.backtrace )
236
+ raise __e
237
+ end
332
238
  else
333
239
  Cell.new()
334
240
  end
335
241
  end
336
242
  } ; ___lambda.call(
337
243
  if (
338
- begin
339
- _null_QUMARK(
340
- begin
341
- trampCall(_type)
342
- end
343
- )
344
- end
244
+ _null_QUMARK(
245
+ trampCall(_type)
246
+ )
345
247
  ) then
346
248
  LispKeyword.new( "html-4.01-strict" )
347
249
  else
348
- begin
349
- trampCall(_type)
350
- end
250
+ trampCall(_type)
351
251
  end
352
252
  )
353
253
  end
@@ -358,510 +258,290 @@ trampCall(
358
258
  #--------------------
359
259
 
360
260
  trampCall(
361
- begin
261
+ begin #execFunc
362
262
  def self._make_MIMARKhtml_MIMARKelement_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_make_MIMARKhtml_MIMARKelement', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
363
263
  @global_lisp_binding['_make_MIMARKhtml_MIMARKelement'] = self.method( :_make_MIMARKhtml_MIMARKelement_METHOD )
364
264
  @_make_MIMARKhtml_MIMARKelement =
365
265
  trampCall(
366
266
  Proc.new { |_name,*__rest__| _args = __rest__[0] ;
367
- begin
267
+ begin #makeLetrec
368
268
  ___lambda = lambda { |_get_MIMARKattr|
369
269
  _get_MIMARKattr =
370
270
  Proc.new { |_args,_attrs|
371
271
  if (
372
- begin
373
- _null_QUMARK(
374
- begin
375
- trampCall(_args)
376
- end
377
- )
378
- end
272
+ _null_QUMARK(
273
+ trampCall(_args)
274
+ )
379
275
  ) then
380
- begin
381
- begin
382
- delayCall( '_values', 'values',
383
- begin
384
- trampCall(@_values)
385
- end ,
386
- [
387
- begin
388
- _reverse(
389
- begin
390
- trampCall(_attrs)
391
- end
392
- )
393
- end ,
394
- begin
395
- trampCall(_args)
396
- end
397
- ]
398
- )
399
- end
400
- end
276
+ delayCall( '_values', 'values',
277
+ trampCall(@_values) ,
278
+ [
279
+ _reverse(
280
+ trampCall(_attrs)
281
+ ) ,
282
+ trampCall(_args)
283
+ ]
284
+ )
401
285
  else
402
286
  if (
403
- begin
404
- _keyword_QUMARK(
405
- begin
406
- _car(
407
- begin
408
- trampCall(_args)
409
- end
410
- )
411
- end
412
- )
413
- end
287
+ _keyword_QUMARK(
288
+ _car(
289
+ trampCall(_args)
290
+ )
291
+ )
414
292
  ) then
415
- begin
416
- if (
417
- begin
418
- _null_QUMARK(
419
- begin
420
- _cdr(
421
- begin
422
- trampCall(_args)
423
- end
424
- )
425
- end
426
- )
427
- end
428
- ) then
429
- begin
430
- begin
431
- delayCall( '_values', 'values',
432
- begin
433
- trampCall(@_values)
434
- end ,
293
+ if (
294
+ _null_QUMARK(
295
+ _cdr(
296
+ trampCall(_args)
297
+ )
298
+ )
299
+ ) then
300
+ delayCall( '_values', 'values',
301
+ trampCall(@_values) ,
302
+ [
303
+ _reverse(
304
+ trampCall( self._list_ASMARK_METHOD( 'list*',
305
+ trampCall(@_list_ASMARK) ,
306
+ [
307
+ _car(
308
+ trampCall(_args)
309
+ ) ,
310
+ " " ,
311
+ trampCall(_attrs)
312
+ ]
313
+ ))
314
+ ) ,
315
+ trampCall(_args)
316
+ ]
317
+ )
318
+ else
319
+ if (
320
+ _eq_QUMARK(
321
+ trampCall( self._cadr_METHOD( 'cadr',
322
+ trampCall(@_cadr) ,
435
323
  [
436
- begin
437
- _reverse(
438
- begin
439
- trampCall( self._list_ASMARK_METHOD( 'list*',
440
- begin
441
- trampCall(@_list_ASMARK)
442
- end ,
443
- [
444
- begin
445
- _car(
446
- begin
447
- trampCall(_args)
448
- end
449
- )
450
- end ,
451
- " " ,
452
- begin
453
- trampCall(_attrs)
454
- end
455
- ]
456
- ))
457
- end
458
- )
459
- end ,
460
- begin
461
- trampCall(_args)
462
- end
324
+ trampCall(_args)
463
325
  ]
464
- )
465
- end
466
- end
467
- else
468
- if (
469
- begin
470
- _eq_QUMARK(
471
- begin
472
- trampCall( self._cadr_METHOD( 'cadr',
473
- begin
474
- trampCall(@_cadr)
475
- end ,
326
+ )) ,
327
+ false
328
+ )
329
+ ) then
330
+ delayCall( '_get_MIMARKattr', 'get-attr',
331
+ trampCall(_get_MIMARKattr) ,
332
+ [
333
+ trampCall( self._cddr_METHOD( 'cddr',
334
+ trampCall(@_cddr) ,
476
335
  [
477
- begin
478
- trampCall(_args)
479
- end
336
+ trampCall(_args)
480
337
  ]
481
- ))
482
- end ,
483
- false
484
- )
485
- end
486
- ) then
487
- begin
488
- begin
489
- delayCall( '_get_MIMARKattr', 'get-attr',
490
- begin
491
- trampCall(_get_MIMARKattr)
492
- end ,
338
+ )) ,
339
+ trampCall(_attrs)
340
+ ]
341
+ )
342
+ else
343
+ if (
344
+ _eq_QUMARK(
345
+ trampCall( self._cadr_METHOD( 'cadr',
346
+ trampCall(@_cadr) ,
493
347
  [
494
- begin
495
- trampCall( self._cddr_METHOD( 'cddr',
496
- begin
497
- trampCall(@_cddr)
498
- end ,
499
- [
500
- begin
501
- trampCall(_args)
502
- end
503
- ]
504
- ))
505
- end ,
506
- begin
507
- trampCall(_attrs)
508
- end
348
+ trampCall(_args)
509
349
  ]
510
- )
511
- end
512
- end
513
- else
514
- if (
515
- begin
516
- _eq_QUMARK(
517
- begin
518
- trampCall( self._cadr_METHOD( 'cadr',
519
- begin
520
- trampCall(@_cadr)
521
- end ,
350
+ )) ,
351
+ true
352
+ )
353
+ ) then
354
+ delayCall( '_get_MIMARKattr', 'get-attr',
355
+ trampCall(_get_MIMARKattr) ,
356
+ [
357
+ trampCall( self._cddr_METHOD( 'cddr',
358
+ trampCall(@_cddr) ,
522
359
  [
523
- begin
524
- trampCall(_args)
525
- end
360
+ trampCall(_args)
361
+ ]
362
+ )) ,
363
+ trampCall( self._list_ASMARK_METHOD( 'list*',
364
+ trampCall(@_list_ASMARK) ,
365
+ [
366
+ _car(
367
+ trampCall(_args)
368
+ ) ,
369
+ " " ,
370
+ trampCall(_attrs)
526
371
  ]
527
372
  ))
528
- end ,
529
- true
530
- )
531
- end
532
- ) then
533
- begin
534
- begin
535
- delayCall( '_get_MIMARKattr', 'get-attr',
536
- begin
537
- trampCall(_get_MIMARKattr)
538
- end ,
539
- [
540
- begin
541
- trampCall( self._cddr_METHOD( 'cddr',
542
- begin
543
- trampCall(@_cddr)
544
- end ,
545
- [
546
- begin
547
- trampCall(_args)
548
- end
549
- ]
550
- ))
551
- end ,
552
- begin
553
- trampCall( self._list_ASMARK_METHOD( 'list*',
554
- begin
555
- trampCall(@_list_ASMARK)
556
- end ,
557
- [
558
- begin
559
- _car(
560
- begin
561
- trampCall(_args)
562
- end
563
- )
564
- end ,
565
- " " ,
566
- begin
567
- trampCall(_attrs)
568
- end
569
- ]
570
- ))
571
- end
572
- ]
573
- )
574
- end
575
- end
576
- else
577
- if (
578
- true
579
- ) then
580
- begin
581
- begin
582
- delayCall( '_get_MIMARKattr', 'get-attr',
583
- begin
584
- trampCall(_get_MIMARKattr)
585
- end ,
586
- [
587
- begin
588
- trampCall( self._cddr_METHOD( 'cddr',
589
- begin
590
- trampCall(@_cddr)
591
- end ,
592
- [
593
- begin
594
- trampCall(_args)
595
- end
596
- ]
597
- ))
598
- end ,
599
- begin
600
- trampCall( self._list_ASMARK_METHOD( 'list*',
601
- begin
602
- trampCall(@_list_ASMARK)
603
- end ,
373
+ ]
374
+ )
375
+ else
376
+ if (
377
+ true
378
+ ) then
379
+ delayCall( '_get_MIMARKattr', 'get-attr',
380
+ trampCall(_get_MIMARKattr) ,
381
+ [
382
+ trampCall( self._cddr_METHOD( 'cddr',
383
+ trampCall(@_cddr) ,
384
+ [
385
+ trampCall(_args)
386
+ ]
387
+ )) ,
388
+ trampCall( self._list_ASMARK_METHOD( 'list*',
389
+ trampCall(@_list_ASMARK) ,
390
+ [
391
+ trampCall( self._sprintf_METHOD( 'sprintf',
392
+ trampCall(@_sprintf) ,
604
393
  [
605
- begin
606
- trampCall( self._sprintf_METHOD( 'sprintf',
607
- begin
608
- trampCall(@_sprintf)
609
- end ,
610
- [
611
- "=\"%s\"" ,
612
- begin
613
- trampCall( self._html_MIMARKescape_MIMARKstring_METHOD( 'html-escape-string',
614
- begin
615
- trampCall(@_html_MIMARKescape_MIMARKstring)
616
- end ,
617
- [
618
- begin
619
- trampCall( self._x_MIMARK_GTMARKstring_METHOD( 'x->string',
620
- begin
621
- trampCall(@_x_MIMARK_GTMARKstring)
622
- end ,
623
- [
624
- begin
625
- trampCall( self._cadr_METHOD( 'cadr',
626
- begin
627
- trampCall(@_cadr)
628
- end ,
629
- [
630
- begin
631
- trampCall(_args)
632
- end
633
- ]
634
- ))
635
- end
636
- ]
637
- ))
638
- end
639
- ]
640
- ))
641
- end
642
- ]
643
- ))
644
- end ,
645
- begin
646
- _car(
647
- begin
648
- trampCall(_args)
649
- end
650
- )
651
- end ,
652
- " " ,
653
- begin
654
- trampCall(_attrs)
655
- end
394
+ "=\"%s\"" ,
395
+ trampCall( self._html_MIMARKescape_MIMARKstring_METHOD( 'html-escape-string',
396
+ trampCall(@_html_MIMARKescape_MIMARKstring) ,
397
+ [
398
+ trampCall( self._x_MIMARK_GTMARKstring_METHOD( 'x->string',
399
+ trampCall(@_x_MIMARK_GTMARKstring) ,
400
+ [
401
+ trampCall( self._cadr_METHOD( 'cadr',
402
+ trampCall(@_cadr) ,
403
+ [
404
+ trampCall(_args)
405
+ ]
406
+ ))
407
+ ]
408
+ ))
409
+ ]
410
+ ))
656
411
  ]
657
- ))
658
- end
659
- ]
660
- )
661
- end
662
- end
663
- else
664
- Cell.new()
665
- end
666
- end
667
- end
668
- end
669
- end
412
+ )) ,
413
+ _car(
414
+ trampCall(_args)
415
+ ) ,
416
+ " " ,
417
+ trampCall(_attrs)
418
+ ]
419
+ ))
420
+ ]
421
+ )
422
+ else
423
+ Cell.new()
424
+ end
425
+ end
426
+ end
427
+ end
670
428
  else
671
429
  if (
672
430
  true
673
431
  ) then
674
- begin
675
- begin
676
- delayCall( '_values', 'values',
677
- begin
678
- trampCall(@_values)
679
- end ,
680
- [
681
- begin
682
- _reverse(
683
- begin
684
- trampCall(_attrs)
685
- end
686
- )
687
- end ,
688
- begin
689
- trampCall(_args)
690
- end
691
- ]
692
- )
693
- end
694
- end
432
+ delayCall( '_values', 'values',
433
+ trampCall(@_values) ,
434
+ [
435
+ _reverse(
436
+ trampCall(_attrs)
437
+ ) ,
438
+ trampCall(_args)
439
+ ]
440
+ )
695
441
  else
696
442
  Cell.new()
697
443
  end
698
444
  end
699
445
  end
700
446
  }
701
- begin
447
+ begin #makeLet
702
448
  ___lambda = lambda { |_empty_QUMARK|
703
449
  if (
704
- begin
705
- trampCall(_empty_QUMARK)
706
- end
450
+ trampCall(_empty_QUMARK)
707
451
  ) then
708
452
  Proc.new { |*__rest__| _args = __rest__[0] ;
709
- begin
710
- delayCall( '_call_MIMARKwith_MIMARKvalues', 'call-with-values',
711
- begin
712
- trampCall(@_call_MIMARKwith_MIMARKvalues)
713
- end ,
714
- [
715
- Proc.new { ||
716
- begin
717
- trampCall( callProcedure( '_get_MIMARKattr', 'get-attr',
718
- begin
719
- trampCall(_get_MIMARKattr)
720
- end ,
721
- [
722
- begin
723
- trampCall(_args)
724
- end ,
725
- Cell.new()
726
- ]
727
- ))
728
- end
729
- } ,
730
- Proc.new { |_attr,_args|
731
- if (
732
- begin
733
- _not(
734
- begin
735
- _null_QUMARK(
736
- begin
737
- trampCall(_args)
738
- end
739
- )
740
- end
741
- )
742
- end
743
- ) then
744
- begin
745
- begin raise RuntimeError,
746
- begin
747
- trampCall( self._sprintf_METHOD( 'sprintf',
748
- begin
749
- trampCall(@_sprintf)
750
- end ,
751
- [
752
- "element %s can't have content: %s" ,
753
- begin
754
- trampCall(_name)
755
- end ,
756
- begin
757
- _write_MIMARKto_MIMARKstring(
758
- begin
759
- trampCall(_args)
760
- end
761
- )
762
- end
763
- ]
764
- ))
765
- end
766
- rescue => __e
767
- __e.set_backtrace( [":1"] + __e.backtrace )
768
- raise __e
769
- end
770
- end
771
- end
772
- begin
773
- trampCall( self._list_METHOD( 'list',
774
- begin
775
- trampCall(@_list)
776
- end ,
777
- [
778
- "<" ,
779
- begin
780
- trampCall(_name)
781
- end ,
782
- begin
783
- trampCall(_attr)
784
- end ,
785
- " />"
786
- ]
787
- ))
788
- end
789
- }
790
- ]
791
- )
792
- end
453
+ delayCall( '_call_MIMARKwith_MIMARKvalues', 'call-with-values',
454
+ trampCall(@_call_MIMARKwith_MIMARKvalues) ,
455
+ [
456
+ Proc.new { ||
457
+ trampCall( callProcedure( '_get_MIMARKattr', 'get-attr',
458
+ trampCall(_get_MIMARKattr) ,
459
+ [
460
+ trampCall(_args) ,
461
+ Cell.new()
462
+ ]
463
+ ))
464
+ } ,
465
+ Proc.new { |_attr,_args|
466
+ if (
467
+ _not(
468
+ _null_QUMARK(
469
+ trampCall(_args)
470
+ )
471
+ )
472
+ ) then
473
+ begin raise RuntimeError,
474
+ trampCall( self._sprintf_METHOD( 'sprintf',
475
+ trampCall(@_sprintf) ,
476
+ [
477
+ "element %s can't have content: %s" ,
478
+ trampCall(_name) ,
479
+ _write_MIMARKto_MIMARKstring(
480
+ trampCall(_args)
481
+ )
482
+ ]
483
+ ))
484
+ rescue => __e
485
+ __e.set_backtrace( [":1"] + __e.backtrace )
486
+ raise __e
487
+ end
488
+ end
489
+ trampCall( self._list_METHOD( 'list',
490
+ trampCall(@_list) ,
491
+ [
492
+ "<" ,
493
+ trampCall(_name) ,
494
+ trampCall(_attr) ,
495
+ " />"
496
+ ]
497
+ ))
498
+ }
499
+ ]
500
+ )
793
501
  }
794
502
  else
795
503
  Proc.new { |*__rest__| _args = __rest__[0] ;
796
- begin
797
- delayCall( '_call_MIMARKwith_MIMARKvalues', 'call-with-values',
798
- begin
799
- trampCall(@_call_MIMARKwith_MIMARKvalues)
800
- end ,
801
- [
802
- Proc.new { ||
803
- begin
804
- trampCall( callProcedure( '_get_MIMARKattr', 'get-attr',
805
- begin
806
- trampCall(_get_MIMARKattr)
807
- end ,
808
- [
809
- begin
810
- trampCall(_args)
811
- end ,
812
- Cell.new()
813
- ]
814
- ))
815
- end
816
- } ,
817
- Proc.new { |_attr,_args|
818
- begin
819
- trampCall( self._list_METHOD( 'list',
820
- begin
821
- trampCall(@_list)
822
- end ,
823
- [
824
- "<" ,
825
- begin
826
- trampCall(_name)
827
- end ,
828
- begin
829
- trampCall(_attr)
830
- end ,
831
- ">" ,
832
- begin
833
- trampCall(_args)
834
- end ,
835
- "</" ,
836
- begin
837
- trampCall(_name)
838
- end ,
839
- "
504
+ delayCall( '_call_MIMARKwith_MIMARKvalues', 'call-with-values',
505
+ trampCall(@_call_MIMARKwith_MIMARKvalues) ,
506
+ [
507
+ Proc.new { ||
508
+ trampCall( callProcedure( '_get_MIMARKattr', 'get-attr',
509
+ trampCall(_get_MIMARKattr) ,
510
+ [
511
+ trampCall(_args) ,
512
+ Cell.new()
513
+ ]
514
+ ))
515
+ } ,
516
+ Proc.new { |_attr,_args|
517
+ trampCall( self._list_METHOD( 'list',
518
+ trampCall(@_list) ,
519
+ [
520
+ "<" ,
521
+ trampCall(_name) ,
522
+ trampCall(_attr) ,
523
+ ">" ,
524
+ trampCall(_args) ,
525
+ "</" ,
526
+ trampCall(_name) ,
527
+ "
840
528
  >"
841
- ]
842
- ))
843
- end
844
- }
845
- ]
846
- )
847
- end
529
+ ]
530
+ ))
531
+ }
532
+ ]
533
+ )
848
534
  }
849
535
  end
850
536
  } ; ___lambda.call(
851
- begin
852
- trampCall( self._get_MIMARKkeyword_METHOD( 'get-keyword',
853
- begin
854
- trampCall(@_get_MIMARKkeyword)
855
- end ,
856
- [
857
- LispKeyword.new( "empty?" ) ,
858
- begin
859
- trampCall(_args)
860
- end ,
861
- false
862
- ]
863
- ))
864
- end
537
+ trampCall( self._get_MIMARKkeyword_METHOD( 'get-keyword',
538
+ trampCall(@_get_MIMARKkeyword) ,
539
+ [
540
+ LispKeyword.new( "empty?" ) ,
541
+ trampCall(_args) ,
542
+ false
543
+ ]
544
+ ))
865
545
  )
866
546
  end
867
547
  } ; ___lambda.call(
@@ -875,375 +555,215 @@ trampCall(
875
555
  #--------------------
876
556
 
877
557
  trampCall(
878
- begin
558
+ begin #execFunc
879
559
  def self._define_MIMARKhtml_MIMARKelements_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_define_MIMARKhtml_MIMARKelements', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
880
560
  @global_lisp_binding['_define_MIMARKhtml_MIMARKelements'] = self.method( :_define_MIMARKhtml_MIMARKelements_METHOD )
881
561
  @_define_MIMARKhtml_MIMARKelements =
882
562
  trampCall(
883
563
  LispMacro.new { |*__rest__| _elements = __rest__[0] ;
884
- begin
564
+ begin #makeLetrec
885
565
  ___lambda = lambda { |_make_MIMARKscheme_MIMARKname|
886
566
  _make_MIMARKscheme_MIMARKname =
887
567
  Proc.new { |_name|
888
- begin
889
- _string_MIMARK_GTMARKsymbol(
890
- begin
891
- trampCall( self._sprintf_METHOD( 'sprintf',
892
- begin
893
- trampCall(@_sprintf)
894
- end ,
895
- [
896
- "html:%s" ,
897
- begin
898
- trampCall(_name)
899
- end
900
- ]
901
- ))
902
- end
903
- )
904
- end
568
+ _string_MIMARK_GTMARKsymbol(
569
+ trampCall( self._sprintf_METHOD( 'sprintf',
570
+ trampCall(@_sprintf) ,
571
+ [
572
+ "html:%s" ,
573
+ trampCall(_name)
574
+ ]
575
+ ))
576
+ )
905
577
  }
906
- begin
578
+ begin #makeLetrec
907
579
  ___lambda = lambda { |_loop|
908
580
  _loop =
909
581
  Proc.new { |_elements,_r|
910
582
  if (
911
- begin
912
- _null_QUMARK(
913
- begin
914
- trampCall(_elements)
915
- end
916
- )
917
- end
583
+ _null_QUMARK(
584
+ trampCall(_elements)
585
+ )
918
586
  ) then
919
- begin
920
- begin
921
- _cons(
922
- :"begin" ,
923
- begin
924
- _reverse(
925
- begin
926
- trampCall(_r)
927
- end
928
- )
929
- end
930
- )
931
- end
932
- end
587
+ _cons(
588
+ :"begin" ,
589
+ _reverse(
590
+ trampCall(_r)
591
+ )
592
+ )
933
593
  else
934
594
  if (
935
595
  if (
936
- begin
937
- _not(
938
- begin
939
- _eq_QUMARK(
940
- false ,
941
- begin
942
- _pair_QUMARK(
943
- begin
944
- _cdr(
945
- begin
946
- trampCall(_elements)
947
- end
948
- )
949
- end
596
+ _not(
597
+ _eq_QUMARK(
598
+ false ,
599
+ _pair_QUMARK(
600
+ _cdr(
601
+ trampCall(_elements)
950
602
  )
951
- end
952
- )
953
- end
954
- )
955
- end
603
+ )
604
+ )
605
+ )
956
606
  ) then
957
- begin
958
- trampCall( self._eqv_QUMARK_METHOD( 'eqv?',
959
- begin
960
- trampCall(@_eqv_QUMARK)
961
- end ,
962
- [
963
- begin
964
- trampCall( self._cadr_METHOD( 'cadr',
965
- begin
966
- trampCall(@_cadr)
967
- end ,
968
- [
969
- begin
970
- trampCall(_elements)
971
- end
972
- ]
973
- ))
974
- end ,
975
- LispKeyword.new( "empty" )
976
- ]
977
- ))
978
- end
607
+ trampCall( self._eqv_QUMARK_METHOD( 'eqv?',
608
+ trampCall(@_eqv_QUMARK) ,
609
+ [
610
+ trampCall( self._cadr_METHOD( 'cadr',
611
+ trampCall(@_cadr) ,
612
+ [
613
+ trampCall(_elements)
614
+ ]
615
+ )) ,
616
+ LispKeyword.new( "empty" )
617
+ ]
618
+ ))
979
619
  else
980
620
  false
981
621
  end
982
622
  ) then
983
- begin
984
- begin
985
- trampCall( callProcedure( '_loop', 'loop',
986
- begin
987
- trampCall(_loop)
988
- end ,
989
- [
990
- begin
991
- trampCall( self._cddr_METHOD( 'cddr',
992
- begin
993
- trampCall(@_cddr)
994
- end ,
995
- [
996
- begin
997
- trampCall(_elements)
998
- end
999
- ]
1000
- ))
1001
- end ,
1002
- begin
1003
- trampCall( self._list_ASMARK_METHOD( 'list*',
1004
- begin
1005
- trampCall(@_list_ASMARK)
1006
- end ,
1007
- [
1008
- begin
1009
- _cons(
1010
- :"define" ,
1011
- begin
1012
- _cons(
1013
- begin
1014
- trampCall( callProcedure( '_make_MIMARKscheme_MIMARKname', 'make-scheme-name',
1015
- begin
1016
- trampCall(_make_MIMARKscheme_MIMARKname)
1017
- end ,
1018
- [
1019
- begin
1020
- _car(
1021
- begin
1022
- trampCall(_elements)
1023
- end
1024
- )
1025
- end
1026
- ]
1027
- ))
1028
- end ,
1029
- begin
1030
- _cons(
1031
- begin
1032
- _cons(
1033
- :"make-html-element" ,
1034
- begin
1035
- _cons(
1036
- begin
1037
- _cons(
1038
- :"quote" ,
1039
- begin
1040
- _cons(
1041
- begin
1042
- _car(
1043
- begin
1044
- trampCall(_elements)
1045
- end
1046
- )
1047
- end ,
1048
- Cell.new()
1049
- )
1050
- end
1051
- )
1052
- end ,
1053
- begin
1054
- _cons(
1055
- LispKeyword.new( "empty?" ) ,
1056
- begin
1057
- _cons(
1058
- true ,
1059
- Cell.new()
1060
- )
1061
- end
1062
- )
1063
- end
1064
- )
1065
- end
1066
- )
1067
- end ,
1068
- Cell.new()
1069
- )
1070
- end
1071
- )
1072
- end
1073
- )
1074
- end ,
1075
- begin
1076
- _cons(
1077
- :"export" ,
1078
- begin
1079
- _cons(
1080
- begin
1081
- trampCall( callProcedure( '_make_MIMARKscheme_MIMARKname', 'make-scheme-name',
1082
- begin
1083
- trampCall(_make_MIMARKscheme_MIMARKname)
1084
- end ,
1085
- [
1086
- begin
1087
- _car(
1088
- begin
1089
- trampCall(_elements)
1090
- end
1091
- )
1092
- end
1093
- ]
1094
- ))
1095
- end ,
1096
- Cell.new()
1097
- )
1098
- end
1099
- )
1100
- end ,
1101
- begin
1102
- trampCall(_r)
1103
- end
1104
- ]
1105
- ))
1106
- end
1107
- ]
1108
- ))
1109
- end
1110
- end
1111
- else
1112
- if (
1113
- true
1114
- ) then
1115
- begin
1116
- begin
1117
- trampCall( callProcedure( '_loop', 'loop',
1118
- begin
1119
- trampCall(_loop)
1120
- end ,
623
+ trampCall( callProcedure( '_loop', 'loop',
624
+ trampCall(_loop) ,
625
+ [
626
+ trampCall( self._cddr_METHOD( 'cddr',
627
+ trampCall(@_cddr) ,
1121
628
  [
1122
- begin
1123
- _cdr(
1124
- begin
1125
- trampCall(_elements)
1126
- end
1127
- )
1128
- end ,
1129
- begin
1130
- trampCall( self._list_ASMARK_METHOD( 'list*',
1131
- begin
1132
- trampCall(@_list_ASMARK)
1133
- end ,
1134
- [
1135
- begin
629
+ trampCall(_elements)
630
+ ]
631
+ )) ,
632
+ trampCall( self._list_ASMARK_METHOD( 'list*',
633
+ trampCall(@_list_ASMARK) ,
634
+ [
635
+ _cons(
636
+ :"define" ,
637
+ _cons(
638
+ trampCall( callProcedure( '_make_MIMARKscheme_MIMARKname', 'make-scheme-name',
639
+ trampCall(_make_MIMARKscheme_MIMARKname) ,
640
+ [
641
+ _car(
642
+ trampCall(_elements)
643
+ )
644
+ ]
645
+ )) ,
1136
646
  _cons(
1137
- :"define" ,
1138
- begin
1139
- _cons(
1140
- begin
1141
- trampCall( callProcedure( '_make_MIMARKscheme_MIMARKname', 'make-scheme-name',
1142
- begin
1143
- trampCall(_make_MIMARKscheme_MIMARKname)
1144
- end ,
1145
- [
1146
- begin
1147
- _car(
1148
- begin
647
+ _cons(
648
+ :"make-html-element" ,
649
+ _cons(
650
+ _cons(
651
+ :"quote" ,
652
+ _cons(
653
+ _car(
1149
654
  trampCall(_elements)
1150
- end
1151
- )
1152
- end
1153
- ]
1154
- ))
1155
- end ,
1156
- begin
1157
- _cons(
1158
- begin
655
+ ) ,
656
+ Cell.new()
657
+ )
658
+ ) ,
659
+ _cons(
660
+ LispKeyword.new( "empty?" ) ,
1159
661
  _cons(
1160
- :"make-html-element" ,
1161
- begin
1162
- _cons(
1163
- begin
1164
- _cons(
1165
- :"quote" ,
1166
- begin
1167
- _cons(
1168
- begin
1169
- _car(
1170
- begin
1171
- trampCall(_elements)
1172
- end
1173
- )
1174
- end ,
1175
- Cell.new()
1176
- )
1177
- end
1178
- )
1179
- end ,
1180
- Cell.new()
1181
- )
1182
- end
662
+ true ,
663
+ Cell.new()
1183
664
  )
1184
- end ,
1185
- Cell.new()
1186
- )
1187
- end
1188
- )
1189
- end
665
+ )
666
+ )
667
+ ) ,
668
+ Cell.new()
1190
669
  )
1191
- end ,
1192
- begin
1193
- _cons(
1194
- :"export" ,
1195
- begin
1196
- _cons(
1197
- begin
1198
- trampCall( callProcedure( '_make_MIMARKscheme_MIMARKname', 'make-scheme-name',
1199
- begin
1200
- trampCall(_make_MIMARKscheme_MIMARKname)
1201
- end ,
1202
- [
1203
- begin
1204
- _car(
1205
- begin
1206
- trampCall(_elements)
1207
- end
1208
- )
1209
- end
1210
- ]
1211
- ))
1212
- end ,
1213
- Cell.new()
670
+ )
671
+ ) ,
672
+ _cons(
673
+ :"export" ,
674
+ _cons(
675
+ trampCall( callProcedure( '_make_MIMARKscheme_MIMARKname', 'make-scheme-name',
676
+ trampCall(_make_MIMARKscheme_MIMARKname) ,
677
+ [
678
+ _car(
679
+ trampCall(_elements)
1214
680
  )
1215
- end
1216
- )
1217
- end ,
1218
- begin
1219
- trampCall(_r)
1220
- end
1221
- ]
1222
- ))
1223
- end
681
+ ]
682
+ )) ,
683
+ Cell.new()
684
+ )
685
+ ) ,
686
+ trampCall(_r)
1224
687
  ]
1225
688
  ))
1226
- end
1227
- end
689
+ ]
690
+ ))
691
+ else
692
+ if (
693
+ true
694
+ ) then
695
+ trampCall( callProcedure( '_loop', 'loop',
696
+ trampCall(_loop) ,
697
+ [
698
+ _cdr(
699
+ trampCall(_elements)
700
+ ) ,
701
+ trampCall( self._list_ASMARK_METHOD( 'list*',
702
+ trampCall(@_list_ASMARK) ,
703
+ [
704
+ _cons(
705
+ :"define" ,
706
+ _cons(
707
+ trampCall( callProcedure( '_make_MIMARKscheme_MIMARKname', 'make-scheme-name',
708
+ trampCall(_make_MIMARKscheme_MIMARKname) ,
709
+ [
710
+ _car(
711
+ trampCall(_elements)
712
+ )
713
+ ]
714
+ )) ,
715
+ _cons(
716
+ _cons(
717
+ :"make-html-element" ,
718
+ _cons(
719
+ _cons(
720
+ :"quote" ,
721
+ _cons(
722
+ _car(
723
+ trampCall(_elements)
724
+ ) ,
725
+ Cell.new()
726
+ )
727
+ ) ,
728
+ Cell.new()
729
+ )
730
+ ) ,
731
+ Cell.new()
732
+ )
733
+ )
734
+ ) ,
735
+ _cons(
736
+ :"export" ,
737
+ _cons(
738
+ trampCall( callProcedure( '_make_MIMARKscheme_MIMARKname', 'make-scheme-name',
739
+ trampCall(_make_MIMARKscheme_MIMARKname) ,
740
+ [
741
+ _car(
742
+ trampCall(_elements)
743
+ )
744
+ ]
745
+ )) ,
746
+ Cell.new()
747
+ )
748
+ ) ,
749
+ trampCall(_r)
750
+ ]
751
+ ))
752
+ ]
753
+ ))
1228
754
  else
1229
755
  Cell.new()
1230
756
  end
1231
757
  end
1232
758
  end
1233
759
  }
1234
- begin
1235
- trampCall( callProcedure( '_loop', 'loop',
1236
- begin
1237
- trampCall(_loop)
1238
- end ,
1239
- [
1240
- begin
1241
- trampCall(_elements)
1242
- end ,
1243
- Cell.new()
1244
- ]
1245
- ))
1246
- end
760
+ trampCall( callProcedure( '_loop', 'loop',
761
+ trampCall(_loop) ,
762
+ [
763
+ trampCall(_elements) ,
764
+ Cell.new()
765
+ ]
766
+ ))
1247
767
  } ; ___lambda.call(
1248
768
  nil
1249
769
  )
@@ -1259,8 +779,8 @@ trampCall(
1259
779
  #--------------------
1260
780
 
1261
781
  trampCall(
1262
- begin
1263
- begin
782
+ begin #makeBegin
783
+ begin #execFunc
1264
784
  def self._html_COMARKtt_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtt', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1265
785
  @global_lisp_binding['_html_COMARKtt'] = self.method( :_html_COMARKtt_METHOD )
1266
786
  @_html_COMARKtt =
@@ -1268,24 +788,20 @@ trampCall(
1268
788
  nil
1269
789
  )
1270
790
  end
1271
- begin
791
+ begin #execFunc
1272
792
  def self._html_COMARKtt_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtt', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1273
793
  @global_lisp_binding['_html_COMARKtt'] = self.method( :_html_COMARKtt_METHOD )
1274
794
  @_html_COMARKtt =
1275
795
  trampCall(
1276
- begin
1277
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1278
- begin
1279
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1280
- end ,
1281
- [
1282
- :"tt"
1283
- ]
1284
- ))
1285
- end
796
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
797
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
798
+ [
799
+ :"tt"
800
+ ]
801
+ ))
1286
802
  )
1287
803
  end
1288
- begin
804
+ begin #execFunc
1289
805
  def self._html_COMARKi_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKi', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1290
806
  @global_lisp_binding['_html_COMARKi'] = self.method( :_html_COMARKi_METHOD )
1291
807
  @_html_COMARKi =
@@ -1293,24 +809,20 @@ trampCall(
1293
809
  nil
1294
810
  )
1295
811
  end
1296
- begin
812
+ begin #execFunc
1297
813
  def self._html_COMARKi_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKi', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1298
814
  @global_lisp_binding['_html_COMARKi'] = self.method( :_html_COMARKi_METHOD )
1299
815
  @_html_COMARKi =
1300
816
  trampCall(
1301
- begin
1302
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1303
- begin
1304
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1305
- end ,
1306
- [
1307
- :"i"
1308
- ]
1309
- ))
1310
- end
817
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
818
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
819
+ [
820
+ :"i"
821
+ ]
822
+ ))
1311
823
  )
1312
824
  end
1313
- begin
825
+ begin #execFunc
1314
826
  def self._html_COMARKb_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKb', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1315
827
  @global_lisp_binding['_html_COMARKb'] = self.method( :_html_COMARKb_METHOD )
1316
828
  @_html_COMARKb =
@@ -1318,24 +830,20 @@ trampCall(
1318
830
  nil
1319
831
  )
1320
832
  end
1321
- begin
833
+ begin #execFunc
1322
834
  def self._html_COMARKb_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKb', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1323
835
  @global_lisp_binding['_html_COMARKb'] = self.method( :_html_COMARKb_METHOD )
1324
836
  @_html_COMARKb =
1325
837
  trampCall(
1326
- begin
1327
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1328
- begin
1329
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1330
- end ,
1331
- [
1332
- :"b"
1333
- ]
1334
- ))
1335
- end
838
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
839
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
840
+ [
841
+ :"b"
842
+ ]
843
+ ))
1336
844
  )
1337
845
  end
1338
- begin
846
+ begin #execFunc
1339
847
  def self._html_COMARKbig_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKbig', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1340
848
  @global_lisp_binding['_html_COMARKbig'] = self.method( :_html_COMARKbig_METHOD )
1341
849
  @_html_COMARKbig =
@@ -1343,24 +851,20 @@ trampCall(
1343
851
  nil
1344
852
  )
1345
853
  end
1346
- begin
854
+ begin #execFunc
1347
855
  def self._html_COMARKbig_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKbig', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1348
856
  @global_lisp_binding['_html_COMARKbig'] = self.method( :_html_COMARKbig_METHOD )
1349
857
  @_html_COMARKbig =
1350
858
  trampCall(
1351
- begin
1352
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1353
- begin
1354
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1355
- end ,
1356
- [
1357
- :"big"
1358
- ]
1359
- ))
1360
- end
859
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
860
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
861
+ [
862
+ :"big"
863
+ ]
864
+ ))
1361
865
  )
1362
866
  end
1363
- begin
867
+ begin #execFunc
1364
868
  def self._html_COMARKsmall_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKsmall', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1365
869
  @global_lisp_binding['_html_COMARKsmall'] = self.method( :_html_COMARKsmall_METHOD )
1366
870
  @_html_COMARKsmall =
@@ -1368,21 +872,17 @@ trampCall(
1368
872
  nil
1369
873
  )
1370
874
  end
1371
- begin
875
+ begin #execFunc
1372
876
  def self._html_COMARKsmall_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKsmall', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1373
877
  @global_lisp_binding['_html_COMARKsmall'] = self.method( :_html_COMARKsmall_METHOD )
1374
878
  @_html_COMARKsmall =
1375
879
  trampCall(
1376
- begin
1377
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1378
- begin
1379
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1380
- end ,
1381
- [
1382
- :"small"
1383
- ]
1384
- ))
1385
- end
880
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
881
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
882
+ [
883
+ :"small"
884
+ ]
885
+ ))
1386
886
  )
1387
887
  end
1388
888
  end
@@ -1390,8 +890,8 @@ trampCall(
1390
890
  #--------------------
1391
891
 
1392
892
  trampCall(
1393
- begin
1394
- begin
893
+ begin #makeBegin
894
+ begin #execFunc
1395
895
  def self._html_COMARKem_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKem', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1396
896
  @global_lisp_binding['_html_COMARKem'] = self.method( :_html_COMARKem_METHOD )
1397
897
  @_html_COMARKem =
@@ -1399,24 +899,20 @@ trampCall(
1399
899
  nil
1400
900
  )
1401
901
  end
1402
- begin
902
+ begin #execFunc
1403
903
  def self._html_COMARKem_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKem', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1404
904
  @global_lisp_binding['_html_COMARKem'] = self.method( :_html_COMARKem_METHOD )
1405
905
  @_html_COMARKem =
1406
906
  trampCall(
1407
- begin
1408
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1409
- begin
1410
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1411
- end ,
1412
- [
1413
- :"em"
1414
- ]
1415
- ))
1416
- end
907
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
908
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
909
+ [
910
+ :"em"
911
+ ]
912
+ ))
1417
913
  )
1418
914
  end
1419
- begin
915
+ begin #execFunc
1420
916
  def self._html_COMARKstrong_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKstrong', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1421
917
  @global_lisp_binding['_html_COMARKstrong'] = self.method( :_html_COMARKstrong_METHOD )
1422
918
  @_html_COMARKstrong =
@@ -1424,24 +920,20 @@ trampCall(
1424
920
  nil
1425
921
  )
1426
922
  end
1427
- begin
923
+ begin #execFunc
1428
924
  def self._html_COMARKstrong_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKstrong', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1429
925
  @global_lisp_binding['_html_COMARKstrong'] = self.method( :_html_COMARKstrong_METHOD )
1430
926
  @_html_COMARKstrong =
1431
927
  trampCall(
1432
- begin
1433
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1434
- begin
1435
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1436
- end ,
1437
- [
1438
- :"strong"
1439
- ]
1440
- ))
1441
- end
928
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
929
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
930
+ [
931
+ :"strong"
932
+ ]
933
+ ))
1442
934
  )
1443
935
  end
1444
- begin
936
+ begin #execFunc
1445
937
  def self._html_COMARKdfn_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKdfn', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1446
938
  @global_lisp_binding['_html_COMARKdfn'] = self.method( :_html_COMARKdfn_METHOD )
1447
939
  @_html_COMARKdfn =
@@ -1449,24 +941,20 @@ trampCall(
1449
941
  nil
1450
942
  )
1451
943
  end
1452
- begin
944
+ begin #execFunc
1453
945
  def self._html_COMARKdfn_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKdfn', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1454
946
  @global_lisp_binding['_html_COMARKdfn'] = self.method( :_html_COMARKdfn_METHOD )
1455
947
  @_html_COMARKdfn =
1456
948
  trampCall(
1457
- begin
1458
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1459
- begin
1460
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1461
- end ,
1462
- [
1463
- :"dfn"
1464
- ]
1465
- ))
1466
- end
949
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
950
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
951
+ [
952
+ :"dfn"
953
+ ]
954
+ ))
1467
955
  )
1468
956
  end
1469
- begin
957
+ begin #execFunc
1470
958
  def self._html_COMARKcode_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKcode', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1471
959
  @global_lisp_binding['_html_COMARKcode'] = self.method( :_html_COMARKcode_METHOD )
1472
960
  @_html_COMARKcode =
@@ -1474,24 +962,20 @@ trampCall(
1474
962
  nil
1475
963
  )
1476
964
  end
1477
- begin
965
+ begin #execFunc
1478
966
  def self._html_COMARKcode_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKcode', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1479
967
  @global_lisp_binding['_html_COMARKcode'] = self.method( :_html_COMARKcode_METHOD )
1480
968
  @_html_COMARKcode =
1481
969
  trampCall(
1482
- begin
1483
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1484
- begin
1485
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1486
- end ,
1487
- [
1488
- :"code"
1489
- ]
1490
- ))
1491
- end
970
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
971
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
972
+ [
973
+ :"code"
974
+ ]
975
+ ))
1492
976
  )
1493
977
  end
1494
- begin
978
+ begin #execFunc
1495
979
  def self._html_COMARKsamp_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKsamp', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1496
980
  @global_lisp_binding['_html_COMARKsamp'] = self.method( :_html_COMARKsamp_METHOD )
1497
981
  @_html_COMARKsamp =
@@ -1499,24 +983,20 @@ trampCall(
1499
983
  nil
1500
984
  )
1501
985
  end
1502
- begin
986
+ begin #execFunc
1503
987
  def self._html_COMARKsamp_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKsamp', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1504
988
  @global_lisp_binding['_html_COMARKsamp'] = self.method( :_html_COMARKsamp_METHOD )
1505
989
  @_html_COMARKsamp =
1506
990
  trampCall(
1507
- begin
1508
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1509
- begin
1510
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1511
- end ,
1512
- [
1513
- :"samp"
1514
- ]
1515
- ))
1516
- end
991
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
992
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
993
+ [
994
+ :"samp"
995
+ ]
996
+ ))
1517
997
  )
1518
998
  end
1519
- begin
999
+ begin #execFunc
1520
1000
  def self._html_COMARKkbd_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKkbd', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1521
1001
  @global_lisp_binding['_html_COMARKkbd'] = self.method( :_html_COMARKkbd_METHOD )
1522
1002
  @_html_COMARKkbd =
@@ -1524,24 +1004,20 @@ trampCall(
1524
1004
  nil
1525
1005
  )
1526
1006
  end
1527
- begin
1007
+ begin #execFunc
1528
1008
  def self._html_COMARKkbd_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKkbd', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1529
1009
  @global_lisp_binding['_html_COMARKkbd'] = self.method( :_html_COMARKkbd_METHOD )
1530
1010
  @_html_COMARKkbd =
1531
1011
  trampCall(
1532
- begin
1533
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1534
- begin
1535
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1536
- end ,
1537
- [
1538
- :"kbd"
1539
- ]
1540
- ))
1541
- end
1012
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1013
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1014
+ [
1015
+ :"kbd"
1016
+ ]
1017
+ ))
1542
1018
  )
1543
1019
  end
1544
- begin
1020
+ begin #execFunc
1545
1021
  def self._html_COMARKvar_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKvar', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1546
1022
  @global_lisp_binding['_html_COMARKvar'] = self.method( :_html_COMARKvar_METHOD )
1547
1023
  @_html_COMARKvar =
@@ -1549,24 +1025,20 @@ trampCall(
1549
1025
  nil
1550
1026
  )
1551
1027
  end
1552
- begin
1028
+ begin #execFunc
1553
1029
  def self._html_COMARKvar_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKvar', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1554
1030
  @global_lisp_binding['_html_COMARKvar'] = self.method( :_html_COMARKvar_METHOD )
1555
1031
  @_html_COMARKvar =
1556
1032
  trampCall(
1557
- begin
1558
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1559
- begin
1560
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1561
- end ,
1562
- [
1563
- :"var"
1564
- ]
1565
- ))
1566
- end
1033
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1034
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1035
+ [
1036
+ :"var"
1037
+ ]
1038
+ ))
1567
1039
  )
1568
1040
  end
1569
- begin
1041
+ begin #execFunc
1570
1042
  def self._html_COMARKcite_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKcite', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1571
1043
  @global_lisp_binding['_html_COMARKcite'] = self.method( :_html_COMARKcite_METHOD )
1572
1044
  @_html_COMARKcite =
@@ -1574,24 +1046,20 @@ trampCall(
1574
1046
  nil
1575
1047
  )
1576
1048
  end
1577
- begin
1049
+ begin #execFunc
1578
1050
  def self._html_COMARKcite_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKcite', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1579
1051
  @global_lisp_binding['_html_COMARKcite'] = self.method( :_html_COMARKcite_METHOD )
1580
1052
  @_html_COMARKcite =
1581
1053
  trampCall(
1582
- begin
1583
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1584
- begin
1585
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1586
- end ,
1587
- [
1588
- :"cite"
1589
- ]
1590
- ))
1591
- end
1054
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1055
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1056
+ [
1057
+ :"cite"
1058
+ ]
1059
+ ))
1592
1060
  )
1593
1061
  end
1594
- begin
1062
+ begin #execFunc
1595
1063
  def self._html_COMARKabbr_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKabbr', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1596
1064
  @global_lisp_binding['_html_COMARKabbr'] = self.method( :_html_COMARKabbr_METHOD )
1597
1065
  @_html_COMARKabbr =
@@ -1599,24 +1067,20 @@ trampCall(
1599
1067
  nil
1600
1068
  )
1601
1069
  end
1602
- begin
1070
+ begin #execFunc
1603
1071
  def self._html_COMARKabbr_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKabbr', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1604
1072
  @global_lisp_binding['_html_COMARKabbr'] = self.method( :_html_COMARKabbr_METHOD )
1605
1073
  @_html_COMARKabbr =
1606
1074
  trampCall(
1607
- begin
1608
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1609
- begin
1610
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1611
- end ,
1612
- [
1613
- :"abbr"
1614
- ]
1615
- ))
1616
- end
1075
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1076
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1077
+ [
1078
+ :"abbr"
1079
+ ]
1080
+ ))
1617
1081
  )
1618
1082
  end
1619
- begin
1083
+ begin #execFunc
1620
1084
  def self._html_COMARKacronym_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKacronym', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1621
1085
  @global_lisp_binding['_html_COMARKacronym'] = self.method( :_html_COMARKacronym_METHOD )
1622
1086
  @_html_COMARKacronym =
@@ -1624,21 +1088,17 @@ trampCall(
1624
1088
  nil
1625
1089
  )
1626
1090
  end
1627
- begin
1091
+ begin #execFunc
1628
1092
  def self._html_COMARKacronym_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKacronym', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1629
1093
  @global_lisp_binding['_html_COMARKacronym'] = self.method( :_html_COMARKacronym_METHOD )
1630
1094
  @_html_COMARKacronym =
1631
1095
  trampCall(
1632
- begin
1633
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1634
- begin
1635
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1636
- end ,
1637
- [
1638
- :"acronym"
1639
- ]
1640
- ))
1641
- end
1096
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1097
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1098
+ [
1099
+ :"acronym"
1100
+ ]
1101
+ ))
1642
1102
  )
1643
1103
  end
1644
1104
  end
@@ -1646,8 +1106,8 @@ trampCall(
1646
1106
  #--------------------
1647
1107
 
1648
1108
  trampCall(
1649
- begin
1650
- begin
1109
+ begin #makeBegin
1110
+ begin #execFunc
1651
1111
  def self._html_COMARKsub_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKsub', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1652
1112
  @global_lisp_binding['_html_COMARKsub'] = self.method( :_html_COMARKsub_METHOD )
1653
1113
  @_html_COMARKsub =
@@ -1655,24 +1115,20 @@ trampCall(
1655
1115
  nil
1656
1116
  )
1657
1117
  end
1658
- begin
1118
+ begin #execFunc
1659
1119
  def self._html_COMARKsub_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKsub', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1660
1120
  @global_lisp_binding['_html_COMARKsub'] = self.method( :_html_COMARKsub_METHOD )
1661
1121
  @_html_COMARKsub =
1662
1122
  trampCall(
1663
- begin
1664
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1665
- begin
1666
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1667
- end ,
1668
- [
1669
- :"sub"
1670
- ]
1671
- ))
1672
- end
1123
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1124
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1125
+ [
1126
+ :"sub"
1127
+ ]
1128
+ ))
1673
1129
  )
1674
1130
  end
1675
- begin
1131
+ begin #execFunc
1676
1132
  def self._html_COMARKsup_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKsup', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1677
1133
  @global_lisp_binding['_html_COMARKsup'] = self.method( :_html_COMARKsup_METHOD )
1678
1134
  @_html_COMARKsup =
@@ -1680,24 +1136,20 @@ trampCall(
1680
1136
  nil
1681
1137
  )
1682
1138
  end
1683
- begin
1139
+ begin #execFunc
1684
1140
  def self._html_COMARKsup_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKsup', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1685
1141
  @global_lisp_binding['_html_COMARKsup'] = self.method( :_html_COMARKsup_METHOD )
1686
1142
  @_html_COMARKsup =
1687
1143
  trampCall(
1688
- begin
1689
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1690
- begin
1691
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1692
- end ,
1693
- [
1694
- :"sup"
1695
- ]
1696
- ))
1697
- end
1144
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1145
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1146
+ [
1147
+ :"sup"
1148
+ ]
1149
+ ))
1698
1150
  )
1699
1151
  end
1700
- begin
1152
+ begin #execFunc
1701
1153
  def self._html_COMARKspan_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKspan', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1702
1154
  @global_lisp_binding['_html_COMARKspan'] = self.method( :_html_COMARKspan_METHOD )
1703
1155
  @_html_COMARKspan =
@@ -1705,24 +1157,20 @@ trampCall(
1705
1157
  nil
1706
1158
  )
1707
1159
  end
1708
- begin
1160
+ begin #execFunc
1709
1161
  def self._html_COMARKspan_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKspan', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1710
1162
  @global_lisp_binding['_html_COMARKspan'] = self.method( :_html_COMARKspan_METHOD )
1711
1163
  @_html_COMARKspan =
1712
1164
  trampCall(
1713
- begin
1714
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1715
- begin
1716
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1717
- end ,
1718
- [
1719
- :"span"
1720
- ]
1721
- ))
1722
- end
1165
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1166
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1167
+ [
1168
+ :"span"
1169
+ ]
1170
+ ))
1723
1171
  )
1724
1172
  end
1725
- begin
1173
+ begin #execFunc
1726
1174
  def self._html_COMARKbdo_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKbdo', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1727
1175
  @global_lisp_binding['_html_COMARKbdo'] = self.method( :_html_COMARKbdo_METHOD )
1728
1176
  @_html_COMARKbdo =
@@ -1730,24 +1178,20 @@ trampCall(
1730
1178
  nil
1731
1179
  )
1732
1180
  end
1733
- begin
1181
+ begin #execFunc
1734
1182
  def self._html_COMARKbdo_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKbdo', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1735
1183
  @global_lisp_binding['_html_COMARKbdo'] = self.method( :_html_COMARKbdo_METHOD )
1736
1184
  @_html_COMARKbdo =
1737
1185
  trampCall(
1738
- begin
1739
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1740
- begin
1741
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1742
- end ,
1743
- [
1744
- :"bdo"
1745
- ]
1746
- ))
1747
- end
1186
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1187
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1188
+ [
1189
+ :"bdo"
1190
+ ]
1191
+ ))
1748
1192
  )
1749
1193
  end
1750
- begin
1194
+ begin #execFunc
1751
1195
  def self._html_COMARKbr_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKbr', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1752
1196
  @global_lisp_binding['_html_COMARKbr'] = self.method( :_html_COMARKbr_METHOD )
1753
1197
  @_html_COMARKbr =
@@ -1755,23 +1199,19 @@ trampCall(
1755
1199
  nil
1756
1200
  )
1757
1201
  end
1758
- begin
1202
+ begin #execFunc
1759
1203
  def self._html_COMARKbr_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKbr', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1760
1204
  @global_lisp_binding['_html_COMARKbr'] = self.method( :_html_COMARKbr_METHOD )
1761
1205
  @_html_COMARKbr =
1762
1206
  trampCall(
1763
- begin
1764
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1765
- begin
1766
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1767
- end ,
1768
- [
1769
- :"br" ,
1770
- LispKeyword.new( "empty?" ) ,
1771
- true
1772
- ]
1773
- ))
1774
- end
1207
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1208
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1209
+ [
1210
+ :"br" ,
1211
+ LispKeyword.new( "empty?" ) ,
1212
+ true
1213
+ ]
1214
+ ))
1775
1215
  )
1776
1216
  end
1777
1217
  end
@@ -1779,8 +1219,8 @@ trampCall(
1779
1219
  #--------------------
1780
1220
 
1781
1221
  trampCall(
1782
- begin
1783
- begin
1222
+ begin #makeBegin
1223
+ begin #execFunc
1784
1224
  def self._html_COMARKbody_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKbody', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1785
1225
  @global_lisp_binding['_html_COMARKbody'] = self.method( :_html_COMARKbody_METHOD )
1786
1226
  @_html_COMARKbody =
@@ -1788,24 +1228,20 @@ trampCall(
1788
1228
  nil
1789
1229
  )
1790
1230
  end
1791
- begin
1231
+ begin #execFunc
1792
1232
  def self._html_COMARKbody_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKbody', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1793
1233
  @global_lisp_binding['_html_COMARKbody'] = self.method( :_html_COMARKbody_METHOD )
1794
1234
  @_html_COMARKbody =
1795
1235
  trampCall(
1796
- begin
1797
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1798
- begin
1799
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1800
- end ,
1801
- [
1802
- :"body"
1803
- ]
1804
- ))
1805
- end
1236
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1237
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1238
+ [
1239
+ :"body"
1240
+ ]
1241
+ ))
1806
1242
  )
1807
1243
  end
1808
- begin
1244
+ begin #execFunc
1809
1245
  def self._html_COMARKaddress_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKaddress', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1810
1246
  @global_lisp_binding['_html_COMARKaddress'] = self.method( :_html_COMARKaddress_METHOD )
1811
1247
  @_html_COMARKaddress =
@@ -1813,24 +1249,20 @@ trampCall(
1813
1249
  nil
1814
1250
  )
1815
1251
  end
1816
- begin
1252
+ begin #execFunc
1817
1253
  def self._html_COMARKaddress_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKaddress', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1818
1254
  @global_lisp_binding['_html_COMARKaddress'] = self.method( :_html_COMARKaddress_METHOD )
1819
1255
  @_html_COMARKaddress =
1820
1256
  trampCall(
1821
- begin
1822
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1823
- begin
1824
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1825
- end ,
1826
- [
1827
- :"address"
1828
- ]
1829
- ))
1830
- end
1257
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1258
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1259
+ [
1260
+ :"address"
1261
+ ]
1262
+ ))
1831
1263
  )
1832
1264
  end
1833
- begin
1265
+ begin #execFunc
1834
1266
  def self._html_COMARKdiv_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKdiv', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1835
1267
  @global_lisp_binding['_html_COMARKdiv'] = self.method( :_html_COMARKdiv_METHOD )
1836
1268
  @_html_COMARKdiv =
@@ -1838,21 +1270,17 @@ trampCall(
1838
1270
  nil
1839
1271
  )
1840
1272
  end
1841
- begin
1273
+ begin #execFunc
1842
1274
  def self._html_COMARKdiv_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKdiv', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1843
1275
  @global_lisp_binding['_html_COMARKdiv'] = self.method( :_html_COMARKdiv_METHOD )
1844
1276
  @_html_COMARKdiv =
1845
1277
  trampCall(
1846
- begin
1847
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1848
- begin
1849
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1850
- end ,
1851
- [
1852
- :"div"
1853
- ]
1854
- ))
1855
- end
1278
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1279
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1280
+ [
1281
+ :"div"
1282
+ ]
1283
+ ))
1856
1284
  )
1857
1285
  end
1858
1286
  end
@@ -1860,8 +1288,8 @@ trampCall(
1860
1288
  #--------------------
1861
1289
 
1862
1290
  trampCall(
1863
- begin
1864
- begin
1291
+ begin #makeBegin
1292
+ begin #execFunc
1865
1293
  def self._html_COMARKa_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKa', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1866
1294
  @global_lisp_binding['_html_COMARKa'] = self.method( :_html_COMARKa_METHOD )
1867
1295
  @_html_COMARKa =
@@ -1869,21 +1297,17 @@ trampCall(
1869
1297
  nil
1870
1298
  )
1871
1299
  end
1872
- begin
1300
+ begin #execFunc
1873
1301
  def self._html_COMARKa_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKa', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1874
1302
  @global_lisp_binding['_html_COMARKa'] = self.method( :_html_COMARKa_METHOD )
1875
1303
  @_html_COMARKa =
1876
1304
  trampCall(
1877
- begin
1878
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1879
- begin
1880
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1881
- end ,
1882
- [
1883
- :"a"
1884
- ]
1885
- ))
1886
- end
1305
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1306
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1307
+ [
1308
+ :"a"
1309
+ ]
1310
+ ))
1887
1311
  )
1888
1312
  end
1889
1313
  end
@@ -1891,8 +1315,8 @@ trampCall(
1891
1315
  #--------------------
1892
1316
 
1893
1317
  trampCall(
1894
- begin
1895
- begin
1318
+ begin #makeBegin
1319
+ begin #execFunc
1896
1320
  def self._html_COMARKmap_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKmap', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1897
1321
  @global_lisp_binding['_html_COMARKmap'] = self.method( :_html_COMARKmap_METHOD )
1898
1322
  @_html_COMARKmap =
@@ -1900,24 +1324,20 @@ trampCall(
1900
1324
  nil
1901
1325
  )
1902
1326
  end
1903
- begin
1327
+ begin #execFunc
1904
1328
  def self._html_COMARKmap_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKmap', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1905
1329
  @global_lisp_binding['_html_COMARKmap'] = self.method( :_html_COMARKmap_METHOD )
1906
1330
  @_html_COMARKmap =
1907
1331
  trampCall(
1908
- begin
1909
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1910
- begin
1911
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1912
- end ,
1913
- [
1914
- :"map"
1915
- ]
1916
- ))
1917
- end
1332
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1333
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1334
+ [
1335
+ :"map"
1336
+ ]
1337
+ ))
1918
1338
  )
1919
1339
  end
1920
- begin
1340
+ begin #execFunc
1921
1341
  def self._html_COMARKarea_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKarea', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1922
1342
  @global_lisp_binding['_html_COMARKarea'] = self.method( :_html_COMARKarea_METHOD )
1923
1343
  @_html_COMARKarea =
@@ -1925,23 +1345,19 @@ trampCall(
1925
1345
  nil
1926
1346
  )
1927
1347
  end
1928
- begin
1348
+ begin #execFunc
1929
1349
  def self._html_COMARKarea_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKarea', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1930
1350
  @global_lisp_binding['_html_COMARKarea'] = self.method( :_html_COMARKarea_METHOD )
1931
1351
  @_html_COMARKarea =
1932
1352
  trampCall(
1933
- begin
1934
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1935
- begin
1936
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1937
- end ,
1938
- [
1939
- :"area" ,
1940
- LispKeyword.new( "empty?" ) ,
1941
- true
1942
- ]
1943
- ))
1944
- end
1353
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1354
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1355
+ [
1356
+ :"area" ,
1357
+ LispKeyword.new( "empty?" ) ,
1358
+ true
1359
+ ]
1360
+ ))
1945
1361
  )
1946
1362
  end
1947
1363
  end
@@ -1949,8 +1365,8 @@ trampCall(
1949
1365
  #--------------------
1950
1366
 
1951
1367
  trampCall(
1952
- begin
1953
- begin
1368
+ begin #makeBegin
1369
+ begin #execFunc
1954
1370
  def self._html_COMARKlink_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKlink', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1955
1371
  @global_lisp_binding['_html_COMARKlink'] = self.method( :_html_COMARKlink_METHOD )
1956
1372
  @_html_COMARKlink =
@@ -1958,23 +1374,19 @@ trampCall(
1958
1374
  nil
1959
1375
  )
1960
1376
  end
1961
- begin
1377
+ begin #execFunc
1962
1378
  def self._html_COMARKlink_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKlink', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1963
1379
  @global_lisp_binding['_html_COMARKlink'] = self.method( :_html_COMARKlink_METHOD )
1964
1380
  @_html_COMARKlink =
1965
1381
  trampCall(
1966
- begin
1967
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1968
- begin
1969
- trampCall(@_make_MIMARKhtml_MIMARKelement)
1970
- end ,
1971
- [
1972
- :"link" ,
1973
- LispKeyword.new( "empty?" ) ,
1974
- true
1975
- ]
1976
- ))
1977
- end
1382
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1383
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1384
+ [
1385
+ :"link" ,
1386
+ LispKeyword.new( "empty?" ) ,
1387
+ true
1388
+ ]
1389
+ ))
1978
1390
  )
1979
1391
  end
1980
1392
  end
@@ -1982,8 +1394,8 @@ trampCall(
1982
1394
  #--------------------
1983
1395
 
1984
1396
  trampCall(
1985
- begin
1986
- begin
1397
+ begin #makeBegin
1398
+ begin #execFunc
1987
1399
  def self._html_COMARKimg_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKimg', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1988
1400
  @global_lisp_binding['_html_COMARKimg'] = self.method( :_html_COMARKimg_METHOD )
1989
1401
  @_html_COMARKimg =
@@ -1991,23 +1403,19 @@ trampCall(
1991
1403
  nil
1992
1404
  )
1993
1405
  end
1994
- begin
1406
+ begin #execFunc
1995
1407
  def self._html_COMARKimg_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKimg', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
1996
1408
  @global_lisp_binding['_html_COMARKimg'] = self.method( :_html_COMARKimg_METHOD )
1997
1409
  @_html_COMARKimg =
1998
1410
  trampCall(
1999
- begin
2000
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2001
- begin
2002
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2003
- end ,
2004
- [
2005
- :"img" ,
2006
- LispKeyword.new( "empty?" ) ,
2007
- true
2008
- ]
2009
- ))
2010
- end
1411
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1412
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1413
+ [
1414
+ :"img" ,
1415
+ LispKeyword.new( "empty?" ) ,
1416
+ true
1417
+ ]
1418
+ ))
2011
1419
  )
2012
1420
  end
2013
1421
  end
@@ -2015,8 +1423,8 @@ trampCall(
2015
1423
  #--------------------
2016
1424
 
2017
1425
  trampCall(
2018
- begin
2019
- begin
1426
+ begin #makeBegin
1427
+ begin #execFunc
2020
1428
  def self._html_COMARKobject_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKobject', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2021
1429
  @global_lisp_binding['_html_COMARKobject'] = self.method( :_html_COMARKobject_METHOD )
2022
1430
  @_html_COMARKobject =
@@ -2024,24 +1432,20 @@ trampCall(
2024
1432
  nil
2025
1433
  )
2026
1434
  end
2027
- begin
1435
+ begin #execFunc
2028
1436
  def self._html_COMARKobject_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKobject', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2029
1437
  @global_lisp_binding['_html_COMARKobject'] = self.method( :_html_COMARKobject_METHOD )
2030
1438
  @_html_COMARKobject =
2031
1439
  trampCall(
2032
- begin
2033
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2034
- begin
2035
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2036
- end ,
2037
- [
2038
- :"object"
2039
- ]
2040
- ))
2041
- end
1440
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1441
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1442
+ [
1443
+ :"object"
1444
+ ]
1445
+ ))
2042
1446
  )
2043
1447
  end
2044
- begin
1448
+ begin #execFunc
2045
1449
  def self._html_COMARKparam_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKparam', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2046
1450
  @global_lisp_binding['_html_COMARKparam'] = self.method( :_html_COMARKparam_METHOD )
2047
1451
  @_html_COMARKparam =
@@ -2049,23 +1453,19 @@ trampCall(
2049
1453
  nil
2050
1454
  )
2051
1455
  end
2052
- begin
1456
+ begin #execFunc
2053
1457
  def self._html_COMARKparam_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKparam', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2054
1458
  @global_lisp_binding['_html_COMARKparam'] = self.method( :_html_COMARKparam_METHOD )
2055
1459
  @_html_COMARKparam =
2056
1460
  trampCall(
2057
- begin
2058
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2059
- begin
2060
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2061
- end ,
2062
- [
2063
- :"param" ,
2064
- LispKeyword.new( "empty?" ) ,
2065
- true
2066
- ]
2067
- ))
2068
- end
1461
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1462
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1463
+ [
1464
+ :"param" ,
1465
+ LispKeyword.new( "empty?" ) ,
1466
+ true
1467
+ ]
1468
+ ))
2069
1469
  )
2070
1470
  end
2071
1471
  end
@@ -2073,8 +1473,8 @@ trampCall(
2073
1473
  #--------------------
2074
1474
 
2075
1475
  trampCall(
2076
- begin
2077
- begin
1476
+ begin #makeBegin
1477
+ begin #execFunc
2078
1478
  def self._html_COMARKhr_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKhr', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2079
1479
  @global_lisp_binding['_html_COMARKhr'] = self.method( :_html_COMARKhr_METHOD )
2080
1480
  @_html_COMARKhr =
@@ -2082,23 +1482,19 @@ trampCall(
2082
1482
  nil
2083
1483
  )
2084
1484
  end
2085
- begin
1485
+ begin #execFunc
2086
1486
  def self._html_COMARKhr_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKhr', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2087
1487
  @global_lisp_binding['_html_COMARKhr'] = self.method( :_html_COMARKhr_METHOD )
2088
1488
  @_html_COMARKhr =
2089
1489
  trampCall(
2090
- begin
2091
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2092
- begin
2093
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2094
- end ,
2095
- [
2096
- :"hr" ,
2097
- LispKeyword.new( "empty?" ) ,
2098
- true
2099
- ]
2100
- ))
2101
- end
1490
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1491
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1492
+ [
1493
+ :"hr" ,
1494
+ LispKeyword.new( "empty?" ) ,
1495
+ true
1496
+ ]
1497
+ ))
2102
1498
  )
2103
1499
  end
2104
1500
  end
@@ -2106,8 +1502,8 @@ trampCall(
2106
1502
  #--------------------
2107
1503
 
2108
1504
  trampCall(
2109
- begin
2110
- begin
1505
+ begin #makeBegin
1506
+ begin #execFunc
2111
1507
  def self._html_COMARKp_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKp', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2112
1508
  @global_lisp_binding['_html_COMARKp'] = self.method( :_html_COMARKp_METHOD )
2113
1509
  @_html_COMARKp =
@@ -2115,21 +1511,17 @@ trampCall(
2115
1511
  nil
2116
1512
  )
2117
1513
  end
2118
- begin
1514
+ begin #execFunc
2119
1515
  def self._html_COMARKp_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKp', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2120
1516
  @global_lisp_binding['_html_COMARKp'] = self.method( :_html_COMARKp_METHOD )
2121
1517
  @_html_COMARKp =
2122
1518
  trampCall(
2123
- begin
2124
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2125
- begin
2126
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2127
- end ,
2128
- [
2129
- :"p"
2130
- ]
2131
- ))
2132
- end
1519
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1520
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1521
+ [
1522
+ :"p"
1523
+ ]
1524
+ ))
2133
1525
  )
2134
1526
  end
2135
1527
  end
@@ -2137,8 +1529,8 @@ trampCall(
2137
1529
  #--------------------
2138
1530
 
2139
1531
  trampCall(
2140
- begin
2141
- begin
1532
+ begin #makeBegin
1533
+ begin #execFunc
2142
1534
  def self._html_COMARKh1_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKh1', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2143
1535
  @global_lisp_binding['_html_COMARKh1'] = self.method( :_html_COMARKh1_METHOD )
2144
1536
  @_html_COMARKh1 =
@@ -2146,24 +1538,20 @@ trampCall(
2146
1538
  nil
2147
1539
  )
2148
1540
  end
2149
- begin
1541
+ begin #execFunc
2150
1542
  def self._html_COMARKh1_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKh1', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2151
1543
  @global_lisp_binding['_html_COMARKh1'] = self.method( :_html_COMARKh1_METHOD )
2152
1544
  @_html_COMARKh1 =
2153
1545
  trampCall(
2154
- begin
2155
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2156
- begin
2157
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2158
- end ,
2159
- [
2160
- :"h1"
2161
- ]
2162
- ))
2163
- end
1546
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1547
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1548
+ [
1549
+ :"h1"
1550
+ ]
1551
+ ))
2164
1552
  )
2165
1553
  end
2166
- begin
1554
+ begin #execFunc
2167
1555
  def self._html_COMARKh2_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKh2', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2168
1556
  @global_lisp_binding['_html_COMARKh2'] = self.method( :_html_COMARKh2_METHOD )
2169
1557
  @_html_COMARKh2 =
@@ -2171,24 +1559,20 @@ trampCall(
2171
1559
  nil
2172
1560
  )
2173
1561
  end
2174
- begin
1562
+ begin #execFunc
2175
1563
  def self._html_COMARKh2_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKh2', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2176
1564
  @global_lisp_binding['_html_COMARKh2'] = self.method( :_html_COMARKh2_METHOD )
2177
1565
  @_html_COMARKh2 =
2178
1566
  trampCall(
2179
- begin
2180
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2181
- begin
2182
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2183
- end ,
2184
- [
2185
- :"h2"
2186
- ]
2187
- ))
2188
- end
1567
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1568
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1569
+ [
1570
+ :"h2"
1571
+ ]
1572
+ ))
2189
1573
  )
2190
1574
  end
2191
- begin
1575
+ begin #execFunc
2192
1576
  def self._html_COMARKh3_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKh3', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2193
1577
  @global_lisp_binding['_html_COMARKh3'] = self.method( :_html_COMARKh3_METHOD )
2194
1578
  @_html_COMARKh3 =
@@ -2196,24 +1580,20 @@ trampCall(
2196
1580
  nil
2197
1581
  )
2198
1582
  end
2199
- begin
1583
+ begin #execFunc
2200
1584
  def self._html_COMARKh3_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKh3', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2201
1585
  @global_lisp_binding['_html_COMARKh3'] = self.method( :_html_COMARKh3_METHOD )
2202
1586
  @_html_COMARKh3 =
2203
1587
  trampCall(
2204
- begin
2205
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2206
- begin
2207
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2208
- end ,
2209
- [
2210
- :"h3"
2211
- ]
2212
- ))
2213
- end
1588
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1589
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1590
+ [
1591
+ :"h3"
1592
+ ]
1593
+ ))
2214
1594
  )
2215
1595
  end
2216
- begin
1596
+ begin #execFunc
2217
1597
  def self._html_COMARKh4_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKh4', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2218
1598
  @global_lisp_binding['_html_COMARKh4'] = self.method( :_html_COMARKh4_METHOD )
2219
1599
  @_html_COMARKh4 =
@@ -2221,24 +1601,20 @@ trampCall(
2221
1601
  nil
2222
1602
  )
2223
1603
  end
2224
- begin
1604
+ begin #execFunc
2225
1605
  def self._html_COMARKh4_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKh4', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2226
1606
  @global_lisp_binding['_html_COMARKh4'] = self.method( :_html_COMARKh4_METHOD )
2227
1607
  @_html_COMARKh4 =
2228
1608
  trampCall(
2229
- begin
2230
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2231
- begin
2232
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2233
- end ,
2234
- [
2235
- :"h4"
2236
- ]
2237
- ))
2238
- end
1609
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1610
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1611
+ [
1612
+ :"h4"
1613
+ ]
1614
+ ))
2239
1615
  )
2240
1616
  end
2241
- begin
1617
+ begin #execFunc
2242
1618
  def self._html_COMARKh5_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKh5', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2243
1619
  @global_lisp_binding['_html_COMARKh5'] = self.method( :_html_COMARKh5_METHOD )
2244
1620
  @_html_COMARKh5 =
@@ -2246,24 +1622,20 @@ trampCall(
2246
1622
  nil
2247
1623
  )
2248
1624
  end
2249
- begin
1625
+ begin #execFunc
2250
1626
  def self._html_COMARKh5_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKh5', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2251
1627
  @global_lisp_binding['_html_COMARKh5'] = self.method( :_html_COMARKh5_METHOD )
2252
1628
  @_html_COMARKh5 =
2253
1629
  trampCall(
2254
- begin
2255
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2256
- begin
2257
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2258
- end ,
2259
- [
2260
- :"h5"
2261
- ]
2262
- ))
2263
- end
1630
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1631
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1632
+ [
1633
+ :"h5"
1634
+ ]
1635
+ ))
2264
1636
  )
2265
1637
  end
2266
- begin
1638
+ begin #execFunc
2267
1639
  def self._html_COMARKh6_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKh6', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2268
1640
  @global_lisp_binding['_html_COMARKh6'] = self.method( :_html_COMARKh6_METHOD )
2269
1641
  @_html_COMARKh6 =
@@ -2271,21 +1643,17 @@ trampCall(
2271
1643
  nil
2272
1644
  )
2273
1645
  end
2274
- begin
1646
+ begin #execFunc
2275
1647
  def self._html_COMARKh6_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKh6', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2276
1648
  @global_lisp_binding['_html_COMARKh6'] = self.method( :_html_COMARKh6_METHOD )
2277
1649
  @_html_COMARKh6 =
2278
1650
  trampCall(
2279
- begin
2280
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2281
- begin
2282
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2283
- end ,
2284
- [
2285
- :"h6"
2286
- ]
2287
- ))
2288
- end
1651
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1652
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1653
+ [
1654
+ :"h6"
1655
+ ]
1656
+ ))
2289
1657
  )
2290
1658
  end
2291
1659
  end
@@ -2293,8 +1661,8 @@ trampCall(
2293
1661
  #--------------------
2294
1662
 
2295
1663
  trampCall(
2296
- begin
2297
- begin
1664
+ begin #makeBegin
1665
+ begin #execFunc
2298
1666
  def self._html_COMARKpre_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKpre', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2299
1667
  @global_lisp_binding['_html_COMARKpre'] = self.method( :_html_COMARKpre_METHOD )
2300
1668
  @_html_COMARKpre =
@@ -2302,21 +1670,17 @@ trampCall(
2302
1670
  nil
2303
1671
  )
2304
1672
  end
2305
- begin
1673
+ begin #execFunc
2306
1674
  def self._html_COMARKpre_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKpre', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2307
1675
  @global_lisp_binding['_html_COMARKpre'] = self.method( :_html_COMARKpre_METHOD )
2308
1676
  @_html_COMARKpre =
2309
1677
  trampCall(
2310
- begin
2311
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2312
- begin
2313
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2314
- end ,
2315
- [
2316
- :"pre"
2317
- ]
2318
- ))
2319
- end
1678
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1679
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1680
+ [
1681
+ :"pre"
1682
+ ]
1683
+ ))
2320
1684
  )
2321
1685
  end
2322
1686
  end
@@ -2324,8 +1688,8 @@ trampCall(
2324
1688
  #--------------------
2325
1689
 
2326
1690
  trampCall(
2327
- begin
2328
- begin
1691
+ begin #makeBegin
1692
+ begin #execFunc
2329
1693
  def self._html_COMARKq_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKq', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2330
1694
  @global_lisp_binding['_html_COMARKq'] = self.method( :_html_COMARKq_METHOD )
2331
1695
  @_html_COMARKq =
@@ -2333,21 +1697,17 @@ trampCall(
2333
1697
  nil
2334
1698
  )
2335
1699
  end
2336
- begin
1700
+ begin #execFunc
2337
1701
  def self._html_COMARKq_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKq', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2338
1702
  @global_lisp_binding['_html_COMARKq'] = self.method( :_html_COMARKq_METHOD )
2339
1703
  @_html_COMARKq =
2340
1704
  trampCall(
2341
- begin
2342
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2343
- begin
2344
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2345
- end ,
2346
- [
2347
- :"q"
2348
- ]
2349
- ))
2350
- end
1705
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1706
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1707
+ [
1708
+ :"q"
1709
+ ]
1710
+ ))
2351
1711
  )
2352
1712
  end
2353
1713
  end
@@ -2355,8 +1715,8 @@ trampCall(
2355
1715
  #--------------------
2356
1716
 
2357
1717
  trampCall(
2358
- begin
2359
- begin
1718
+ begin #makeBegin
1719
+ begin #execFunc
2360
1720
  def self._html_COMARKblockquote_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKblockquote', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2361
1721
  @global_lisp_binding['_html_COMARKblockquote'] = self.method( :_html_COMARKblockquote_METHOD )
2362
1722
  @_html_COMARKblockquote =
@@ -2364,21 +1724,17 @@ trampCall(
2364
1724
  nil
2365
1725
  )
2366
1726
  end
2367
- begin
1727
+ begin #execFunc
2368
1728
  def self._html_COMARKblockquote_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKblockquote', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2369
1729
  @global_lisp_binding['_html_COMARKblockquote'] = self.method( :_html_COMARKblockquote_METHOD )
2370
1730
  @_html_COMARKblockquote =
2371
1731
  trampCall(
2372
- begin
2373
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2374
- begin
2375
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2376
- end ,
2377
- [
2378
- :"blockquote"
2379
- ]
2380
- ))
2381
- end
1732
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1733
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1734
+ [
1735
+ :"blockquote"
1736
+ ]
1737
+ ))
2382
1738
  )
2383
1739
  end
2384
1740
  end
@@ -2386,8 +1742,8 @@ trampCall(
2386
1742
  #--------------------
2387
1743
 
2388
1744
  trampCall(
2389
- begin
2390
- begin
1745
+ begin #makeBegin
1746
+ begin #execFunc
2391
1747
  def self._html_COMARKins_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKins', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2392
1748
  @global_lisp_binding['_html_COMARKins'] = self.method( :_html_COMARKins_METHOD )
2393
1749
  @_html_COMARKins =
@@ -2395,24 +1751,20 @@ trampCall(
2395
1751
  nil
2396
1752
  )
2397
1753
  end
2398
- begin
1754
+ begin #execFunc
2399
1755
  def self._html_COMARKins_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKins', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2400
1756
  @global_lisp_binding['_html_COMARKins'] = self.method( :_html_COMARKins_METHOD )
2401
1757
  @_html_COMARKins =
2402
1758
  trampCall(
2403
- begin
2404
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2405
- begin
2406
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2407
- end ,
2408
- [
2409
- :"ins"
2410
- ]
2411
- ))
2412
- end
1759
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1760
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1761
+ [
1762
+ :"ins"
1763
+ ]
1764
+ ))
2413
1765
  )
2414
1766
  end
2415
- begin
1767
+ begin #execFunc
2416
1768
  def self._html_COMARKdel_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKdel', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2417
1769
  @global_lisp_binding['_html_COMARKdel'] = self.method( :_html_COMARKdel_METHOD )
2418
1770
  @_html_COMARKdel =
@@ -2420,21 +1772,17 @@ trampCall(
2420
1772
  nil
2421
1773
  )
2422
1774
  end
2423
- begin
1775
+ begin #execFunc
2424
1776
  def self._html_COMARKdel_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKdel', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2425
1777
  @global_lisp_binding['_html_COMARKdel'] = self.method( :_html_COMARKdel_METHOD )
2426
1778
  @_html_COMARKdel =
2427
1779
  trampCall(
2428
- begin
2429
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2430
- begin
2431
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2432
- end ,
2433
- [
2434
- :"del"
2435
- ]
2436
- ))
2437
- end
1780
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1781
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1782
+ [
1783
+ :"del"
1784
+ ]
1785
+ ))
2438
1786
  )
2439
1787
  end
2440
1788
  end
@@ -2442,8 +1790,8 @@ trampCall(
2442
1790
  #--------------------
2443
1791
 
2444
1792
  trampCall(
2445
- begin
2446
- begin
1793
+ begin #makeBegin
1794
+ begin #execFunc
2447
1795
  def self._html_COMARKdl_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKdl', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2448
1796
  @global_lisp_binding['_html_COMARKdl'] = self.method( :_html_COMARKdl_METHOD )
2449
1797
  @_html_COMARKdl =
@@ -2451,24 +1799,20 @@ trampCall(
2451
1799
  nil
2452
1800
  )
2453
1801
  end
2454
- begin
1802
+ begin #execFunc
2455
1803
  def self._html_COMARKdl_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKdl', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2456
1804
  @global_lisp_binding['_html_COMARKdl'] = self.method( :_html_COMARKdl_METHOD )
2457
1805
  @_html_COMARKdl =
2458
1806
  trampCall(
2459
- begin
2460
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2461
- begin
2462
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2463
- end ,
2464
- [
2465
- :"dl"
2466
- ]
2467
- ))
2468
- end
1807
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1808
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1809
+ [
1810
+ :"dl"
1811
+ ]
1812
+ ))
2469
1813
  )
2470
1814
  end
2471
- begin
1815
+ begin #execFunc
2472
1816
  def self._html_COMARKdt_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKdt', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2473
1817
  @global_lisp_binding['_html_COMARKdt'] = self.method( :_html_COMARKdt_METHOD )
2474
1818
  @_html_COMARKdt =
@@ -2476,24 +1820,20 @@ trampCall(
2476
1820
  nil
2477
1821
  )
2478
1822
  end
2479
- begin
1823
+ begin #execFunc
2480
1824
  def self._html_COMARKdt_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKdt', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2481
1825
  @global_lisp_binding['_html_COMARKdt'] = self.method( :_html_COMARKdt_METHOD )
2482
1826
  @_html_COMARKdt =
2483
1827
  trampCall(
2484
- begin
2485
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2486
- begin
2487
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2488
- end ,
2489
- [
2490
- :"dt"
2491
- ]
2492
- ))
2493
- end
1828
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1829
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1830
+ [
1831
+ :"dt"
1832
+ ]
1833
+ ))
2494
1834
  )
2495
1835
  end
2496
- begin
1836
+ begin #execFunc
2497
1837
  def self._html_COMARKdd_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKdd', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2498
1838
  @global_lisp_binding['_html_COMARKdd'] = self.method( :_html_COMARKdd_METHOD )
2499
1839
  @_html_COMARKdd =
@@ -2501,24 +1841,20 @@ trampCall(
2501
1841
  nil
2502
1842
  )
2503
1843
  end
2504
- begin
1844
+ begin #execFunc
2505
1845
  def self._html_COMARKdd_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKdd', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2506
1846
  @global_lisp_binding['_html_COMARKdd'] = self.method( :_html_COMARKdd_METHOD )
2507
1847
  @_html_COMARKdd =
2508
1848
  trampCall(
2509
- begin
2510
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2511
- begin
2512
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2513
- end ,
2514
- [
2515
- :"dd"
2516
- ]
2517
- ))
2518
- end
1849
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1850
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1851
+ [
1852
+ :"dd"
1853
+ ]
1854
+ ))
2519
1855
  )
2520
1856
  end
2521
- begin
1857
+ begin #execFunc
2522
1858
  def self._html_COMARKol_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKol', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2523
1859
  @global_lisp_binding['_html_COMARKol'] = self.method( :_html_COMARKol_METHOD )
2524
1860
  @_html_COMARKol =
@@ -2526,24 +1862,20 @@ trampCall(
2526
1862
  nil
2527
1863
  )
2528
1864
  end
2529
- begin
1865
+ begin #execFunc
2530
1866
  def self._html_COMARKol_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKol', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2531
1867
  @global_lisp_binding['_html_COMARKol'] = self.method( :_html_COMARKol_METHOD )
2532
1868
  @_html_COMARKol =
2533
1869
  trampCall(
2534
- begin
2535
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2536
- begin
2537
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2538
- end ,
2539
- [
2540
- :"ol"
2541
- ]
2542
- ))
2543
- end
1870
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1871
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1872
+ [
1873
+ :"ol"
1874
+ ]
1875
+ ))
2544
1876
  )
2545
1877
  end
2546
- begin
1878
+ begin #execFunc
2547
1879
  def self._html_COMARKul_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKul', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2548
1880
  @global_lisp_binding['_html_COMARKul'] = self.method( :_html_COMARKul_METHOD )
2549
1881
  @_html_COMARKul =
@@ -2551,24 +1883,20 @@ trampCall(
2551
1883
  nil
2552
1884
  )
2553
1885
  end
2554
- begin
1886
+ begin #execFunc
2555
1887
  def self._html_COMARKul_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKul', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2556
1888
  @global_lisp_binding['_html_COMARKul'] = self.method( :_html_COMARKul_METHOD )
2557
1889
  @_html_COMARKul =
2558
1890
  trampCall(
2559
- begin
2560
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2561
- begin
2562
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2563
- end ,
2564
- [
2565
- :"ul"
2566
- ]
2567
- ))
2568
- end
1891
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1892
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1893
+ [
1894
+ :"ul"
1895
+ ]
1896
+ ))
2569
1897
  )
2570
1898
  end
2571
- begin
1899
+ begin #execFunc
2572
1900
  def self._html_COMARKli_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKli', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2573
1901
  @global_lisp_binding['_html_COMARKli'] = self.method( :_html_COMARKli_METHOD )
2574
1902
  @_html_COMARKli =
@@ -2576,21 +1904,17 @@ trampCall(
2576
1904
  nil
2577
1905
  )
2578
1906
  end
2579
- begin
1907
+ begin #execFunc
2580
1908
  def self._html_COMARKli_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKli', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2581
1909
  @global_lisp_binding['_html_COMARKli'] = self.method( :_html_COMARKli_METHOD )
2582
1910
  @_html_COMARKli =
2583
1911
  trampCall(
2584
- begin
2585
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2586
- begin
2587
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2588
- end ,
2589
- [
2590
- :"li"
2591
- ]
2592
- ))
2593
- end
1912
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1913
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1914
+ [
1915
+ :"li"
1916
+ ]
1917
+ ))
2594
1918
  )
2595
1919
  end
2596
1920
  end
@@ -2598,8 +1922,8 @@ trampCall(
2598
1922
  #--------------------
2599
1923
 
2600
1924
  trampCall(
2601
- begin
2602
- begin
1925
+ begin #makeBegin
1926
+ begin #execFunc
2603
1927
  def self._html_COMARKform_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKform', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2604
1928
  @global_lisp_binding['_html_COMARKform'] = self.method( :_html_COMARKform_METHOD )
2605
1929
  @_html_COMARKform =
@@ -2607,24 +1931,20 @@ trampCall(
2607
1931
  nil
2608
1932
  )
2609
1933
  end
2610
- begin
1934
+ begin #execFunc
2611
1935
  def self._html_COMARKform_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKform', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2612
1936
  @global_lisp_binding['_html_COMARKform'] = self.method( :_html_COMARKform_METHOD )
2613
1937
  @_html_COMARKform =
2614
1938
  trampCall(
2615
- begin
2616
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2617
- begin
2618
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2619
- end ,
2620
- [
2621
- :"form"
2622
- ]
2623
- ))
2624
- end
1939
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1940
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1941
+ [
1942
+ :"form"
1943
+ ]
1944
+ ))
2625
1945
  )
2626
1946
  end
2627
- begin
1947
+ begin #execFunc
2628
1948
  def self._html_COMARKlabel_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKlabel', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2629
1949
  @global_lisp_binding['_html_COMARKlabel'] = self.method( :_html_COMARKlabel_METHOD )
2630
1950
  @_html_COMARKlabel =
@@ -2632,24 +1952,20 @@ trampCall(
2632
1952
  nil
2633
1953
  )
2634
1954
  end
2635
- begin
1955
+ begin #execFunc
2636
1956
  def self._html_COMARKlabel_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKlabel', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2637
1957
  @global_lisp_binding['_html_COMARKlabel'] = self.method( :_html_COMARKlabel_METHOD )
2638
1958
  @_html_COMARKlabel =
2639
1959
  trampCall(
2640
- begin
2641
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2642
- begin
2643
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2644
- end ,
2645
- [
2646
- :"label"
2647
- ]
2648
- ))
2649
- end
1960
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1961
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1962
+ [
1963
+ :"label"
1964
+ ]
1965
+ ))
2650
1966
  )
2651
1967
  end
2652
- begin
1968
+ begin #execFunc
2653
1969
  def self._html_COMARKinput_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKinput', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2654
1970
  @global_lisp_binding['_html_COMARKinput'] = self.method( :_html_COMARKinput_METHOD )
2655
1971
  @_html_COMARKinput =
@@ -2657,26 +1973,22 @@ trampCall(
2657
1973
  nil
2658
1974
  )
2659
1975
  end
2660
- begin
1976
+ begin #execFunc
2661
1977
  def self._html_COMARKinput_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKinput', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2662
1978
  @global_lisp_binding['_html_COMARKinput'] = self.method( :_html_COMARKinput_METHOD )
2663
1979
  @_html_COMARKinput =
2664
1980
  trampCall(
2665
- begin
2666
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2667
- begin
2668
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2669
- end ,
2670
- [
2671
- :"input" ,
2672
- LispKeyword.new( "empty?" ) ,
2673
- true
2674
- ]
2675
- ))
2676
- end
1981
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
1982
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
1983
+ [
1984
+ :"input" ,
1985
+ LispKeyword.new( "empty?" ) ,
1986
+ true
1987
+ ]
1988
+ ))
2677
1989
  )
2678
1990
  end
2679
- begin
1991
+ begin #execFunc
2680
1992
  def self._html_COMARKselect_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKselect', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2681
1993
  @global_lisp_binding['_html_COMARKselect'] = self.method( :_html_COMARKselect_METHOD )
2682
1994
  @_html_COMARKselect =
@@ -2684,24 +1996,20 @@ trampCall(
2684
1996
  nil
2685
1997
  )
2686
1998
  end
2687
- begin
1999
+ begin #execFunc
2688
2000
  def self._html_COMARKselect_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKselect', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2689
2001
  @global_lisp_binding['_html_COMARKselect'] = self.method( :_html_COMARKselect_METHOD )
2690
2002
  @_html_COMARKselect =
2691
2003
  trampCall(
2692
- begin
2693
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2694
- begin
2695
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2696
- end ,
2697
- [
2698
- :"select"
2699
- ]
2700
- ))
2701
- end
2004
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2005
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2006
+ [
2007
+ :"select"
2008
+ ]
2009
+ ))
2702
2010
  )
2703
2011
  end
2704
- begin
2012
+ begin #execFunc
2705
2013
  def self._html_COMARKoptgroup_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKoptgroup', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2706
2014
  @global_lisp_binding['_html_COMARKoptgroup'] = self.method( :_html_COMARKoptgroup_METHOD )
2707
2015
  @_html_COMARKoptgroup =
@@ -2709,24 +2017,20 @@ trampCall(
2709
2017
  nil
2710
2018
  )
2711
2019
  end
2712
- begin
2020
+ begin #execFunc
2713
2021
  def self._html_COMARKoptgroup_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKoptgroup', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2714
2022
  @global_lisp_binding['_html_COMARKoptgroup'] = self.method( :_html_COMARKoptgroup_METHOD )
2715
2023
  @_html_COMARKoptgroup =
2716
2024
  trampCall(
2717
- begin
2718
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2719
- begin
2720
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2721
- end ,
2722
- [
2723
- :"optgroup"
2724
- ]
2725
- ))
2726
- end
2025
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2026
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2027
+ [
2028
+ :"optgroup"
2029
+ ]
2030
+ ))
2727
2031
  )
2728
2032
  end
2729
- begin
2033
+ begin #execFunc
2730
2034
  def self._html_COMARKoption_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKoption', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2731
2035
  @global_lisp_binding['_html_COMARKoption'] = self.method( :_html_COMARKoption_METHOD )
2732
2036
  @_html_COMARKoption =
@@ -2734,24 +2038,20 @@ trampCall(
2734
2038
  nil
2735
2039
  )
2736
2040
  end
2737
- begin
2041
+ begin #execFunc
2738
2042
  def self._html_COMARKoption_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKoption', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2739
2043
  @global_lisp_binding['_html_COMARKoption'] = self.method( :_html_COMARKoption_METHOD )
2740
2044
  @_html_COMARKoption =
2741
2045
  trampCall(
2742
- begin
2743
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2744
- begin
2745
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2746
- end ,
2747
- [
2748
- :"option"
2749
- ]
2750
- ))
2751
- end
2046
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2047
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2048
+ [
2049
+ :"option"
2050
+ ]
2051
+ ))
2752
2052
  )
2753
2053
  end
2754
- begin
2054
+ begin #execFunc
2755
2055
  def self._html_COMARKtextarea_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtextarea', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2756
2056
  @global_lisp_binding['_html_COMARKtextarea'] = self.method( :_html_COMARKtextarea_METHOD )
2757
2057
  @_html_COMARKtextarea =
@@ -2759,24 +2059,20 @@ trampCall(
2759
2059
  nil
2760
2060
  )
2761
2061
  end
2762
- begin
2062
+ begin #execFunc
2763
2063
  def self._html_COMARKtextarea_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtextarea', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2764
2064
  @global_lisp_binding['_html_COMARKtextarea'] = self.method( :_html_COMARKtextarea_METHOD )
2765
2065
  @_html_COMARKtextarea =
2766
2066
  trampCall(
2767
- begin
2768
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2769
- begin
2770
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2771
- end ,
2772
- [
2773
- :"textarea"
2774
- ]
2775
- ))
2776
- end
2067
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2068
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2069
+ [
2070
+ :"textarea"
2071
+ ]
2072
+ ))
2777
2073
  )
2778
2074
  end
2779
- begin
2075
+ begin #execFunc
2780
2076
  def self._html_COMARKfieldset_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKfieldset', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2781
2077
  @global_lisp_binding['_html_COMARKfieldset'] = self.method( :_html_COMARKfieldset_METHOD )
2782
2078
  @_html_COMARKfieldset =
@@ -2784,24 +2080,20 @@ trampCall(
2784
2080
  nil
2785
2081
  )
2786
2082
  end
2787
- begin
2083
+ begin #execFunc
2788
2084
  def self._html_COMARKfieldset_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKfieldset', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2789
2085
  @global_lisp_binding['_html_COMARKfieldset'] = self.method( :_html_COMARKfieldset_METHOD )
2790
2086
  @_html_COMARKfieldset =
2791
2087
  trampCall(
2792
- begin
2793
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2794
- begin
2795
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2796
- end ,
2797
- [
2798
- :"fieldset"
2799
- ]
2800
- ))
2801
- end
2088
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2089
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2090
+ [
2091
+ :"fieldset"
2092
+ ]
2093
+ ))
2802
2094
  )
2803
2095
  end
2804
- begin
2096
+ begin #execFunc
2805
2097
  def self._html_COMARKlegend_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKlegend', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2806
2098
  @global_lisp_binding['_html_COMARKlegend'] = self.method( :_html_COMARKlegend_METHOD )
2807
2099
  @_html_COMARKlegend =
@@ -2809,24 +2101,20 @@ trampCall(
2809
2101
  nil
2810
2102
  )
2811
2103
  end
2812
- begin
2104
+ begin #execFunc
2813
2105
  def self._html_COMARKlegend_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKlegend', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2814
2106
  @global_lisp_binding['_html_COMARKlegend'] = self.method( :_html_COMARKlegend_METHOD )
2815
2107
  @_html_COMARKlegend =
2816
2108
  trampCall(
2817
- begin
2818
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2819
- begin
2820
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2821
- end ,
2822
- [
2823
- :"legend"
2824
- ]
2825
- ))
2826
- end
2109
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2110
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2111
+ [
2112
+ :"legend"
2113
+ ]
2114
+ ))
2827
2115
  )
2828
2116
  end
2829
- begin
2117
+ begin #execFunc
2830
2118
  def self._html_COMARKbutton_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKbutton', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2831
2119
  @global_lisp_binding['_html_COMARKbutton'] = self.method( :_html_COMARKbutton_METHOD )
2832
2120
  @_html_COMARKbutton =
@@ -2834,21 +2122,17 @@ trampCall(
2834
2122
  nil
2835
2123
  )
2836
2124
  end
2837
- begin
2125
+ begin #execFunc
2838
2126
  def self._html_COMARKbutton_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKbutton', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2839
2127
  @global_lisp_binding['_html_COMARKbutton'] = self.method( :_html_COMARKbutton_METHOD )
2840
2128
  @_html_COMARKbutton =
2841
2129
  trampCall(
2842
- begin
2843
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2844
- begin
2845
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2846
- end ,
2847
- [
2848
- :"button"
2849
- ]
2850
- ))
2851
- end
2130
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2131
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2132
+ [
2133
+ :"button"
2134
+ ]
2135
+ ))
2852
2136
  )
2853
2137
  end
2854
2138
  end
@@ -2856,8 +2140,8 @@ trampCall(
2856
2140
  #--------------------
2857
2141
 
2858
2142
  trampCall(
2859
- begin
2860
- begin
2143
+ begin #makeBegin
2144
+ begin #execFunc
2861
2145
  def self._html_COMARKtable_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtable', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2862
2146
  @global_lisp_binding['_html_COMARKtable'] = self.method( :_html_COMARKtable_METHOD )
2863
2147
  @_html_COMARKtable =
@@ -2865,24 +2149,20 @@ trampCall(
2865
2149
  nil
2866
2150
  )
2867
2151
  end
2868
- begin
2152
+ begin #execFunc
2869
2153
  def self._html_COMARKtable_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtable', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2870
2154
  @global_lisp_binding['_html_COMARKtable'] = self.method( :_html_COMARKtable_METHOD )
2871
2155
  @_html_COMARKtable =
2872
2156
  trampCall(
2873
- begin
2874
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2875
- begin
2876
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2877
- end ,
2878
- [
2879
- :"table"
2880
- ]
2881
- ))
2882
- end
2157
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2158
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2159
+ [
2160
+ :"table"
2161
+ ]
2162
+ ))
2883
2163
  )
2884
2164
  end
2885
- begin
2165
+ begin #execFunc
2886
2166
  def self._html_COMARKcaption_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKcaption', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2887
2167
  @global_lisp_binding['_html_COMARKcaption'] = self.method( :_html_COMARKcaption_METHOD )
2888
2168
  @_html_COMARKcaption =
@@ -2890,24 +2170,20 @@ trampCall(
2890
2170
  nil
2891
2171
  )
2892
2172
  end
2893
- begin
2173
+ begin #execFunc
2894
2174
  def self._html_COMARKcaption_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKcaption', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2895
2175
  @global_lisp_binding['_html_COMARKcaption'] = self.method( :_html_COMARKcaption_METHOD )
2896
2176
  @_html_COMARKcaption =
2897
2177
  trampCall(
2898
- begin
2899
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2900
- begin
2901
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2902
- end ,
2903
- [
2904
- :"caption"
2905
- ]
2906
- ))
2907
- end
2178
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2179
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2180
+ [
2181
+ :"caption"
2182
+ ]
2183
+ ))
2908
2184
  )
2909
2185
  end
2910
- begin
2186
+ begin #execFunc
2911
2187
  def self._html_COMARKthead_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKthead', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2912
2188
  @global_lisp_binding['_html_COMARKthead'] = self.method( :_html_COMARKthead_METHOD )
2913
2189
  @_html_COMARKthead =
@@ -2915,24 +2191,20 @@ trampCall(
2915
2191
  nil
2916
2192
  )
2917
2193
  end
2918
- begin
2194
+ begin #execFunc
2919
2195
  def self._html_COMARKthead_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKthead', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2920
2196
  @global_lisp_binding['_html_COMARKthead'] = self.method( :_html_COMARKthead_METHOD )
2921
2197
  @_html_COMARKthead =
2922
2198
  trampCall(
2923
- begin
2924
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2925
- begin
2926
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2927
- end ,
2928
- [
2929
- :"thead"
2930
- ]
2931
- ))
2932
- end
2199
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2200
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2201
+ [
2202
+ :"thead"
2203
+ ]
2204
+ ))
2933
2205
  )
2934
2206
  end
2935
- begin
2207
+ begin #execFunc
2936
2208
  def self._html_COMARKtfoot_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtfoot', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2937
2209
  @global_lisp_binding['_html_COMARKtfoot'] = self.method( :_html_COMARKtfoot_METHOD )
2938
2210
  @_html_COMARKtfoot =
@@ -2940,24 +2212,20 @@ trampCall(
2940
2212
  nil
2941
2213
  )
2942
2214
  end
2943
- begin
2215
+ begin #execFunc
2944
2216
  def self._html_COMARKtfoot_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtfoot', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2945
2217
  @global_lisp_binding['_html_COMARKtfoot'] = self.method( :_html_COMARKtfoot_METHOD )
2946
2218
  @_html_COMARKtfoot =
2947
2219
  trampCall(
2948
- begin
2949
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2950
- begin
2951
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2952
- end ,
2953
- [
2954
- :"tfoot"
2955
- ]
2956
- ))
2957
- end
2220
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2221
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2222
+ [
2223
+ :"tfoot"
2224
+ ]
2225
+ ))
2958
2226
  )
2959
2227
  end
2960
- begin
2228
+ begin #execFunc
2961
2229
  def self._html_COMARKtbody_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtbody', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2962
2230
  @global_lisp_binding['_html_COMARKtbody'] = self.method( :_html_COMARKtbody_METHOD )
2963
2231
  @_html_COMARKtbody =
@@ -2965,24 +2233,20 @@ trampCall(
2965
2233
  nil
2966
2234
  )
2967
2235
  end
2968
- begin
2236
+ begin #execFunc
2969
2237
  def self._html_COMARKtbody_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtbody', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2970
2238
  @global_lisp_binding['_html_COMARKtbody'] = self.method( :_html_COMARKtbody_METHOD )
2971
2239
  @_html_COMARKtbody =
2972
2240
  trampCall(
2973
- begin
2974
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2975
- begin
2976
- trampCall(@_make_MIMARKhtml_MIMARKelement)
2977
- end ,
2978
- [
2979
- :"tbody"
2980
- ]
2981
- ))
2982
- end
2241
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2242
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2243
+ [
2244
+ :"tbody"
2245
+ ]
2246
+ ))
2983
2247
  )
2984
2248
  end
2985
- begin
2249
+ begin #execFunc
2986
2250
  def self._html_COMARKcolgroup_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKcolgroup', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2987
2251
  @global_lisp_binding['_html_COMARKcolgroup'] = self.method( :_html_COMARKcolgroup_METHOD )
2988
2252
  @_html_COMARKcolgroup =
@@ -2990,24 +2254,20 @@ trampCall(
2990
2254
  nil
2991
2255
  )
2992
2256
  end
2993
- begin
2257
+ begin #execFunc
2994
2258
  def self._html_COMARKcolgroup_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKcolgroup', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
2995
2259
  @global_lisp_binding['_html_COMARKcolgroup'] = self.method( :_html_COMARKcolgroup_METHOD )
2996
2260
  @_html_COMARKcolgroup =
2997
2261
  trampCall(
2998
- begin
2999
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3000
- begin
3001
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3002
- end ,
3003
- [
3004
- :"colgroup"
3005
- ]
3006
- ))
3007
- end
2262
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2263
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2264
+ [
2265
+ :"colgroup"
2266
+ ]
2267
+ ))
3008
2268
  )
3009
2269
  end
3010
- begin
2270
+ begin #execFunc
3011
2271
  def self._html_COMARKcol_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKcol', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3012
2272
  @global_lisp_binding['_html_COMARKcol'] = self.method( :_html_COMARKcol_METHOD )
3013
2273
  @_html_COMARKcol =
@@ -3015,26 +2275,22 @@ trampCall(
3015
2275
  nil
3016
2276
  )
3017
2277
  end
3018
- begin
2278
+ begin #execFunc
3019
2279
  def self._html_COMARKcol_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKcol', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3020
2280
  @global_lisp_binding['_html_COMARKcol'] = self.method( :_html_COMARKcol_METHOD )
3021
2281
  @_html_COMARKcol =
3022
2282
  trampCall(
3023
- begin
3024
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3025
- begin
3026
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3027
- end ,
3028
- [
3029
- :"col" ,
3030
- LispKeyword.new( "empty?" ) ,
3031
- true
3032
- ]
3033
- ))
3034
- end
2283
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2284
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2285
+ [
2286
+ :"col" ,
2287
+ LispKeyword.new( "empty?" ) ,
2288
+ true
2289
+ ]
2290
+ ))
3035
2291
  )
3036
2292
  end
3037
- begin
2293
+ begin #execFunc
3038
2294
  def self._html_COMARKtr_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtr', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3039
2295
  @global_lisp_binding['_html_COMARKtr'] = self.method( :_html_COMARKtr_METHOD )
3040
2296
  @_html_COMARKtr =
@@ -3042,24 +2298,20 @@ trampCall(
3042
2298
  nil
3043
2299
  )
3044
2300
  end
3045
- begin
2301
+ begin #execFunc
3046
2302
  def self._html_COMARKtr_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtr', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3047
2303
  @global_lisp_binding['_html_COMARKtr'] = self.method( :_html_COMARKtr_METHOD )
3048
2304
  @_html_COMARKtr =
3049
2305
  trampCall(
3050
- begin
3051
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3052
- begin
3053
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3054
- end ,
3055
- [
3056
- :"tr"
3057
- ]
3058
- ))
3059
- end
2306
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2307
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2308
+ [
2309
+ :"tr"
2310
+ ]
2311
+ ))
3060
2312
  )
3061
2313
  end
3062
- begin
2314
+ begin #execFunc
3063
2315
  def self._html_COMARKth_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKth', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3064
2316
  @global_lisp_binding['_html_COMARKth'] = self.method( :_html_COMARKth_METHOD )
3065
2317
  @_html_COMARKth =
@@ -3067,24 +2319,20 @@ trampCall(
3067
2319
  nil
3068
2320
  )
3069
2321
  end
3070
- begin
2322
+ begin #execFunc
3071
2323
  def self._html_COMARKth_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKth', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3072
2324
  @global_lisp_binding['_html_COMARKth'] = self.method( :_html_COMARKth_METHOD )
3073
2325
  @_html_COMARKth =
3074
2326
  trampCall(
3075
- begin
3076
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3077
- begin
3078
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3079
- end ,
3080
- [
3081
- :"th"
3082
- ]
3083
- ))
3084
- end
2327
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2328
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2329
+ [
2330
+ :"th"
2331
+ ]
2332
+ ))
3085
2333
  )
3086
2334
  end
3087
- begin
2335
+ begin #execFunc
3088
2336
  def self._html_COMARKtd_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtd', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3089
2337
  @global_lisp_binding['_html_COMARKtd'] = self.method( :_html_COMARKtd_METHOD )
3090
2338
  @_html_COMARKtd =
@@ -3092,21 +2340,17 @@ trampCall(
3092
2340
  nil
3093
2341
  )
3094
2342
  end
3095
- begin
2343
+ begin #execFunc
3096
2344
  def self._html_COMARKtd_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtd', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3097
2345
  @global_lisp_binding['_html_COMARKtd'] = self.method( :_html_COMARKtd_METHOD )
3098
2346
  @_html_COMARKtd =
3099
2347
  trampCall(
3100
- begin
3101
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3102
- begin
3103
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3104
- end ,
3105
- [
3106
- :"td"
3107
- ]
3108
- ))
3109
- end
2348
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2349
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2350
+ [
2351
+ :"td"
2352
+ ]
2353
+ ))
3110
2354
  )
3111
2355
  end
3112
2356
  end
@@ -3114,8 +2358,8 @@ trampCall(
3114
2358
  #--------------------
3115
2359
 
3116
2360
  trampCall(
3117
- begin
3118
- begin
2361
+ begin #makeBegin
2362
+ begin #execFunc
3119
2363
  def self._html_COMARKhead_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKhead', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3120
2364
  @global_lisp_binding['_html_COMARKhead'] = self.method( :_html_COMARKhead_METHOD )
3121
2365
  @_html_COMARKhead =
@@ -3123,24 +2367,20 @@ trampCall(
3123
2367
  nil
3124
2368
  )
3125
2369
  end
3126
- begin
2370
+ begin #execFunc
3127
2371
  def self._html_COMARKhead_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKhead', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3128
2372
  @global_lisp_binding['_html_COMARKhead'] = self.method( :_html_COMARKhead_METHOD )
3129
2373
  @_html_COMARKhead =
3130
2374
  trampCall(
3131
- begin
3132
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3133
- begin
3134
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3135
- end ,
3136
- [
3137
- :"head"
3138
- ]
3139
- ))
3140
- end
2375
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2376
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2377
+ [
2378
+ :"head"
2379
+ ]
2380
+ ))
3141
2381
  )
3142
2382
  end
3143
- begin
2383
+ begin #execFunc
3144
2384
  def self._html_COMARKtitle_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtitle', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3145
2385
  @global_lisp_binding['_html_COMARKtitle'] = self.method( :_html_COMARKtitle_METHOD )
3146
2386
  @_html_COMARKtitle =
@@ -3148,24 +2388,20 @@ trampCall(
3148
2388
  nil
3149
2389
  )
3150
2390
  end
3151
- begin
2391
+ begin #execFunc
3152
2392
  def self._html_COMARKtitle_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKtitle', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3153
2393
  @global_lisp_binding['_html_COMARKtitle'] = self.method( :_html_COMARKtitle_METHOD )
3154
2394
  @_html_COMARKtitle =
3155
2395
  trampCall(
3156
- begin
3157
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3158
- begin
3159
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3160
- end ,
3161
- [
3162
- :"title"
3163
- ]
3164
- ))
3165
- end
2396
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2397
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2398
+ [
2399
+ :"title"
2400
+ ]
2401
+ ))
3166
2402
  )
3167
2403
  end
3168
- begin
2404
+ begin #execFunc
3169
2405
  def self._html_COMARKbase_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKbase', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3170
2406
  @global_lisp_binding['_html_COMARKbase'] = self.method( :_html_COMARKbase_METHOD )
3171
2407
  @_html_COMARKbase =
@@ -3173,26 +2409,22 @@ trampCall(
3173
2409
  nil
3174
2410
  )
3175
2411
  end
3176
- begin
2412
+ begin #execFunc
3177
2413
  def self._html_COMARKbase_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKbase', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3178
2414
  @global_lisp_binding['_html_COMARKbase'] = self.method( :_html_COMARKbase_METHOD )
3179
2415
  @_html_COMARKbase =
3180
2416
  trampCall(
3181
- begin
3182
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3183
- begin
3184
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3185
- end ,
3186
- [
3187
- :"base" ,
3188
- LispKeyword.new( "empty?" ) ,
3189
- true
3190
- ]
3191
- ))
3192
- end
2417
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2418
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2419
+ [
2420
+ :"base" ,
2421
+ LispKeyword.new( "empty?" ) ,
2422
+ true
2423
+ ]
2424
+ ))
3193
2425
  )
3194
2426
  end
3195
- begin
2427
+ begin #execFunc
3196
2428
  def self._html_COMARKmeta_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKmeta', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3197
2429
  @global_lisp_binding['_html_COMARKmeta'] = self.method( :_html_COMARKmeta_METHOD )
3198
2430
  @_html_COMARKmeta =
@@ -3200,26 +2432,22 @@ trampCall(
3200
2432
  nil
3201
2433
  )
3202
2434
  end
3203
- begin
2435
+ begin #execFunc
3204
2436
  def self._html_COMARKmeta_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKmeta', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3205
2437
  @global_lisp_binding['_html_COMARKmeta'] = self.method( :_html_COMARKmeta_METHOD )
3206
2438
  @_html_COMARKmeta =
3207
2439
  trampCall(
3208
- begin
3209
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3210
- begin
3211
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3212
- end ,
3213
- [
3214
- :"meta" ,
3215
- LispKeyword.new( "empty?" ) ,
3216
- true
3217
- ]
3218
- ))
3219
- end
2440
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2441
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2442
+ [
2443
+ :"meta" ,
2444
+ LispKeyword.new( "empty?" ) ,
2445
+ true
2446
+ ]
2447
+ ))
3220
2448
  )
3221
2449
  end
3222
- begin
2450
+ begin #execFunc
3223
2451
  def self._html_COMARKstyle_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKstyle', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3224
2452
  @global_lisp_binding['_html_COMARKstyle'] = self.method( :_html_COMARKstyle_METHOD )
3225
2453
  @_html_COMARKstyle =
@@ -3227,24 +2455,20 @@ trampCall(
3227
2455
  nil
3228
2456
  )
3229
2457
  end
3230
- begin
2458
+ begin #execFunc
3231
2459
  def self._html_COMARKstyle_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKstyle', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3232
2460
  @global_lisp_binding['_html_COMARKstyle'] = self.method( :_html_COMARKstyle_METHOD )
3233
2461
  @_html_COMARKstyle =
3234
2462
  trampCall(
3235
- begin
3236
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3237
- begin
3238
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3239
- end ,
3240
- [
3241
- :"style"
3242
- ]
3243
- ))
3244
- end
2463
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2464
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2465
+ [
2466
+ :"style"
2467
+ ]
2468
+ ))
3245
2469
  )
3246
2470
  end
3247
- begin
2471
+ begin #execFunc
3248
2472
  def self._html_COMARKscript_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKscript', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3249
2473
  @global_lisp_binding['_html_COMARKscript'] = self.method( :_html_COMARKscript_METHOD )
3250
2474
  @_html_COMARKscript =
@@ -3252,24 +2476,20 @@ trampCall(
3252
2476
  nil
3253
2477
  )
3254
2478
  end
3255
- begin
2479
+ begin #execFunc
3256
2480
  def self._html_COMARKscript_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKscript', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3257
2481
  @global_lisp_binding['_html_COMARKscript'] = self.method( :_html_COMARKscript_METHOD )
3258
2482
  @_html_COMARKscript =
3259
2483
  trampCall(
3260
- begin
3261
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3262
- begin
3263
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3264
- end ,
3265
- [
3266
- :"script"
3267
- ]
3268
- ))
3269
- end
2484
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2485
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2486
+ [
2487
+ :"script"
2488
+ ]
2489
+ ))
3270
2490
  )
3271
2491
  end
3272
- begin
2492
+ begin #execFunc
3273
2493
  def self._html_COMARKnoscript_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKnoscript', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3274
2494
  @global_lisp_binding['_html_COMARKnoscript'] = self.method( :_html_COMARKnoscript_METHOD )
3275
2495
  @_html_COMARKnoscript =
@@ -3277,21 +2497,17 @@ trampCall(
3277
2497
  nil
3278
2498
  )
3279
2499
  end
3280
- begin
2500
+ begin #execFunc
3281
2501
  def self._html_COMARKnoscript_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKnoscript', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3282
2502
  @global_lisp_binding['_html_COMARKnoscript'] = self.method( :_html_COMARKnoscript_METHOD )
3283
2503
  @_html_COMARKnoscript =
3284
2504
  trampCall(
3285
- begin
3286
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3287
- begin
3288
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3289
- end ,
3290
- [
3291
- :"noscript"
3292
- ]
3293
- ))
3294
- end
2505
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2506
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2507
+ [
2508
+ :"noscript"
2509
+ ]
2510
+ ))
3295
2511
  )
3296
2512
  end
3297
2513
  end
@@ -3299,8 +2515,8 @@ trampCall(
3299
2515
  #--------------------
3300
2516
 
3301
2517
  trampCall(
3302
- begin
3303
- begin
2518
+ begin #makeBegin
2519
+ begin #execFunc
3304
2520
  def self._html_COMARKhtml_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKhtml', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3305
2521
  @global_lisp_binding['_html_COMARKhtml'] = self.method( :_html_COMARKhtml_METHOD )
3306
2522
  @_html_COMARKhtml =
@@ -3308,21 +2524,17 @@ trampCall(
3308
2524
  nil
3309
2525
  )
3310
2526
  end
3311
- begin
2527
+ begin #execFunc
3312
2528
  def self._html_COMARKhtml_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKhtml', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3313
2529
  @global_lisp_binding['_html_COMARKhtml'] = self.method( :_html_COMARKhtml_METHOD )
3314
2530
  @_html_COMARKhtml =
3315
2531
  trampCall(
3316
- begin
3317
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3318
- begin
3319
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3320
- end ,
3321
- [
3322
- :"html"
3323
- ]
3324
- ))
3325
- end
2532
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2533
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2534
+ [
2535
+ :"html"
2536
+ ]
2537
+ ))
3326
2538
  )
3327
2539
  end
3328
2540
  end
@@ -3330,8 +2542,8 @@ trampCall(
3330
2542
  #--------------------
3331
2543
 
3332
2544
  trampCall(
3333
- begin
3334
- begin
2545
+ begin #makeBegin
2546
+ begin #execFunc
3335
2547
  def self._html_COMARKframeset_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKframeset', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3336
2548
  @global_lisp_binding['_html_COMARKframeset'] = self.method( :_html_COMARKframeset_METHOD )
3337
2549
  @_html_COMARKframeset =
@@ -3339,24 +2551,20 @@ trampCall(
3339
2551
  nil
3340
2552
  )
3341
2553
  end
3342
- begin
2554
+ begin #execFunc
3343
2555
  def self._html_COMARKframeset_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKframeset', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3344
2556
  @global_lisp_binding['_html_COMARKframeset'] = self.method( :_html_COMARKframeset_METHOD )
3345
2557
  @_html_COMARKframeset =
3346
2558
  trampCall(
3347
- begin
3348
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3349
- begin
3350
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3351
- end ,
3352
- [
3353
- :"frameset"
3354
- ]
3355
- ))
3356
- end
2559
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2560
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2561
+ [
2562
+ :"frameset"
2563
+ ]
2564
+ ))
3357
2565
  )
3358
2566
  end
3359
- begin
2567
+ begin #execFunc
3360
2568
  def self._html_COMARKframe_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKframe', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3361
2569
  @global_lisp_binding['_html_COMARKframe'] = self.method( :_html_COMARKframe_METHOD )
3362
2570
  @_html_COMARKframe =
@@ -3364,24 +2572,20 @@ trampCall(
3364
2572
  nil
3365
2573
  )
3366
2574
  end
3367
- begin
2575
+ begin #execFunc
3368
2576
  def self._html_COMARKframe_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKframe', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3369
2577
  @global_lisp_binding['_html_COMARKframe'] = self.method( :_html_COMARKframe_METHOD )
3370
2578
  @_html_COMARKframe =
3371
2579
  trampCall(
3372
- begin
3373
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3374
- begin
3375
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3376
- end ,
3377
- [
3378
- :"frame"
3379
- ]
3380
- ))
3381
- end
2580
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2581
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2582
+ [
2583
+ :"frame"
2584
+ ]
2585
+ ))
3382
2586
  )
3383
2587
  end
3384
- begin
2588
+ begin #execFunc
3385
2589
  def self._html_COMARKnoframes_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKnoframes', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3386
2590
  @global_lisp_binding['_html_COMARKnoframes'] = self.method( :_html_COMARKnoframes_METHOD )
3387
2591
  @_html_COMARKnoframes =
@@ -3389,24 +2593,20 @@ trampCall(
3389
2593
  nil
3390
2594
  )
3391
2595
  end
3392
- begin
2596
+ begin #execFunc
3393
2597
  def self._html_COMARKnoframes_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKnoframes', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3394
2598
  @global_lisp_binding['_html_COMARKnoframes'] = self.method( :_html_COMARKnoframes_METHOD )
3395
2599
  @_html_COMARKnoframes =
3396
2600
  trampCall(
3397
- begin
3398
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3399
- begin
3400
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3401
- end ,
3402
- [
3403
- :"noframes"
3404
- ]
3405
- ))
3406
- end
2601
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2602
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2603
+ [
2604
+ :"noframes"
2605
+ ]
2606
+ ))
3407
2607
  )
3408
2608
  end
3409
- begin
2609
+ begin #execFunc
3410
2610
  def self._html_COMARKiframe_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKiframe', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3411
2611
  @global_lisp_binding['_html_COMARKiframe'] = self.method( :_html_COMARKiframe_METHOD )
3412
2612
  @_html_COMARKiframe =
@@ -3414,21 +2614,17 @@ trampCall(
3414
2614
  nil
3415
2615
  )
3416
2616
  end
3417
- begin
2617
+ begin #execFunc
3418
2618
  def self._html_COMARKiframe_METHOD( origname, pred, args ) lispMethodEntry( origname, true ) ; ret = callProcedure( '_html_COMARKiframe', origname, pred, args ) ; lispMethodExit( origname, true ) ; return ret end
3419
2619
  @global_lisp_binding['_html_COMARKiframe'] = self.method( :_html_COMARKiframe_METHOD )
3420
2620
  @_html_COMARKiframe =
3421
2621
  trampCall(
3422
- begin
3423
- trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
3424
- begin
3425
- trampCall(@_make_MIMARKhtml_MIMARKelement)
3426
- end ,
3427
- [
3428
- :"iframe"
3429
- ]
3430
- ))
3431
- end
2622
+ trampCall( self._make_MIMARKhtml_MIMARKelement_METHOD( 'make-html-element',
2623
+ trampCall(@_make_MIMARKhtml_MIMARKelement) ,
2624
+ [
2625
+ :"iframe"
2626
+ ]
2627
+ ))
3432
2628
  )
3433
2629
  end
3434
2630
  end