1 # Testable primitives for writing to screen.
  2 #
  3 # Mu mostly uses the screen for text, but it builds it out of pixel graphics
  4 # and a bitmap font. There is no support for a blinking cursor, scrolling and
  5 # so on.
  6 #
  7 # Fake screens are primarily for testing text-mode prints. However, they do
  8 # support some rudimentary pixel operations as well. Caveats:
  9 #
 10 # - Drawing pixels atop text or vice versa is not supported. Results in a fake
 11 #   screen will not mimic real screens in these situations.
 12 # - Fake screens currently also assume a fixed-width 8x16 font.
 13 # - Combining characters don't render like in a real screen (which itself
 14 #   isn't ideal).
 15 
 16 type screen {
 17   # text mode
 18   width: int
 19   height: int
 20   data: (handle array screen-cell)
 21   cursor-x: int  # [0..width)
 22   cursor-y: int  # [0..height)
 23   # pixel graphics
 24   pixels: (handle array byte)
 25 }
 26 
 27 type screen-cell {
 28   data: code-point
 29   color: int
 30   background-color: int
 31   unused?: boolean
 32 }
 33 
 34 fn initialize-screen _screen: (addr screen), width: int, height: int, pixel-graphics?: boolean {
 35   var screen/esi: (addr screen) <- copy _screen
 36   var tmp/eax: int <- copy 0
 37   var dest/edi: (addr int) <- copy 0
 38   # screen->width = width
 39   dest <- get screen, width
 40   tmp <- copy width
 41   copy-to *dest, tmp
 42   # screen->height = height
 43   dest <- get screen, height
 44   tmp <- copy height
 45   copy-to *dest, tmp
 46   # populate screen->data
 47   {
 48     var data-ah/edi: (addr handle array screen-cell) <- get screen, data
 49     var capacity/eax: int <- copy width
 50     capacity <- multiply height
 51     #
 52     populate data-ah, capacity
 53   }
 54   # if necessary, populate screen->pixels
 55   {
 56     compare pixel-graphics?, 0/false
 57     break-if-=
 58     var pixels-ah/edi: (addr handle array byte) <- get screen, pixels
 59     var capacity/eax: int <- copy width
 60     capacity <- shift-left 3/log2-font-width
 61     capacity <- multiply height
 62     capacity <- shift-left 4/log2-font-height
 63     #
 64     populate pixels-ah, capacity
 65   }
 66   # screen->cursor-x = 0
 67   dest <- get screen, cursor-x
 68   copy-to *dest, 0
 69   # screen->cursor-y = 0
 70   dest <- get screen, cursor-y
 71   copy-to *dest, 0
 72 }
 73 
 74 # in graphemes
 75 fn screen-size _screen: (addr screen) -> _/eax: int, _/ecx: int {
 76   var screen/esi: (addr screen) <- copy _screen
 77   var width/eax: int <- copy 0
 78   var height/ecx: int <- copy 0
 79   compare screen, 0
 80   {
 81     break-if-!=
 82     return 0x80/128, 0x30/48
 83   }
 84   # fake screen
 85   var tmp/edx: (addr int) <- get screen, width
 86   width <- copy *tmp
 87   tmp <- get screen, height
 88   height <- copy *tmp
 89   return width, height
 90 }
 91 
 92 # testable screen primitive
 93 # return number of 8x16 units drawn
 94 fn draw-code-point _screen: (addr screen), c: code-point, x: int, y: int, color: int, background-color: int -> _/eax: int {
 95   var screen/esi: (addr screen) <- copy _screen
 96   {
 97     compare screen, 0
 98     break-if-!=
 99     var result/eax: int <- draw-code-point-on-real-screen c, x, y, color, background-color
100     return result
101   }
102   # fake screen
103   var wide?/eax: boolean <- wide-code-point? c
104   compare wide?, 0/false
105   {
106     break-if-=
107     draw-wide-code-point-on-fake-screen screen, c, x, y, color, background-color
108     return 2
109   }
110   draw-narrow-code-point-on-fake-screen screen, c, x, y, color, background-color
111   return 1
112 }
113 
114 fn overlay-code-point _screen: (addr screen), c: code-point, x: int, y: int, color: int, background-color: int -> _/eax: int {
115   var screen/esi: (addr screen) <- copy _screen
116   {
117     compare screen, 0
118     break-if-!=
119     var result/eax: int <- overlay-code-point-on-real-screen c, x, y, color, background-color
120     return result
121   }
122   # fake screen
123   # TODO: support overlays in fake screen
124   var wide?/eax: boolean <- wide-code-point? c
125   compare wide?, 0/false
126   {
127     break-if-=
128     draw-wide-code-point-on-fake-screen screen, c, x, y, color, background-color
129     return 2
130   }
131   draw-narrow-code-point-on-fake-screen screen, c, x, y, color, background-color
132   return 1
133 }
134 
135 fn draw-narrow-code-point-on-fake-screen _screen: (addr screen), c: code-point, x: int, y: int, color: int, background-color: int {
136   var screen/esi: (addr screen) <- copy _screen
137   # ignore if out of bounds
138   {
139     compare x, 0
140     break-if->=
141     return
142   }
143   {
144     var xmax-addr/eax: (addr int) <- get screen, width
145     var xmax/eax: int <- copy *xmax-addr
146     compare x, xmax
147     break-if-<
148     {
149       loop
150     }
151     return
152   }
153   {
154     compare y, 0
155     break-if->=
156     return
157   }
158   {
159     var ymax-addr/eax: (addr int) <- get screen, height
160     var ymax/eax: int <- copy *ymax-addr
161     compare y, ymax
162     break-if-<
163     return
164   }
165   #
166   var index/ecx: int <- screen-cell-index screen, x, y
167   var data-ah/eax: (addr handle array screen-cell) <- get screen, data
168   var data/eax: (addr array screen-cell) <- lookup *data-ah
169   var offset/ecx: (offset screen-cell) <- compute-offset data, index
170   var dest-cell/ecx: (addr screen-cell) <- index data, offset
171   var dest-code-point/eax: (addr code-point) <- get dest-cell, data
172   var c2/edx: code-point <- copy c
173   copy-to *dest-code-point, c2
174   var dest-color/eax: (addr int) <- get dest-cell, color
175   var src-color/edx: int <- copy color
176   copy-to *dest-color, src-color
177   dest-color <- get dest-cell, background-color
178   src-color <- copy background-color
179   copy-to *dest-color, src-color
180   var dest/eax: (addr boolean) <- get dest-cell, unused?
181   copy-to *dest, 0/false
182 }
183 
184 fn draw-wide-code-point-on-fake-screen _screen: (addr screen), c: code-point, x: int, y: int, color: int, background-color: int {
185   var screen/esi: (addr screen) <- copy _screen
186   # ignore if out of bounds
187   {
188     compare x, 0
189     break-if->=
190     return
191   }
192   {
193     var xmax-addr/eax: (addr int) <- get screen, width
194     var xmax/eax: int <- copy *xmax-addr
195     xmax <- decrement  # wide code-points need an extra unit
196     compare x, xmax
197     break-if-<
198     return
199   }
200   {
201     compare y, 0
202     break-if->=
203     return
204   }
205   {
206     var ymax-addr/eax: (addr int) <- get screen, height
207     var ymax/eax: int <- copy *ymax-addr
208     compare y, ymax
209     break-if-<
210     return
211   }
212   #
213   var index/ecx: int <- screen-cell-index screen, x, y
214   {
215     var data-ah/eax: (addr handle array screen-cell) <- get screen, data
216     var data/eax: (addr array screen-cell) <- lookup *data-ah
217     var offset/ecx: (offset screen-cell) <- compute-offset data, index
218     var dest-cell/ecx: (addr screen-cell) <- index data, offset
219     var dest-code-point/eax: (addr code-point) <- get dest-cell, data
220     var c2/edx: code-point <- copy c
221     copy-to *dest-code-point, c2
222     var dest-color/eax: (addr int) <- get dest-cell, color
223     var src-color/edx: int <- copy color
224     copy-to *dest-color, src-color
225     dest-color <- get dest-cell, background-color
226     src-color <- copy background-color
227     copy-to *dest-color, src-color
228     var dest/eax: (addr boolean) <- get dest-cell, unused?
229     copy-to *dest, 0/false
230   }
231   # set next screen-cell to unused
232   index <- increment
233   {
234     var data-ah/eax: (addr handle array screen-cell) <- get screen, data
235     var data/eax: (addr array screen-cell) <- lookup *data-ah
236     var offset/ecx: (offset screen-cell) <- compute-offset data, index
237     var dest-cell/ecx: (addr screen-cell) <- index data, offset
238     var dest/eax: (addr boolean) <- get dest-cell, unused?
239     copy-to *dest, 1/true
240   }
241 }
242 
243 # fake screens only
244 fn screen-cell-index _screen: (addr screen), x: int, y: int -> _/ecx: int {
245   var screen/esi: (addr screen) <- copy _screen
246   var width-addr/eax: (addr int) <- get screen, width
247   var result/ecx: int <- copy y
248   result <- multiply *width-addr
249   result <- add x
250   return result
251 }
252 
253 fn cursor-position _screen: (addr screen) -> _/eax: int, _/ecx: int {
254   var screen/esi: (addr screen) <- copy _screen
255   {
256     compare screen, 0
257     break-if-!=
258     var x/eax: int <- copy 0
259     var y/ecx: int <- copy 0
260     x, y <- cursor-position-on-real-screen
261     return x, y
262   }
263   # fake screen
264   var cursor-x-addr/eax: (addr int) <- get screen, cursor-x
265   var cursor-y-addr/ecx: (addr int) <- get screen, cursor-y
266   return *cursor-x-addr, *cursor-y-addr
267 }
268 
269 fn set-cursor-position _screen: (addr screen), x: int, y: int {
270   var screen/esi: (addr screen) <- copy _screen
271   {
272     compare screen, 0
273     break-if-!=
274     set-cursor-position-on-real-screen x, y
275     return
276   }
277   # fake screen
278   # ignore x < 0
279   {
280     compare x, 0
281     break-if->=
282     return
283   }
284   # ignore x >= width
285   {
286     var width-addr/eax: (addr int) <- get screen, width
287     var width/eax: int <- copy *width-addr
288     compare x, width
289     break-if-<=
290     return
291   }
292   # ignore y < 0
293   {
294     compare y, 0
295     break-if->=
296     return
297   }
298   # ignore y >= height
299   {
300     var height-addr/eax: (addr int) <- get screen, height
301     var height/eax: int <- copy *height-addr
302     compare y, height
303     break-if-<
304     return
305   }
306   # screen->cursor-x = x
307   var dest/edi: (addr int) <- get screen, cursor-x
308   var src/eax: int <- copy x
309   copy-to *dest, src
310   # screen->cursor-y = y
311   dest <- get screen, cursor-y
312   src <- copy y
313   copy-to *dest, src
314 }
315 
316 fn draw-cursor screen: (addr screen), c: code-point {
317   {
318     compare screen, 0
319     break-if-!=
320     draw-cursor-on-real-screen c
321     return
322   }
323   # fake screen
324   var cursor-x/eax: int <- copy 0
325   var cursor-y/ecx: int <- copy 0
326   cursor-x, cursor-y <- cursor-position screen
327   var dummy/eax: int <- draw-code-point screen, c, cursor-x, cursor-y, 0/fg, 7/bg
328 }
329 
330 fn clear-screen _screen: (addr screen) {
331   var screen/esi: (addr screen) <- copy _screen
332   {
333     compare screen, 0
334     break-if-!=
335     clear-real-screen
336     return
337   }
338   # fake screen
339   set-cursor-position screen, 0, 0
340   var y/eax: int <- copy 0
341   var height/ecx: (addr int) <- get screen, height
342   {
343     compare y, *height
344     break-if->=
345     var x/edx: int <- copy 0
346     var width/ebx: (addr int) <- get screen, width
347     {
348       compare x, *width
349       break-if->=
350       var dummy/eax: int <- draw-code-point screen, 0/nul, x, y, 0/fg=black, 0/bg=black
351       x <- increment
352       loop
353     }
354     y <- increment
355     loop
356   }
357   set-cursor-position screen, 0, 0
358   var pixels-ah/eax: (addr handle array byte) <- get screen, pixels
359   var pixels/eax: (addr array byte) <- lookup *pixels-ah
360   var i/ecx: int <- copy 0
361   var max/edx: int <- length pixels
362   {
363     compare i, max
364     break-if->=
365     var curr/eax: (addr byte) <- index pixels, i
366     var zero/ebx: byte <- copy 0
367     copy-byte-to *curr, zero
368     i <- increment
369     loop
370   }
371 }
372 
373 fn fake-screen-empty? _screen: (addr screen) -> _/eax: boolean {
374   var screen/esi: (addr screen) <- copy _screen
375   var y/eax: int <- copy 0
376   var height/ecx: (addr int) <- get screen, height
377   {
378     compare y, *height
379     break-if->=
380     var x/edx: int <- copy 0
381     var width/ebx: (addr int) <- get screen, width
382     {
383       compare x, *width
384       break-if->=
385       var c/eax: code-point <- screen-code-point-at screen, x, y
386       {
387         compare c, 0
388         break-if-=
389         compare c, 0x20/space
390         break-if-=
391         return 0/false
392       }
393       x <- increment
394       loop
395     }
396     y <- increment
397     loop
398   }
399   var pixels-ah/eax: (addr handle array byte) <- get screen, pixels
400   var pixels/eax: (addr array byte) <- lookup *pixels-ah
401   var y/ebx: int <- copy 0
402   var height-addr/edx: (addr int) <- get screen, height
403   var height/edx: int <- copy *height-addr
404   height <- shift-left 4/log2-font-height
405   {
406     compare y, height
407     break-if->=
408     var width-addr/edx: (addr int) <- get screen, width
409     var width/edx: int <- copy *width-addr
410     width <- shift-left 3/log2-font-width
411     var x/edi: int <- copy 0
412     {
413       compare x, width
414       break-if->=
415       var index/ecx: int <- pixel-index screen, x, y
416       var color-addr/ecx: (addr byte) <- index pixels, index
417       var color/ecx: byte <- copy-byte *color-addr
418       compare color, 0
419       {
420         break-if-=
421         return 0/false
422       }
423       x <- increment
424       loop
425     }
426     y <- increment
427     loop
428   }
429   return 1/true
430 }
431 
432 fn clear-rect _screen: (addr screen), xmin: int, ymin: int, xmax: int, ymax: int, background-color: int {
433   var screen/esi: (addr screen) <- copy _screen
434   {
435     compare screen, 0
436     break-if-!=
437     clear-rect-on-real-screen xmin, ymin, xmax, ymax, background-color
438     return
439   }
440   # fake screen
441   set-cursor-position screen, 0, 0
442   var y/eax: int <- copy ymin
443   var ymax/ecx: int <- copy ymax
444   {
445     compare y, ymax
446     break-if->=
447     var x/edx: int <- copy xmin
448     var xmax/ebx: int <- copy xmax
449     {
450       compare x, xmax
451       break-if->=
452       var dummy/eax: int <- draw-code-point screen, 0x20/space, x, y, 0/fg, background-color
453       x <- increment
454       loop
455     }
456     y <- increment
457     loop
458   }
459   set-cursor-position screen, 0, 0
460 }
461 
462 # there's no grapheme that guarantees to cover every pixel, so we'll bump down
463 # to pixels for a real screen
464 fn clear-real-screen {
465   var y/eax: int <- copy 0
466   {
467     compare y, 0x300/screen-height=768
468     break-if->=
469     var x/edx: int <- copy 0
470     {
471       compare x, 0x400/screen-width=1024
472       break-if->=
473       pixel-on-real-screen x, y, 0/color=black
474       x <- increment
475       loop
476     }
477     y <- increment
478     loop
479   }
480 }
481 
482 fn clear-rect-on-real-screen xmin: int, ymin: int, xmax: int, ymax: int, background-color: int {
483   var y/eax: int <- copy ymin
484   y <- shift-left 4/log2-font-height
485   var ymax/ecx: int <- copy ymax
486   ymax <- shift-left 4/log2-font-height
487   {
488     compare y, ymax
489     break-if->=
490     var x/edx: int <- copy xmin
491     x <- shift-left 3/log2-font-width
492     var xmax/ebx: int <- copy xmax
493     xmax <- shift-left 3/log2-font-width
494     {
495       compare x, xmax
496       break-if->=
497       pixel-on-real-screen x, y, background-color
498       x <- increment
499       loop
500     }
501     y <- increment
502     loop
503   }
504 }
505 
506 fn screen-cell-unused-at? _screen: (addr screen), x: int, y: int -> _/eax: boolean {
507   var screen/esi: (addr screen) <- copy _screen
508   var index/ecx: int <- screen-cell-index screen, x, y
509   var result/eax: boolean <- screen-cell-unused-at-index? screen, index
510   return result
511 }
512 
513 fn screen-cell-unused-at-index? _screen: (addr screen), _index: int -> _/eax: boolean {
514   var screen/esi: (addr screen) <- copy _screen
515   var data-ah/eax: (addr handle array screen-cell) <- get screen, data
516   var data/eax: (addr array screen-cell) <- lookup *data-ah
517   var index/ecx: int <- copy _index
518   var offset/ecx: (offset screen-cell) <- compute-offset data, index
519   var cell/eax: (addr screen-cell) <- index data, offset
520   var src/eax: (addr boolean) <- get cell, unused?
521   return *src
522 }
523 
524 fn screen-code-point-at _screen: (addr screen), x: int, y: int -> _/eax: code-point {
525   var screen/esi: (addr screen) <- copy _screen
526   var index/ecx: int <- screen-cell-index screen, x, y
527   var result/eax: code-point <- screen-code-point-at-index screen, index
528   return result
529 }
530 
531 fn screen-code-point-at-index _screen: (addr screen), _index: int -> _/eax: code-point {
532   var screen/esi: (addr screen) <- copy _screen
533   var data-ah/eax: (addr handle array screen-cell) <- get screen, data
534   var data/eax: (addr array screen-cell) <- lookup *data-ah
535   var index/ecx: int <- copy _index
536   var offset/ecx: (offset screen-cell) <- compute-offset data, index
537   var cell/eax: (addr screen-cell) <- index data, offset
538   var src/eax: (addr code-point) <- get cell, data
539   return *src
540 }
541 
542 fn screen-color-at _screen: (addr screen), x: int, y: int -> _/eax: int {
543   var screen/esi: (addr screen) <- copy _screen
544   var index/ecx: int <- screen-cell-index screen, x, y
545   var result/eax: int <- screen-color-at-index screen, index
546   return result
547 }
548 
549 fn screen-color-at-index _screen: (addr screen), _index: int -> _/eax: int {
550   var screen/esi: (addr screen) <- copy _screen
551   var data-ah/eax: (addr handle array screen-cell) <- get screen, data
552   var data/eax: (addr array screen-cell) <- lookup *data-ah
553   var index/ecx: int <- copy _index
554   var offset/ecx: (offset screen-cell) <- compute-offset data, index
555   var cell/eax: (addr screen-cell) <- index data, offset
556   var src/eax: (addr int) <- get cell, color
557   var result/eax: int <- copy *src
558   return result
559 }
560 
561 fn screen-background-color-at _screen: (addr screen), x: int, y: int -> _/eax: int {
562   var screen/esi: (addr screen) <- copy _screen
563   var index/ecx: int <- screen-cell-index screen, x, y
564   var result/eax: int <- screen-background-color-at-index screen, index
565   return result
566 }
567 
568 fn screen-background-color-at-index _screen: (addr screen), _index: int -> _/eax: int {
569   var screen/esi: (addr screen) <- copy _screen
570   var data-ah/eax: (addr handle array screen-cell) <- get screen, data
571   var data/eax: (addr array screen-cell) <- lookup *data-ah
572   var index/ecx: int <- copy _index
573   var offset/ecx: (offset screen-cell) <- compute-offset data, index
574   var cell/eax: (addr screen-cell) <- index data, offset
575   var src/eax: (addr int) <- get cell, background-color
576   var result/eax: int <- copy *src
577   return result
578 }
579 
580 fn pixel screen: (addr screen), x: int, y: int, color: int {
581   {
582     compare screen, 0
583     break-if-!=
584     pixel-on-real-screen x, y, color
585     return
586   }
587   # fake screen
588   var screen/esi: (addr screen) <- copy screen
589   var pixels-ah/eax: (addr handle array byte) <- get screen, pixels
590   var pixels/eax: (addr array byte) <- lookup *pixels-ah
591   {
592     compare pixels, 0
593     break-if-!=
594     abort "pixel graphics not enabled for this screen"
595   }
596   # ignore if out of bounds
597   {
598     compare x, 0
599     break-if->=
600     return
601   }
602   {
603     var xmax-addr/eax: (addr int) <- get screen, width
604     var xmax/eax: int <- copy *xmax-addr
605     xmax <- shift-left 3/log2-font-width
606     compare x, xmax
607     break-if-<
608     return
609   }
610   {
611     compare y, 0
612     break-if->=
613     return
614   }
615   {
616     var ymax-addr/eax: (addr int) <- get screen, height
617     var ymax/eax: int <- copy *ymax-addr
618     ymax <- shift-left 4/log2-font-height
619     compare y, ymax
620     break-if-<
621     return
622   }
623   #
624   var index/ecx: int <- pixel-index screen, x, y
625   var dest/ecx: (addr byte) <- index pixels, index
626   var src/eax: byte <- copy-byte color
627   copy-byte-to *dest, src
628 }
629 
630 fn pixel-index _screen: (addr screen), x: int, y: int -> _/ecx: int {
631   var screen/esi: (addr screen) <- copy _screen
632   var width-addr/eax: (addr int) <- get screen, width
633   var result/ecx: int <- copy y
634   result <- multiply *width-addr
635   result <- shift-left 3/log2-font-width
636   result <- add x
637   return result
638 }
639 
640 # double-buffering primitive
641 # 'screen' must be a fake screen. 'target-screen' is usually real.
642 # Both screens must have the same size.
643 fn copy-pixels _screen: (addr screen), target-screen: (addr screen) {
644   var screen/esi: (addr screen) <- copy _screen
645   var pixels-ah/eax: (addr handle array byte) <- get screen, pixels
646   var _pixels/eax: (addr array byte) <- lookup *pixels-ah
647   var pixels/edi: (addr array byte) <- copy _pixels
648   var width-a/edx: (addr int) <- get screen, width
649   var width/edx: int <- copy *width-a
650   width <- shift-left 3/log2-font-width
651   var height-a/ebx: (addr int) <- get screen, height
652   var height/ebx: int <- copy *height-a
653   height <- shift-left 4/log2-font-height
654   var i/esi: int <- copy 0
655   var y/ecx: int <- copy 0
656   {
657     # screen top left pixels x y width height
658     compare y, height
659     break-if->=
660     var x/eax: int <- copy 0
661     {
662       compare x, width
663       break-if->=
664       {
665         var color-addr/ebx: (addr byte) <- index pixels, i
666         var color/ebx: byte <- copy-byte *color-addr
667         var color2/ebx: int <- copy color
668         pixel target-screen, x, y, color2
669       }
670       x <- increment
671       i <- increment
672       loop
673     }
674     y <- increment
675     loop
676   }
677 }
678 
679 # It turns out double-buffering screen-cells is useless because rendering fonts
680 # takes too long. (At least under Qemu.)
681 # So we'll instead convert screen-cells to pixels when double-buffering.
682 # 'screen' must be a fake screen.
683 fn convert-screen-cells-to-pixels _screen: (addr screen) {
684   var screen/esi: (addr screen) <- copy _screen
685   var width-a/ebx: (addr int) <- get screen, width
686   var height-a/edx: (addr int) <- get screen, height
687   var data-ah/eax: (addr handle array byte) <- get screen, pixels
688   var _data/eax: (addr array byte) <- lookup *data-ah
689   var data: (addr array byte)
690   copy-to data, _data
691   var y/ecx: int <- copy 0
692   {
693     compare y, *height-a
694     break-if->=
695     var x/edi: int <- copy 0
696     $convert-screen-cells-to-pixels:loop-x: {
697       compare x, *width-a
698       break-if->=
699       {
700         var tmp/eax: code-point <- screen-code-point-at screen, x, y
701         # skip null code-points that only get created when clearing screen
702         # there may be other pixels drawn there, and we don't want to clobber them
703         # this is a situation where fake screens aren't faithful to real screens; we don't support overlap between screen-cells and raw pixels
704         compare tmp, 0
705         break-if-=
706         var c: code-point
707         copy-to c, tmp
708         var tmp/eax: int <- screen-color-at screen, x, y
709         var fg: int
710         copy-to fg, tmp
711         var bg/eax: int <- screen-background-color-at screen, x, y
712         var offset/eax: int <- draw-code-point-on-screen-array data, c, x, y, fg, bg, *width-a, *height-a
713         x <- add offset
714         loop $convert-screen-cells-to-pixels:loop-x
715       }
716       x <- increment
717       loop
718     }
719     y <- increment
720     loop
721   }
722 }