def! main text:text [
local-scope
load-ingredients
open-console
editor:&:editor <- new-editor text, 0/screen, 5/left, 45/right
editor-event-loop 0/screen, 0/console, editor
close-console
]
def editor-event-loop screen:&:screen, console:&:console, editor:&:editor -> screen:&:screen, console:&:console, editor:&:editor [
local-scope
load-ingredients
{
+next-event
cursor-row:num <- get *editor, cursor-row:offset
cursor-column:num <- get *editor, cursor-column:offset
screen <- move-cursor screen, cursor-row, cursor-column
e:event, console, found?:bool, quit?:bool <- read-event console
loop-unless found?
break-if quit?
trace 10, [app], [next-event]
t:touch-event, is-touch?:bool <- maybe-convert e, touch:variant
{
break-unless is-touch?
move-cursor-in-editor screen, editor, t
loop +next-event
}
{
break-if is-touch?
screen, editor, go-render?:bool <- handle-keyboard-event screen, editor, e
{
break-unless go-render?
screen <- editor-render screen, editor
}
}
loop
}
]
def move-cursor-in-editor screen:&:screen, editor:&:editor, t:touch-event -> in-focus?:bool, editor:&:editor [
local-scope
load-ingredients
return-unless editor, 0/false
click-row:num <- get t, row:offset
return-unless click-row, 0/false
click-column:num <- get t, column:offset
left:num <- get *editor, left:offset
too-far-left?:bool <- lesser-than click-column, left
return-if too-far-left?, 0/false
right:num <- get *editor, right:offset
too-far-right?:bool <- greater-than click-column, right
return-if too-far-right?, 0/false
<move-cursor-begin>
editor <- snap-cursor screen, editor, click-row, click-column
undo-coalesce-tag:num <- copy 0/never
<move-cursor-end>
return 1/true
]
def snap-cursor screen:&:screen, editor:&:editor, target-row:num, target-column:num -> editor:&:editor [
local-scope
load-ingredients
return-unless editor
left:num <- get *editor, left:offset
right:num <- get *editor, right:offset
screen-height:num <- screen-height screen
curr:&:duplex-list:char <- get *editor, top-of-screen:offset
prev:&:duplex-list:char <- copy curr
curr <- next curr
row:num <- copy 1/top
column:num <- copy left
*editor <- put *editor, cursor-row:offset, target-row
cursor-row:num <- copy target-row
*editor <- put *editor, cursor-column:offset, target-column
cursor-column:num <- copy target-column
before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
{
+next-character
break-unless curr
off-screen?:bool <- greater-or-equal row, screen-height
break-if off-screen?
{
at-cursor-row?:bool <- equal row, cursor-row
break-unless at-cursor-row?
at-cursor?:bool <- equal column, cursor-column
break-unless at-cursor?
before-cursor <- copy prev
*editor <- put *editor, before-cursor:offset, before-cursor
}
c:char <- get *curr, value:offset
{
newline?:bool <- equal c, 10/newline
break-unless newline?
{
at-cursor-row?:bool <- equal row, cursor-row
break-unless at-cursor-row?
left-of-cursor?:bool <- lesser-than column, cursor-column
break-unless left-of-cursor?
cursor-column <- copy column
*editor <- put *editor, cursor-column:offset, cursor-column
before-cursor <- copy prev
*editor <- put *editor, before-cursor:offset, before-cursor
}
row <- add row, 1
column <- copy left
curr <- next curr
prev <- next prev
loop +next-character
}
{
at-right?:bool <- equal column, right
break-unless at-right?
column <- copy left
row <- add row, 1
loop +next-character
}
curr <- next curr
prev <- next prev
column <- add column, 1
loop
}
{
at-cursor-row?:bool <- equal row, cursor-row
cursor-outside-line?:bool <- lesser-or-equal column, cursor-column
before-cursor-on-same-line?:bool <- and at-cursor-row?, cursor-outside-line?
above-cursor-row?:bool <- lesser-than row, cursor-row
before-cursor?:bool <- or before-cursor-on-same-line?, above-cursor-row?
break-unless before-cursor?
cursor-row <- copy row
*editor <- put *editor, cursor-row:offset, cursor-row
cursor-column <- copy column
*editor <- put *editor, cursor-column:offset, cursor-column
before-cursor <- copy prev
*editor <- put *editor, before-cursor:offset, before-cursor
}
]
def handle-keyboard-event screen:&:screen, editor:&:editor, e:event -> screen:&:screen, editor:&:editor, go-render?:bool [
local-scope
load-ingredients
go-render? <- copy 0/false
return-unless editor
screen-width:num <- screen-width screen
screen-height:num <- screen-height screen
left:num <- get *editor, left:offset
right:num <- get *editor, right:offset
before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
cursor-row:num <- get *editor, cursor-row:offset
cursor-column:num <- get *editor, cursor-column:offset
save-row:num <- copy cursor-row
save-column:num <- copy cursor-column
{
c:char, is-unicode?:bool <- maybe-convert e, text:variant
break-unless is-unicode?
trace 10, [app], [handle-keyboard-event: special character]
<handle-special-character>
regular-character?:bool <- greater-or-equal c, 32/space
go-render? <- copy 0/false
return-unless regular-character?
<insert-character-begin>
editor, screen, go-render?:bool <- insert-at-cursor editor, c, screen
<insert-character-end>
return
}
k:num, is-keycode?:bool <- maybe-convert e:event, keycode:variant
assert is-keycode?, [event was of unknown type; neither keyboard nor mouse]
<handle-special-key>
go-render? <- copy 1/true
return
]
def insert-at-cursor editor:&:editor, c:char, screen:&:screen -> editor:&:editor, screen:&:screen, go-render?:bool [
local-scope
load-ingredients
before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
insert c, before-cursor
before-cursor <- next before-cursor
*editor <- put *editor, before-cursor:offset, before-cursor
cursor-row:num <- get *editor, cursor-row:offset
cursor-column:num <- get *editor, cursor-column:offset
left:num <- get *editor, left:offset
right:num <- get *editor, right:offset
save-row:num <- copy cursor-row
save-column:num <- copy cursor-column
screen-width:num <- screen-width screen
screen-height:num <- screen-height screen
<insert-character-special-case>
cursor-column <- add cursor-column, 1
*editor <- put *editor, cursor-column:offset, cursor-column
next:&:duplex-list:char <- next before-cursor
{
at-end?:bool <- equal next, 0/null
break-unless at-end?
bottom:num <- subtract screen-height, 1
at-bottom?:bool <- equal save-row, bottom
at-right?:bool <- equal save-column, right
overflow?:bool <- and at-bottom?, at-right?
break-if overflow?
move-cursor screen, save-row, save-column
print screen, c
go-render? <- copy 0/false
return
}
{
break-unless next
at-right?:bool <- greater-or-equal cursor-column, screen-width
break-if at-right?
curr:&:duplex-list:char <- copy before-cursor
move-cursor screen, save-row, save-column
curr-column:num <- copy save-column
{
go-render? <- copy 1/true
at-right?:bool <- greater-than curr-column, right
return-if at-right?
break-unless curr
currc:char <- get *curr, value:offset
at-newline?:bool <- equal currc, 10/newline
break-if at-newline?
print screen, currc
curr-column <- add curr-column, 1
curr <- next curr
loop
}
go-render? <- copy 0/false
return
}
go-render? <- copy 1/true
return
]
def editor-render screen:&:screen, editor:&:editor -> screen:&:screen, editor:&:editor [
local-scope
load-ingredients
left:num <- get *editor, left:offset
right:num <- get *editor, right:offset
row:num, column:num <- render screen, editor
clear-line-until screen, right
row <- add row, 1
draw-horizontal screen, row, left, right, 9480/horizontal-dotted
row <- add row, 1
clear-screen-from screen, row, left, left, right
]
scenario editor-handles-empty-event-queue [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], screen, 0/left, 10/right
editor-render screen, e
assume-console []
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abc .
.╌╌╌╌╌╌╌╌╌╌.
. .
]
]
scenario editor-handles-mouse-clicks [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], screen, 0/left, 10/right
editor-render screen, e
$clear-trace
assume-console [
left-click 1, 1
]
run [
editor-event-loop screen, console, e
3:num/raw <- get *e, cursor-row:offset
4:num/raw <- get *e, cursor-column:offset
]
screen-should-contain [
. .
.abc .
.╌╌╌╌╌╌╌╌╌╌.
. .
]
memory-should-contain [
3 <- 1
4 <- 1
]
check-trace-count-for-label 0, [print-character]
]
scenario editor-handles-mouse-clicks-outside-text [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], screen, 0/left, 10/right
$clear-trace
assume-console [
left-click 1, 7
]
run [
editor-event-loop screen, console, e
3:num/raw <- get *e, cursor-row:offset
4:num/raw <- get *e, cursor-column:offset
]
memory-should-contain [
3 <- 1
4 <- 3
]
check-trace-count-for-label 0, [print-character]
]
scenario editor-handles-mouse-clicks-outside-text-2 [
local-scope
assume-screen 10/width, 5/height
s:text <- new [abc
def]
e:&:editor <- new-editor s, screen, 0/left, 10/right
$clear-trace
assume-console [
left-click 1, 7
]
run [
editor-event-loop screen, console, e
3:num/raw <- get *e, cursor-row:offset
4:num/raw <- get *e, cursor-column:offset
]
memory-should-contain [
3 <- 1
4 <- 3
]
check-trace-count-for-label 0, [print-character]
]
scenario editor-handles-mouse-clicks-outside-text-3 [
local-scope
assume-screen 10/width, 5/height
s:text <- new [abc
def]
e:&:editor <- new-editor s, screen, 0/left, 10/right
$clear-trace
assume-console [
left-click 3, 7
]
run [
editor-event-loop screen, console, e
3:num/raw <- get *e, cursor-row:offset
4:num/raw <- get *e, cursor-column:offset
]
memory-should-contain [
3 <- 2
4 <- 3
]
check-trace-count-for-label 0, [print-character]
]
scenario editor-handles-mouse-clicks-outside-column [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], screen, 0/left, 5/right
editor-render screen, e
$clear-trace
assume-console [
left-click 3, 8
]
run [
editor-event-loop screen, console, e
3:num/raw <- get *e, cursor-row:offset
4:num/raw <- get *e, cursor-column:offset
]
screen-should-contain [
. .
.abc .
.╌╌╌╌╌ .
. .
]
memory-should-contain [
3 <- 1
4 <- 0
]
check-trace-count-for-label 0, [print-character]
]
scenario editor-handles-mouse-clicks-in-menu-area [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], screen, 0/left, 5/right
editor-render screen, e
$clear-trace
assume-console [
left-click 0, 3
]
run [
editor-event-loop screen, console, e
3:num/raw <- get *e, cursor-row:offset
4:num/raw <- get *e, cursor-column:offset
]
memory-should-contain [
3 <- 1
4 <- 0
]
]
scenario editor-inserts-characters-into-empty-editor [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [], screen, 0/left, 5/right
editor-render screen, e
$clear-trace
assume-console [
type [abc]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abc .
.╌╌╌╌╌ .
. .
]
check-trace-count-for-label 3, [print-character]
]
scenario editor-inserts-characters-at-cursor [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], screen, 0/left, 10/right
editor-render screen, e
$clear-trace
assume-console [
type [0]
left-click 1, 2
type [d]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.0adbc .
.╌╌╌╌╌╌╌╌╌╌.
. .
]
check-trace-count-for-label 7, [print-character]
]
scenario editor-inserts-characters-at-cursor-2 [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], screen, 0/left, 10/right
editor-render screen, e
$clear-trace
assume-console [
left-click 1, 5
type [d]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abcd .
.╌╌╌╌╌╌╌╌╌╌.
. .
]
check-trace-count-for-label 1, [print-character]
]
scenario editor-inserts-characters-at-cursor-5 [
local-scope
assume-screen 10/width, 5/height
s:text <- new [abc
d]
e:&:editor <- new-editor s, screen, 0/left, 10/right
editor-render screen, e
$clear-trace
assume-console [
left-click 1, 5
type [e]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abce .
.d .
.╌╌╌╌╌╌╌╌╌╌.
. .
]
check-trace-count-for-label 1, [print-character]
]
scenario editor-inserts-characters-at-cursor-3 [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], screen, 0/left, 10/right
editor-render screen, e
$clear-trace
assume-console [
left-click 3, 5
type [d]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abcd .
.╌╌╌╌╌╌╌╌╌╌.
. .
]
check-trace-count-for-label 1, [print-character]
]
scenario editor-inserts-characters-at-cursor-4 [
local-scope
assume-screen 10/width, 5/height
s:text <- new [abc
d]
e:&:editor <- new-editor s, screen, 0/left, 10/right
editor-render screen, e
$clear-trace
assume-console [
left-click 3, 5
type [e]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abc .
.de .
.╌╌╌╌╌╌╌╌╌╌.
. .
]
check-trace-count-for-label 1, [print-character]
]
scenario editor-inserts-characters-at-cursor-6 [
local-scope
assume-screen 10/width, 5/height
s:text <- new [abc
d]
e:&:editor <- new-editor s, screen, 0/left, 10/right
editor-render screen, e
$clear-trace
assume-console [
left-click 3, 5
type [ef]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abc .
.def .
.╌╌╌╌╌╌╌╌╌╌.
. .
]
check-trace-count-for-label 2, [print-character]
]
scenario editor-moves-cursor-after-inserting-characters [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [ab], screen, 0/left, 5/right
editor-render screen, e
assume-console [
type [01]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.01ab .
.╌╌╌╌╌ .
. .
]
]
scenario editor-wraps-line-on-insert [
local-scope
assume-screen 5/width, 5/height
e:&:editor <- new-editor [abc], screen, 0/left, 5/right
editor-render screen, e
assume-console [
type [e]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.eabc .
.╌╌╌╌╌.
. .
. .
]
assume-console [
type [f]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.efab↩.
.c .
.╌╌╌╌╌.
. .
]
]
scenario editor-wraps-line-on-insert-2 [
local-scope
assume-screen 10/width, 5/height
s:text <- new [abcdefg
defg]
e:&:editor <- new-editor s, screen, 0/left, 5/right
editor-render screen, e
assume-console [
left-click 3, 0
type [abc]
]
run [
editor-event-loop screen, console, e
3:num/raw <- get *e, cursor-row:offset
4:num/raw <- get *e, cursor-column:offset
]
memory-should-contain [
3 <- 3
4 <- 3
]
screen-should-contain [
. .
.abcd↩ .
.efg .
.abcd↩ .
.efg .
]
]
after <insert-character-special-case> [
{
wrap-column:num <- copy right
before-wrap-column:num <- subtract wrap-column, 1
at-wrap?:bool <- greater-or-equal cursor-column, wrap-column
just-before-wrap?:bool <- greater-or-equal cursor-column, before-wrap-column
next:&:duplex-list:char <- next before-cursor
at-end-of-line?:bool <- equal next, 0
{
break-if at-end-of-line?
next-character:char <- get *next, value:offset
at-end-of-line? <- equal next-character, 10/newline
}
move-cursor-to-next-line?:bool <- copy 0/false
{
break-if at-end-of-line?
move-cursor-to-next-line? <- copy just-before-wrap?
potential-new-cursor-column:num <- copy left
}
{
break-unless at-end-of-line?
move-cursor-to-next-line? <- copy at-wrap?
potential-new-cursor-column:num <- add left, 1/make-room-for-wrap-indicator
}
break-unless move-cursor-to-next-line?
cursor-column <- copy potential-new-cursor-column
*editor <- put *editor, cursor-column:offset, cursor-column
cursor-row <- add cursor-row, 1
*editor <- put *editor, cursor-row:offset, cursor-row
{
below-screen?:bool <- greater-or-equal cursor-row, screen-height
break-unless below-screen?
<scroll-down>
}
go-render? <- copy 1/true
return
}
]
scenario editor-wraps-cursor-after-inserting-characters-in-middle-of-line [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abcde], screen, 0/left, 5/right
assume-console [
left-click 1, 3
type [f]
]
run [
editor-event-loop screen, console, e
3:num/raw <- get *e, cursor-row:offset
4:num/raw <- get *e, cursor-column:offset
]
screen-should-contain [
. .
.abcf↩ .
.de .
.╌╌╌╌╌ .
. .
]
memory-should-contain [
3 <- 2
4 <- 0
]
]
scenario editor-wraps-cursor-after-inserting-characters-at-end-of-line [
local-scope
assume-screen 10/width, 5/height
s:text <- new [abc
xyz]
e:&:editor <- new-editor s, screen, 0/left, 5/right
screen-should-contain [
. .
.abc .
.xyz .
. .
]
assume-console [
left-click 1, 4
type [de]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.abcd↩ .
.e .
.xyz .
.╌╌╌╌╌ .
]
]
scenario editor-wraps-cursor-to-left-margin [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abcde], screen, 2/left, 7/right
assume-console [
left-click 1, 5
type [01]
]
run [
editor-event-loop screen, console, e
3:num/raw <- get *e, cursor-row:offset
4:num/raw <- get *e, cursor-column:offset
]
screen-should-contain [
. .
. abc0↩ .
. 1de .
. ╌╌╌╌╌ .
. .
]
memory-should-contain [
3 <- 2
4 <- 3
]
]
container editor [
indent?:bool
]
after <editor-initialization> [
*result <- put *result, indent?:offset, 1/true
]
scenario editor-moves-cursor-down-after-inserting-newline [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], screen, 0/left, 10/right
assume-console [
type [0
1]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
.0 .
.1abc .
.╌╌╌╌╌╌╌╌╌╌.
. .
]
]
after <handle-special-character> [
{
newline?:bool <- equal c, 10/newline
break-unless newline?
<insert-enter-begin>
editor <- insert-new-line-and-indent editor, screen
<insert-enter-end>
go-render? <- copy 1/true
return
}
]
def insert-new-line-and-indent editor:&:editor, screen:&:screen -> editor:&:editor, screen:&:screen, go-render?:bool [
local-scope
load-ingredients
cursor-row:num <- get *editor, cursor-row:offset
cursor-column:num <- get *editor, cursor-column:offset
before-cursor:&:duplex-list:char <- get *editor, before-cursor:offset
left:num <- get *editor, left:offset
right:num <- get *editor, right:offset
screen-height:num <- screen-height screen
insert 10/newline, before-cursor
before-cursor <- next before-cursor
*editor <- put *editor, before-cursor:offset, before-cursor
cursor-row <- add cursor-row, 1
*editor <- put *editor, cursor-row:offset, cursor-row
cursor-column <- copy left
*editor <- put *editor, cursor-column:offset, cursor-column
{
below-screen?:bool <- greater-or-equal cursor-row, screen-height
break-unless below-screen?
<scroll-down>
go-render? <- copy 1/true
cursor-row <- subtract cursor-row, 1
*editor <- put *editor, cursor-row:offset, cursor-row
}
indent?:bool <- get *editor, indent?:offset
return-unless indent?
d:&:duplex-list:char <- get *editor, data:offset
end-of-previous-line:&:duplex-list:char <- prev before-cursor
indent:num <- line-indent end-of-previous-line, d
i:num <- copy 0
{
indent-done?:bool <- greater-or-equal i, indent
break-if indent-done?
editor, screen, go-render?:bool <- insert-at-cursor editor, 32/space, screen
i <- add i, 1
loop
}
]
def line-indent curr:&:duplex-list:char, start:&:duplex-list:char -> result:num [
local-scope
load-ingredients
result:num <- copy 0
return-unless curr
at-start?:bool <- equal curr, start
return-if at-start?
{
curr <- prev curr
break-unless curr
at-start?:bool <- equal curr, start
break-if at-start?
c:char <- get *curr, value:offset
at-newline?:bool <- equal c, 10/newline
break-if at-newline?
is-space?:bool <- equal c, 32/space
{
break-unless is-space?
result <- add result, 1
}
{
break-if is-space?
result <- copy 0
}
loop
}
]
scenario editor-moves-cursor-down-after-inserting-newline-2 [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abc], screen, 1/left, 10/right
assume-console [
type [0
1]
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
. 0 .
. 1abc .
. ╌╌╌╌╌╌╌╌╌.
. .
]
]
scenario editor-clears-previous-line-completely-after-inserting-newline [
local-scope
assume-screen 10/width, 5/height
e:&:editor <- new-editor [abcde], screen, 0/left, 5/right
assume-console [
press enter
]
screen-should-contain [
. .
.abcd↩ .
.e .
. .
. .
]
run [
editor-event-loop screen, console, e
]
screen-should-contain [
. .
. .
.abcd↩ .
.e .
.╌╌╌╌╌ .
]
]
scenario editor-inserts-indent-after-newline [
local-scope
assume-screen 10/width, 10/height
s:text <- new [ab
cd
ef]
e:&:editor <- new-editor s, screen, 0/left, 10/right
assume-console [
left-click 2, 8
type [
]
]
run [
editor-event-loop screen, console, e
3:num/raw <- get *e, cursor-row:offset
4:num/raw <- get *e, cursor-column:offset
]
memory-should-contain [
3 <- 3
4 <- 2
]
]
scenario editor-skips-indent-around-paste [
local-scope
assume-screen 10/width, 10/height
s:text <- new [ab
cd
ef]
e:&:editor <- new-editor s, screen, 0/left, 10/right
assume-console [
left-click 2, 8
press 65507
press enter
press 65506
]
run [
editor-event-loop screen, console, e
3:num/raw <- get *e, cursor-row:offset
4:num/raw <- get *e, cursor-column:offset
]
memory-should-contain [
3 <- 3
4 <- 0
]
]
after <handle-special-key> [
{
paste-start?:bool <- equal k, 65507/paste-start
break-unless paste-start?
*editor <- put *editor, indent?:offset, 0/false
go-render? <- copy 1/true
return
}
]
after <handle-special-key> [
{
paste-end?:bool <- equal k, 65506/paste-end
break-unless paste-end?
*editor <- put *editor, indent?:offset, 1/true
go-render? <- copy 1/true
return
}
]
def draw-horizontal screen:&:screen, row:num, x:num, right:num -> screen:&:screen [
local-scope
load-ingredients
style:char, style-found?:bool <- next-ingredient
{
break-if style-found?
style <- copy 9472/horizontal
}
color:num, color-found?:bool <- next-ingredient
{
break-if color-found?
color <- copy 245/grey
}
bg-color:num, bg-color-found?:bool <- next-ingredient
{
break-if bg-color-found?
bg-color <- copy 0/black
}
screen <- move-cursor screen, row, x
{
continue?:bool <- lesser-or-equal x, right
break-unless continue?
print screen, style, color, bg-color
x <- add x, 1
loop
}
]