1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
|
# If a screen is too wide, split it up into a fixed size of pages.
# We take control of drawing and moving the cursor, and delegate everything else.
# Never scroll; use the 'done-drawing?' method instead.
#
# Example usage:
# initialize-paginated-screen
# on each frame
# start-drawing
# while !done-drawing
# add-grapheme ...
type paginated-screen {
screen: (handle screen)
nrows: int # const
ncols: int # const
page-width: int
toprow: int
botrow: int
leftcol: int
rightcol: int
row: int
col: int
}
fn initialize-paginated-screen _self: (addr paginated-screen), page-width: int {
# hardcoded parameters:
# top-margin
# page-margin
var self/esi: (addr paginated-screen) <- copy _self
var screen-ah/eax: (addr handle screen) <- get self, screen
var _screen-addr/eax: (addr screen) <- lookup *screen-ah
var screen-addr/edi: (addr screen) <- copy _screen-addr
var nrows/eax: int <- copy 0
var ncols/ecx: int <- copy 0
nrows, ncols <- screen-size screen-addr
var dest/edx: (addr int) <- copy 0
# self->nrows = nrows
dest <- get self, nrows
copy-to *dest, nrows
# self->ncols = ncols
dest <- get self, ncols
copy-to *dest, ncols
# self->page-width = page-width
{
var pg/eax: int <- copy page-width
dest <- get self, page-width
copy-to *dest, pg
}
# self->toprow = top-margin
dest <- get self, toprow
copy-to *dest, 2 # top-margin
# self->botrow = nrows
dest <- get self, botrow
copy-to *dest, nrows
#
start-drawing self
}
fn start-drawing _self: (addr paginated-screen) {
var self/esi: (addr paginated-screen) <- copy _self
clear-paginated-screen self
var tmp/eax: (addr int) <- copy 0
var tmp2/ecx: int <- copy 0
# self->leftcol = page-margin
tmp <- get self, leftcol
copy-to *tmp, 5 # left-margin
# self->rightcol = self->leftcol + page-width
tmp <- get self, rightcol
#? copy-to *tmp, 0x1f # ncols - 1
copy-to *tmp, 0x45 # left-margin + page-width
# self->row = self->toprow
tmp <- get self, toprow
tmp2 <- copy *tmp
tmp <- get self, row
copy-to *tmp, tmp2
# self->col = self->leftcol
tmp <- get self, leftcol
tmp2 <- copy *tmp
tmp <- get self, col
copy-to *tmp, tmp2
#
reposition-cursor self
}
fn done-drawing? _self: (addr paginated-screen) -> result/eax: boolean {
$done-drawing?:body: {
# return self->rightcol >= self->ncols
var self/esi: (addr paginated-screen) <- copy _self
var max/ecx: (addr int) <- get self, ncols
var tmp/eax: (addr int) <- get self, rightcol
var right/eax: int <- copy *tmp
compare right, *max
{
break-if->=
result <- copy 0 # false
break $done-drawing?:body
}
{
break-if-<
result <- copy 1 # true
}
}
}
fn add-grapheme _self: (addr paginated-screen), c: grapheme {
$add-grapheme:body: {
var self/esi: (addr paginated-screen) <- copy _self
{
compare c, 0xa # newline
break-if-!=
next-line self
reposition-cursor self
break $add-grapheme:body
}
# print c
var screen-ah/eax: (addr handle screen) <- get self, screen
var screen-addr/eax: (addr screen) <- lookup *screen-ah
print-grapheme screen-addr, c
# self->col++
var tmp/eax: (addr int) <- get self, col
increment *tmp
# if (self->col > self->rightcol) next-line(self)
var tmp2/ecx: int <- copy *tmp
tmp <- get self, rightcol
compare tmp2, *tmp
{
break-if-<=
next-line self
reposition-cursor self
}
}
}
## tests
fn initialize-fake-paginated-screen _self: (addr paginated-screen), nrows: int, ncols: int, page-width: int {
var self/esi: (addr paginated-screen) <- copy _self
var screen-ah/eax: (addr handle screen) <- get self, screen
allocate screen-ah
var screen-addr/eax: (addr screen) <- lookup *screen-ah
initialize-screen screen-addr, nrows, ncols
initialize-paginated-screen self, page-width
}
## simple delegates
fn reposition-cursor _self: (addr paginated-screen) {
var self/esi: (addr paginated-screen) <- copy _self
var r/ecx: (addr int) <- get self, row
var c/edx: (addr int) <- get self, col
var screen-ah/eax: (addr handle screen) <- get self, screen
var screen-addr/eax: (addr screen) <- lookup *screen-ah
move-cursor screen-addr, *r *c
}
fn clear-paginated-screen _self: (addr paginated-screen) {
var self/esi: (addr paginated-screen) <- copy _self
var screen-ah/eax: (addr handle screen) <- get self, screen
var screen-addr/eax: (addr screen) <- lookup *screen-ah
clear-screen screen-addr
}
fn start-color-on-paginated-screen _self: (addr paginated-screen), fg: int, bg: int {
var self/esi: (addr paginated-screen) <- copy _self
var screen-ah/eax: (addr handle screen) <- get self, screen
var screen-addr/eax: (addr screen) <- lookup *screen-ah
start-color screen-addr, fg, bg
}
fn start-bold-on-paginated-screen _self: (addr paginated-screen) {
var self/esi: (addr paginated-screen) <- copy _self
var screen-ah/eax: (addr handle screen) <- get self, screen
var screen-addr/eax: (addr screen) <- lookup *screen-ah
start-bold screen-addr
}
fn start-underline-on-paginated-screen _self: (addr paginated-screen) {
var self/esi: (addr paginated-screen) <- copy _self
var screen-ah/eax: (addr handle screen) <- get self, screen
var screen-addr/eax: (addr screen) <- lookup *screen-ah
start-underline screen-addr
}
fn start-reverse-video-on-paginated-screen _self: (addr paginated-screen) {
var self/esi: (addr paginated-screen) <- copy _self
var screen-ah/eax: (addr handle screen) <- get self, screen
var screen-addr/eax: (addr screen) <- lookup *screen-ah
start-reverse-video screen-addr
}
fn start-blinking-on-paginated-screen _self: (addr paginated-screen) {
var self/esi: (addr paginated-screen) <- copy _self
var screen-ah/eax: (addr handle screen) <- get self, screen
var screen-addr/eax: (addr screen) <- lookup *screen-ah
start-blinking screen-addr
}
fn reset-formatting-on-paginated-screen _self: (addr paginated-screen) {
var self/esi: (addr paginated-screen) <- copy _self
var screen-ah/eax: (addr handle screen) <- get self, screen
var screen-addr/eax: (addr screen) <- lookup *screen-ah
reset-formatting screen-addr
}
## helpers
fn next-line _self: (addr paginated-screen) {
var self/esi: (addr paginated-screen) <- copy _self
var tmp/eax: (addr int) <- copy 0
var tmp2/ecx: int <- copy 0
# self->col = self->leftcol
tmp <- get self, leftcol
tmp2 <- copy *tmp
tmp <- get self, col
copy-to *tmp, tmp2
# self->row++
tmp <- get self, row
increment *tmp
# if (self->row > self->botrow) next-page(self)
tmp2 <- copy *tmp
tmp <- get self, botrow
compare tmp2, *tmp
{
break-if-<=
next-page self
}
}
fn next-page _self: (addr paginated-screen) {
var self/esi: (addr paginated-screen) <- copy _self
var pg/edi: (addr int) <- get self, page-width
var tmp/eax: (addr int) <- copy 0
var tmp2/ecx: int <- copy 0
#? # temporary: stop
#? tmp <- get self, ncols
#? tmp2 <- copy *tmp
#? tmp <- get self, rightcol
#? copy-to *tmp, tmp2
# real: multiple pages
# self->leftcol = self->rightcol + page-margin
tmp <- get self, rightcol
tmp2 <- copy *tmp
tmp2 <- add 5 # page-margin
tmp <- get self, leftcol
copy-to *tmp, tmp2
# self->rightcol = self->leftcol + page-width
tmp2 <- copy *tmp
tmp2 <- add *pg
tmp <- get self, rightcol
copy-to *tmp, tmp2
# self->row = self->toprow
tmp <- get self, toprow
tmp2 <- copy *tmp
tmp <- get self, row
copy-to *tmp, tmp2
# self->col = self->leftcol
tmp <- get self, leftcol
tmp2 <- copy *tmp
tmp <- get self, col
copy-to *tmp, tmp2
}
|