clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name grid.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.bin/tmux/obj -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/usr.bin/tmux -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.bin/tmux/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/usr.bin/tmux/grid.c
1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | |
11 | |
12 | |
13 | |
14 | |
15 | |
16 | |
17 | |
18 | |
19 | #include <sys/types.h> |
20 | |
21 | #include <stdlib.h> |
22 | #include <string.h> |
23 | |
24 | #include "tmux.h" |
25 | |
26 | |
27 | |
28 | |
29 | |
30 | |
31 | |
32 | |
33 | |
34 | |
35 | |
36 | |
37 | |
38 | |
39 | const struct grid_cell grid_default_cell = { |
40 | { { ' ' }, 0, 1, 1 }, 0, 0, 8, 8, 8, 0 |
41 | }; |
42 | |
43 | |
44 | |
45 | |
46 | |
47 | static const struct grid_cell grid_padding_cell = { |
48 | { { '!' }, 0, 0, 0 }, 0, GRID_FLAG_PADDING, 8, 8, 8, 0 |
49 | }; |
50 | |
51 | |
52 | static const struct grid_cell grid_cleared_cell = { |
53 | { { ' ' }, 0, 1, 1 }, 0, GRID_FLAG_CLEARED, 8, 8, 8, 0 |
54 | }; |
55 | static const struct grid_cell_entry grid_cleared_entry = { |
56 | { .data = { 0, 8, 8, ' ' } }, GRID_FLAG_CLEARED |
57 | }; |
58 | |
59 | |
60 | static void |
61 | grid_store_cell(struct grid_cell_entry *gce, const struct grid_cell *gc, |
62 | u_char c) |
63 | { |
64 | gce->flags = (gc->flags & ~GRID_FLAG_CLEARED); |
65 | |
66 | gce->data.fg = gc->fg & 0xff; |
67 | if (gc->fg & COLOUR_FLAG_256) |
68 | gce->flags |= GRID_FLAG_FG256; |
69 | |
70 | gce->data.bg = gc->bg & 0xff; |
71 | if (gc->bg & COLOUR_FLAG_256) |
72 | gce->flags |= GRID_FLAG_BG256; |
73 | |
74 | gce->data.attr = gc->attr; |
75 | gce->data.data = c; |
76 | } |
77 | |
78 | |
79 | static int |
80 | grid_need_extended_cell(const struct grid_cell_entry *gce, |
81 | const struct grid_cell *gc) |
82 | { |
83 | if (gce->flags & GRID_FLAG_EXTENDED) |
84 | return (1); |
85 | if (gc->attr > 0xff) |
86 | return (1); |
87 | if (gc->data.size != 1 || gc->data.width != 1) |
88 | return (1); |
89 | if ((gc->fg & COLOUR_FLAG_RGB) || (gc->bg & COLOUR_FLAG_RGB)) |
90 | return (1); |
91 | if (gc->us != 0) |
92 | return (1); |
93 | if (gc->link != 0) |
94 | return (1); |
95 | return (0); |
96 | } |
97 | |
98 | |
99 | static void |
100 | grid_get_extended_cell(struct grid_line *gl, struct grid_cell_entry *gce, |
101 | int flags) |
102 | { |
103 | u_int at = gl->extdsize + 1; |
104 | |
105 | gl->extddata = xreallocarray(gl->extddata, at, sizeof *gl->extddata); |
106 | gl->extdsize = at; |
107 | |
108 | gce->offset = at - 1; |
109 | gce->flags = (flags | GRID_FLAG_EXTENDED); |
110 | } |
111 | |
112 | |
113 | static struct grid_extd_entry * |
114 | grid_extended_cell(struct grid_line *gl, struct grid_cell_entry *gce, |
115 | const struct grid_cell *gc) |
116 | { |
117 | struct grid_extd_entry *gee; |
118 | int flags = (gc->flags & ~GRID_FLAG_CLEARED); |
119 | utf8_char uc; |
120 | |
121 | if (~gce->flags & GRID_FLAG_EXTENDED) |
122 | grid_get_extended_cell(gl, gce, flags); |
123 | else if (gce->offset >= gl->extdsize) |
124 | fatalx("offset too big"); |
125 | gl->flags |= GRID_LINE_EXTENDED; |
126 | |
127 | utf8_from_data(&gc->data, &uc); |
128 | |
129 | gee = &gl->extddata[gce->offset]; |
130 | gee->data = uc; |
131 | gee->attr = gc->attr; |
132 | gee->flags = flags; |
133 | gee->fg = gc->fg; |
134 | gee->bg = gc->bg; |
135 | gee->us = gc->us; |
136 | gee->link = gc->link; |
137 | return (gee); |
138 | } |
139 | |
140 | |
141 | static void |
142 | grid_compact_line(struct grid_line *gl) |
143 | { |
144 | int new_extdsize = 0; |
145 | struct grid_extd_entry *new_extddata; |
146 | struct grid_cell_entry *gce; |
147 | struct grid_extd_entry *gee; |
148 | u_int px, idx; |
149 | |
150 | if (gl->extdsize == 0) |
151 | return; |
152 | |
153 | for (px = 0; px < gl->cellsize; px++) { |
154 | gce = &gl->celldata[px]; |
155 | if (gce->flags & GRID_FLAG_EXTENDED) |
156 | new_extdsize++; |
157 | } |
158 | |
159 | if (new_extdsize == 0) { |
160 | free(gl->extddata); |
161 | gl->extddata = NULL; |
162 | gl->extdsize = 0; |
163 | return; |
164 | } |
165 | new_extddata = xreallocarray(NULL, new_extdsize, sizeof *gl->extddata); |
166 | |
167 | idx = 0; |
168 | for (px = 0; px < gl->cellsize; px++) { |
169 | gce = &gl->celldata[px]; |
170 | if (gce->flags & GRID_FLAG_EXTENDED) { |
171 | gee = &gl->extddata[gce->offset]; |
172 | memcpy(&new_extddata[idx], gee, sizeof *gee); |
173 | gce->offset = idx++; |
174 | } |
175 | } |
176 | |
177 | free(gl->extddata); |
178 | gl->extddata = new_extddata; |
179 | gl->extdsize = new_extdsize; |
180 | } |
181 | |
182 | |
183 | struct grid_line * |
184 | grid_get_line(struct grid *gd, u_int line) |
185 | { |
186 | return (&gd->linedata[line]); |
187 | } |
188 | |
189 | |
190 | void |
191 | grid_adjust_lines(struct grid *gd, u_int lines) |
192 | { |
193 | gd->linedata = xreallocarray(gd->linedata, lines, sizeof *gd->linedata); |
194 | } |
195 | |
196 | |
197 | static void |
198 | grid_clear_cell(struct grid *gd, u_int px, u_int py, u_int bg) |
199 | { |
200 | struct grid_line *gl = &gd->linedata[py]; |
201 | struct grid_cell_entry *gce = &gl->celldata[px]; |
202 | struct grid_extd_entry *gee; |
203 | |
204 | memcpy(gce, &grid_cleared_entry, sizeof *gce); |
205 | if (bg != 8) { |
206 | if (bg & COLOUR_FLAG_RGB) { |
207 | grid_get_extended_cell(gl, gce, gce->flags); |
208 | gee = grid_extended_cell(gl, gce, &grid_cleared_cell); |
209 | gee->bg = bg; |
210 | } else { |
211 | if (bg & COLOUR_FLAG_256) |
212 | gce->flags |= GRID_FLAG_BG256; |
213 | gce->data.bg = bg; |
214 | } |
215 | } |
216 | } |
217 | |
218 | |
219 | static int |
220 | grid_check_y(struct grid *gd, const char *from, u_int py) |
221 | { |
222 | if (py >= gd->hsize + gd->sy) { |
223 | log_debug("%s: y out of range: %u", from, py); |
224 | return (-1); |
225 | } |
226 | return (0); |
227 | } |
228 | |
229 | |
230 | int |
231 | grid_cells_look_equal(const struct grid_cell *gc1, const struct grid_cell *gc2) |
232 | { |
233 | if (gc1->fg != gc2->fg || gc1->bg != gc2->bg) |
234 | return (0); |
235 | if (gc1->attr != gc2->attr || gc1->flags != gc2->flags) |
236 | return (0); |
237 | if (gc1->link != gc2->link) |
238 | return (0); |
239 | return (1); |
240 | } |
241 | |
242 | |
243 | int |
244 | grid_cells_equal(const struct grid_cell *gc1, const struct grid_cell *gc2) |
245 | { |
246 | if (!grid_cells_look_equal(gc1, gc2)) |
247 | return (0); |
248 | if (gc1->data.width != gc2->data.width) |
249 | return (0); |
250 | if (gc1->data.size != gc2->data.size) |
251 | return (0); |
252 | return (memcmp(gc1->data.data, gc2->data.data, gc1->data.size) == 0); |
253 | } |
254 | |
255 | |
256 | static void |
257 | grid_free_line(struct grid *gd, u_int py) |
258 | { |
259 | free(gd->linedata[py].celldata); |
260 | gd->linedata[py].celldata = NULL; |
261 | free(gd->linedata[py].extddata); |
262 | gd->linedata[py].extddata = NULL; |
263 | } |
264 | |
265 | |
266 | static void |
267 | grid_free_lines(struct grid *gd, u_int py, u_int ny) |
268 | { |
269 | u_int yy; |
270 | |
271 | for (yy = py; yy < py + ny; yy++) |
272 | grid_free_line(gd, yy); |
273 | } |
274 | |
275 | |
276 | struct grid * |
277 | grid_create(u_int sx, u_int sy, u_int hlimit) |
278 | { |
279 | struct grid *gd; |
280 | |
281 | gd = xmalloc(sizeof *gd); |
282 | gd->sx = sx; |
283 | gd->sy = sy; |
284 | |
285 | if (hlimit != 0) |
286 | gd->flags = GRID_HISTORY; |
287 | else |
288 | gd->flags = 0; |
289 | |
290 | gd->hscrolled = 0; |
291 | gd->hsize = 0; |
292 | gd->hlimit = hlimit; |
293 | |
294 | if (gd->sy != 0) |
295 | gd->linedata = xcalloc(gd->sy, sizeof *gd->linedata); |
296 | else |
297 | gd->linedata = NULL; |
298 | |
299 | return (gd); |
300 | } |
301 | |
302 | |
303 | void |
304 | grid_destroy(struct grid *gd) |
305 | { |
306 | grid_free_lines(gd, 0, gd->hsize + gd->sy); |
307 | |
308 | free(gd->linedata); |
309 | |
310 | free(gd); |
311 | } |
312 | |
313 | |
314 | int |
315 | grid_compare(struct grid *ga, struct grid *gb) |
316 | { |
317 | struct grid_line *gla, *glb; |
318 | struct grid_cell gca, gcb; |
319 | u_int xx, yy; |
320 | |
321 | if (ga->sx != gb->sx || ga->sy != gb->sy) |
322 | return (1); |
323 | |
324 | for (yy = 0; yy < ga->sy; yy++) { |
325 | gla = &ga->linedata[yy]; |
326 | glb = &gb->linedata[yy]; |
327 | if (gla->cellsize != glb->cellsize) |
328 | return (1); |
329 | for (xx = 0; xx < gla->cellsize; xx++) { |
330 | grid_get_cell(ga, xx, yy, &gca); |
331 | grid_get_cell(gb, xx, yy, &gcb); |
332 | if (!grid_cells_equal(&gca, &gcb)) |
333 | return (1); |
334 | } |
335 | } |
336 | |
337 | return (0); |
338 | } |
339 | |
340 | |
341 | static void |
342 | grid_trim_history(struct grid *gd, u_int ny) |
343 | { |
344 | grid_free_lines(gd, 0, ny); |
345 | memmove(&gd->linedata[0], &gd->linedata[ny], |
346 | (gd->hsize + gd->sy - ny) * (sizeof *gd->linedata)); |
347 | } |
348 | |
349 | |
350 | |
351 | |
352 | |
353 | void |
354 | grid_collect_history(struct grid *gd) |
355 | { |
356 | u_int ny; |
357 | |
358 | if (gd->hsize == 0 || gd->hsize < gd->hlimit) |
359 | return; |
360 | |
361 | ny = gd->hlimit / 10; |
362 | if (ny < 1) |
363 | ny = 1; |
364 | if (ny > gd->hsize) |
365 | ny = gd->hsize; |
366 | |
367 | |
368 | |
369 | |
370 | |
371 | grid_trim_history(gd, ny); |
372 | |
373 | gd->hsize -= ny; |
374 | if (gd->hscrolled > gd->hsize) |
375 | gd->hscrolled = gd->hsize; |
376 | } |
377 | |
378 | |
379 | void |
380 | grid_remove_history(struct grid *gd, u_int ny) |
381 | { |
382 | u_int yy; |
383 | |
384 | if (ny > gd->hsize) |
385 | return; |
386 | for (yy = 0; yy < ny; yy++) |
387 | grid_free_line(gd, gd->hsize + gd->sy - 1 - yy); |
388 | gd->hsize -= ny; |
389 | } |
390 | |
391 | |
392 | |
393 | |
394 | |
395 | void |
396 | grid_scroll_history(struct grid *gd, u_int bg) |
397 | { |
398 | u_int yy; |
399 | |
400 | yy = gd->hsize + gd->sy; |
401 | gd->linedata = xreallocarray(gd->linedata, yy + 1, |
402 | sizeof *gd->linedata); |
403 | grid_empty_line(gd, yy, bg); |
404 | |
405 | gd->hscrolled++; |
406 | grid_compact_line(&gd->linedata[gd->hsize]); |
407 | gd->linedata[gd->hsize].time = current_time; |
408 | gd->hsize++; |
409 | } |
410 | |
411 | |
412 | void |
413 | grid_clear_history(struct grid *gd) |
414 | { |
415 | grid_trim_history(gd, gd->hsize); |
416 | |
417 | gd->hscrolled = 0; |
418 | gd->hsize = 0; |
419 | |
420 | gd->linedata = xreallocarray(gd->linedata, gd->sy, |
421 | sizeof *gd->linedata); |
422 | } |
423 | |
424 | |
425 | void |
426 | grid_scroll_history_region(struct grid *gd, u_int upper, u_int lower, u_int bg) |
427 | { |
428 | struct grid_line *gl_history, *gl_upper; |
429 | u_int yy; |
430 | |
431 | |
432 | yy = gd->hsize + gd->sy; |
433 | gd->linedata = xreallocarray(gd->linedata, yy + 1, |
434 | sizeof *gd->linedata); |
435 | |
436 | |
437 | gl_history = &gd->linedata[gd->hsize]; |
438 | memmove(gl_history + 1, gl_history, gd->sy * sizeof *gl_history); |
439 | |
440 | |
441 | upper++; |
442 | gl_upper = &gd->linedata[upper]; |
443 | lower++; |
444 | |
445 | |
446 | memcpy(gl_history, gl_upper, sizeof *gl_history); |
447 | gl_history->time = current_time; |
448 | |
449 | |
450 | memmove(gl_upper, gl_upper + 1, (lower - upper) * sizeof *gl_upper); |
451 | grid_empty_line(gd, lower, bg); |
452 | |
453 | |
454 | gd->hscrolled++; |
455 | gd->hsize++; |
456 | } |
457 | |
458 | |
459 | static void |
460 | grid_expand_line(struct grid *gd, u_int py, u_int sx, u_int bg) |
461 | { |
462 | struct grid_line *gl; |
463 | u_int xx; |
464 | |
465 | gl = &gd->linedata[py]; |
466 | if (sx <= gl->cellsize) |
467 | return; |
468 | |
469 | if (sx < gd->sx / 4) |
470 | sx = gd->sx / 4; |
471 | else if (sx < gd->sx / 2) |
472 | sx = gd->sx / 2; |
473 | else if (gd->sx > sx) |
474 | sx = gd->sx; |
475 | |
476 | gl->celldata = xreallocarray(gl->celldata, sx, sizeof *gl->celldata); |
477 | for (xx = gl->cellsize; xx < sx; xx++) |
478 | grid_clear_cell(gd, xx, py, bg); |
479 | gl->cellsize = sx; |
480 | } |
481 | |
482 | |
483 | void |
484 | grid_empty_line(struct grid *gd, u_int py, u_int bg) |
485 | { |
486 | memset(&gd->linedata[py], 0, sizeof gd->linedata[py]); |
487 | if (!COLOUR_DEFAULT(bg)) |
488 | grid_expand_line(gd, py, gd->sx, bg); |
489 | } |
490 | |
491 | |
492 | const struct grid_line * |
493 | grid_peek_line(struct grid *gd, u_int py) |
494 | { |
495 | if (grid_check_y(gd, __func__, py) != 0) |
496 | return (NULL); |
497 | return (&gd->linedata[py]); |
498 | } |
499 | |
500 | |
501 | static void |
502 | grid_get_cell1(struct grid_line *gl, u_int px, struct grid_cell *gc) |
503 | { |
504 | struct grid_cell_entry *gce = &gl->celldata[px]; |
505 | struct grid_extd_entry *gee; |
506 | |
507 | if (gce->flags & GRID_FLAG_EXTENDED) { |
508 | if (gce->offset >= gl->extdsize) |
509 | memcpy(gc, &grid_default_cell, sizeof *gc); |
510 | else { |
511 | gee = &gl->extddata[gce->offset]; |
512 | gc->flags = gee->flags; |
513 | gc->attr = gee->attr; |
514 | gc->fg = gee->fg; |
515 | gc->bg = gee->bg; |
516 | gc->us = gee->us; |
517 | gc->link = gee->link; |
518 | utf8_to_data(gee->data, &gc->data); |
519 | } |
520 | return; |
521 | } |
522 | |
523 | gc->flags = gce->flags & ~(GRID_FLAG_FG256|GRID_FLAG_BG256); |
524 | gc->attr = gce->data.attr; |
525 | gc->fg = gce->data.fg; |
526 | if (gce->flags & GRID_FLAG_FG256) |
527 | gc->fg |= COLOUR_FLAG_256; |
528 | gc->bg = gce->data.bg; |
529 | if (gce->flags & GRID_FLAG_BG256) |
530 | gc->bg |= COLOUR_FLAG_256; |
531 | gc->us = 8; |
532 | utf8_set(&gc->data, gce->data.data); |
533 | gc->link = 0; |
534 | } |
535 | |
536 | |
537 | void |
538 | grid_get_cell(struct grid *gd, u_int px, u_int py, struct grid_cell *gc) |
539 | { |
540 | if (grid_check_y(gd, __func__, py) != 0 || |
541 | px >= gd->linedata[py].cellsize) |
542 | memcpy(gc, &grid_default_cell, sizeof *gc); |
543 | else |
544 | grid_get_cell1(&gd->linedata[py], px, gc); |
545 | } |
546 | |
547 | |
548 | void |
549 | grid_set_cell(struct grid *gd, u_int px, u_int py, const struct grid_cell *gc) |
550 | { |
551 | struct grid_line *gl; |
552 | struct grid_cell_entry *gce; |
553 | |
554 | if (grid_check_y(gd, __func__, py) != 0) |
555 | return; |
556 | |
557 | grid_expand_line(gd, py, px + 1, 8); |
558 | |
559 | gl = &gd->linedata[py]; |
560 | if (px + 1 > gl->cellused) |
561 | gl->cellused = px + 1; |
562 | |
563 | gce = &gl->celldata[px]; |
564 | if (grid_need_extended_cell(gce, gc)) |
565 | grid_extended_cell(gl, gce, gc); |
566 | else |
567 | grid_store_cell(gce, gc, gc->data.data[0]); |
568 | } |
569 | |
570 | |
571 | void |
572 | grid_set_padding(struct grid *gd, u_int px, u_int py) |
573 | { |
574 | grid_set_cell(gd, px, py, &grid_padding_cell); |
575 | } |
576 | |
577 | |
578 | void |
579 | grid_set_cells(struct grid *gd, u_int px, u_int py, const struct grid_cell *gc, |
580 | const char *s, size_t slen) |
581 | { |
582 | struct grid_line *gl; |
583 | struct grid_cell_entry *gce; |
584 | struct grid_extd_entry *gee; |
585 | u_int i; |
586 | |
587 | if (grid_check_y(gd, __func__, py) != 0) |
588 | return; |
589 | |
590 | grid_expand_line(gd, py, px + slen, 8); |
591 | |
592 | gl = &gd->linedata[py]; |
593 | if (px + slen > gl->cellused) |
594 | gl->cellused = px + slen; |
595 | |
596 | for (i = 0; i < slen; i++) { |
597 | gce = &gl->celldata[px + i]; |
598 | if (grid_need_extended_cell(gce, gc)) { |
599 | gee = grid_extended_cell(gl, gce, gc); |
600 | gee->data = utf8_build_one(s[i]); |
601 | } else |
602 | grid_store_cell(gce, gc, s[i]); |
603 | } |
604 | } |
605 | |
606 | |
607 | void |
608 | grid_clear(struct grid *gd, u_int px, u_int py, u_int nx, u_int ny, u_int bg) |
609 | { |
610 | struct grid_line *gl; |
611 | u_int xx, yy, ox, sx; |
612 | |
613 | if (nx == 0 || ny == 0) |
614 | return; |
615 | |
616 | if (px == 0 && nx == gd->sx) { |
617 | grid_clear_lines(gd, py, ny, bg); |
618 | return; |
619 | } |
620 | |
621 | if (grid_check_y(gd, __func__, py) != 0) |
622 | return; |
623 | if (grid_check_y(gd, __func__, py + ny - 1) != 0) |
624 | return; |
625 | |
626 | for (yy = py; yy < py + ny; yy++) { |
627 | gl = &gd->linedata[yy]; |
628 | |
629 | sx = gd->sx; |
630 | if (sx > gl->cellsize) |
631 | sx = gl->cellsize; |
632 | ox = nx; |
633 | if (COLOUR_DEFAULT(bg)) { |
634 | if (px > sx) |
635 | continue; |
636 | if (px + nx > sx) |
637 | ox = sx - px; |
638 | } |
639 | |
640 | grid_expand_line(gd, yy, px + ox, 8); |
641 | for (xx = px; xx < px + ox; xx++) |
642 | grid_clear_cell(gd, xx, yy, bg); |
643 | } |
644 | } |
645 | |
646 | |
647 | void |
648 | grid_clear_lines(struct grid *gd, u_int py, u_int ny, u_int bg) |
649 | { |
650 | u_int yy; |
651 | |
652 | if (ny == 0) |
653 | return; |
654 | |
655 | if (grid_check_y(gd, __func__, py) != 0) |
656 | return; |
657 | if (grid_check_y(gd, __func__, py + ny - 1) != 0) |
658 | return; |
659 | |
660 | for (yy = py; yy < py + ny; yy++) { |
661 | grid_free_line(gd, yy); |
662 | grid_empty_line(gd, yy, bg); |
663 | } |
664 | if (py != 0) |
665 | gd->linedata[py - 1].flags &= ~GRID_LINE_WRAPPED; |
666 | } |
667 | |
668 | |
669 | void |
670 | grid_move_lines(struct grid *gd, u_int dy, u_int py, u_int ny, u_int bg) |
671 | { |
672 | u_int yy; |
673 | |
674 | if (ny == 0 || py == dy) |
675 | return; |
676 | |
677 | if (grid_check_y(gd, __func__, py) != 0) |
678 | return; |
679 | if (grid_check_y(gd, __func__, py + ny - 1) != 0) |
680 | return; |
681 | if (grid_check_y(gd, __func__, dy) != 0) |
682 | return; |
683 | if (grid_check_y(gd, __func__, dy + ny - 1) != 0) |
684 | return; |
685 | |
686 | |
687 | for (yy = dy; yy < dy + ny; yy++) { |
688 | if (yy >= py && yy < py + ny) |
689 | continue; |
690 | grid_free_line(gd, yy); |
691 | } |
692 | if (dy != 0) |
693 | gd->linedata[dy - 1].flags &= ~GRID_LINE_WRAPPED; |
694 | |
695 | memmove(&gd->linedata[dy], &gd->linedata[py], |
696 | ny * (sizeof *gd->linedata)); |
697 | |
698 | |
699 | |
700 | |
701 | |
702 | for (yy = py; yy < py + ny; yy++) { |
703 | if (yy < dy || yy >= dy + ny) |
704 | grid_empty_line(gd, yy, bg); |
705 | } |
706 | if (py != 0 && (py < dy || py >= dy + ny)) |
707 | gd->linedata[py - 1].flags &= ~GRID_LINE_WRAPPED; |
708 | } |
709 | |
710 | |
711 | void |
712 | grid_move_cells(struct grid *gd, u_int dx, u_int px, u_int py, u_int nx, |
713 | u_int bg) |
714 | { |
715 | struct grid_line *gl; |
716 | u_int xx; |
717 | |
718 | if (nx == 0 || px == dx) |
719 | return; |
720 | |
721 | if (grid_check_y(gd, __func__, py) != 0) |
722 | return; |
723 | gl = &gd->linedata[py]; |
724 | |
725 | grid_expand_line(gd, py, px + nx, 8); |
726 | grid_expand_line(gd, py, dx + nx, 8); |
727 | memmove(&gl->celldata[dx], &gl->celldata[px], |
728 | nx * sizeof *gl->celldata); |
729 | if (dx + nx > gl->cellused) |
730 | gl->cellused = dx + nx; |
731 | |
732 | |
733 | for (xx = px; xx < px + nx; xx++) { |
734 | if (xx >= dx && xx < dx + nx) |
735 | continue; |
736 | grid_clear_cell(gd, xx, py, bg); |
737 | } |
738 | } |
739 | |
740 | |
741 | static size_t |
742 | grid_string_cells_fg(const struct grid_cell *gc, int *values) |
743 | { |
744 | size_t n; |
745 | u_char r, g, b; |
746 | |
747 | n = 0; |
748 | if (gc->fg & COLOUR_FLAG_256) { |
749 | values[n++] = 38; |
750 | values[n++] = 5; |
751 | values[n++] = gc->fg & 0xff; |
752 | } else if (gc->fg & COLOUR_FLAG_RGB) { |
753 | values[n++] = 38; |
754 | values[n++] = 2; |
755 | colour_split_rgb(gc->fg, &r, &g, &b); |
756 | values[n++] = r; |
757 | values[n++] = g; |
758 | values[n++] = b; |
759 | } else { |
760 | switch (gc->fg) { |
761 | case 0: |
762 | case 1: |
763 | case 2: |
764 | case 3: |
765 | case 4: |
766 | case 5: |
767 | case 6: |
768 | case 7: |
769 | values[n++] = gc->fg + 30; |
770 | break; |
771 | case 8: |
772 | values[n++] = 39; |
773 | break; |
774 | case 90: |
775 | case 91: |
776 | case 92: |
777 | case 93: |
778 | case 94: |
779 | case 95: |
780 | case 96: |
781 | case 97: |
782 | values[n++] = gc->fg; |
783 | break; |
784 | } |
785 | } |
786 | return (n); |
787 | } |
788 | |
789 | |
790 | static size_t |
791 | grid_string_cells_bg(const struct grid_cell *gc, int *values) |
792 | { |
793 | size_t n; |
794 | u_char r, g, b; |
795 | |
796 | n = 0; |
797 | if (gc->bg & COLOUR_FLAG_256) { |
798 | values[n++] = 48; |
799 | values[n++] = 5; |
800 | values[n++] = gc->bg & 0xff; |
801 | } else if (gc->bg & COLOUR_FLAG_RGB) { |
802 | values[n++] = 48; |
803 | values[n++] = 2; |
804 | colour_split_rgb(gc->bg, &r, &g, &b); |
805 | values[n++] = r; |
806 | values[n++] = g; |
807 | values[n++] = b; |
808 | } else { |
809 | switch (gc->bg) { |
810 | case 0: |
811 | case 1: |
812 | case 2: |
813 | case 3: |
814 | case 4: |
815 | case 5: |
816 | case 6: |
817 | case 7: |
818 | values[n++] = gc->bg + 40; |
819 | break; |
820 | case 8: |
821 | values[n++] = 49; |
822 | break; |
823 | case 90: |
824 | case 91: |
825 | case 92: |
826 | case 93: |
827 | case 94: |
828 | case 95: |
829 | case 96: |
830 | case 97: |
831 | values[n++] = gc->bg + 10; |
832 | break; |
833 | } |
834 | } |
835 | return (n); |
836 | } |
837 | |
838 | |
839 | static size_t |
840 | grid_string_cells_us(const struct grid_cell *gc, int *values) |
841 | { |
842 | size_t n; |
843 | u_char r, g, b; |
844 | |
845 | n = 0; |
846 | if (gc->us & COLOUR_FLAG_256) { |
847 | values[n++] = 58; |
848 | values[n++] = 5; |
849 | values[n++] = gc->us & 0xff; |
850 | } else if (gc->us & COLOUR_FLAG_RGB) { |
851 | values[n++] = 58; |
852 | values[n++] = 2; |
853 | colour_split_rgb(gc->us, &r, &g, &b); |
854 | values[n++] = r; |
855 | values[n++] = g; |
856 | values[n++] = b; |
857 | } |
858 | return (n); |
859 | } |
860 | |
861 | |
862 | static void |
863 | grid_string_cells_add_code(char *buf, size_t len, u_int n, int *s, int *newc, |
864 | int *oldc, size_t nnewc, size_t noldc, int flags) |
865 | { |
866 | u_int i; |
867 | char tmp[64]; |
868 | int reset = (n != 0 && s[0] == 0); |
869 | |
870 | if (nnewc == 0) |
871 | return; |
872 | if (!reset && |
873 | nnewc == noldc && |
874 | memcmp(newc, oldc, nnewc * sizeof newc[0]) == 0) |
875 | return; |
876 | if (reset && (newc[0] == 49 || newc[0] == 39)) |
877 | return; |
878 | |
879 | if (flags & GRID_STRING_ESCAPE_SEQUENCES) |
880 | strlcat(buf, "\\033[", len); |
881 | else |
882 | strlcat(buf, "\033[", len); |
883 | for (i = 0; i < nnewc; i++) { |
884 | if (i + 1 < nnewc) |
885 | xsnprintf(tmp, sizeof tmp, "%d;", newc[i]); |
886 | else |
887 | xsnprintf(tmp, sizeof tmp, "%d", newc[i]); |
888 | strlcat(buf, tmp, len); |
889 | } |
890 | strlcat(buf, "m", len); |
891 | } |
892 | |
893 | static int |
894 | grid_string_cells_add_hyperlink(char *buf, size_t len, const char *id, |
895 | const char *uri, int flags) |
896 | { |
897 | char *tmp; |
898 | |
899 | if (strlen(uri) + strlen(id) + 17 >= len) |
900 | return (0); |
901 | |
902 | if (flags & GRID_STRING_ESCAPE_SEQUENCES) |
903 | strlcat(buf, "\\033]8;", len); |
904 | else |
905 | strlcat(buf, "\033]8;", len); |
906 | if (*id != '\0') { |
907 | xasprintf(&tmp, "id=%s;", id); |
908 | strlcat(buf, tmp, len); |
909 | free(tmp); |
910 | } else |
911 | strlcat(buf, ";", len); |
912 | strlcat(buf, uri, len); |
913 | if (flags & GRID_STRING_ESCAPE_SEQUENCES) |
914 | strlcat(buf, "\\033\\\\", len); |
915 | else |
916 | strlcat(buf, "\033\\", len); |
917 | return (1); |
918 | } |
919 | |
920 | |
921 | |
922 | |
923 | |
924 | static void |
925 | grid_string_cells_code(const struct grid_cell *lastgc, |
926 | const struct grid_cell *gc, char *buf, size_t len, int flags, |
927 | struct screen *sc, int *has_link) |
928 | { |
929 | int oldc[64], newc[64], s[128]; |
930 | size_t noldc, nnewc, n, i; |
931 | u_int attr = gc->attr, lastattr = lastgc->attr; |
932 | char tmp[64]; |
933 | const char *uri, *id; |
934 | |
935 | static const struct { |
936 | u_int mask; |
937 | u_int code; |
938 | } attrs[] = { |
939 | { GRID_ATTR_BRIGHT, 1 }, |
940 | { GRID_ATTR_DIM, 2 }, |
941 | { GRID_ATTR_ITALICS, 3 }, |
942 | { GRID_ATTR_UNDERSCORE, 4 }, |
943 | { GRID_ATTR_BLINK, 5 }, |
944 | { GRID_ATTR_REVERSE, 7 }, |
945 | { GRID_ATTR_HIDDEN, 8 }, |
946 | { GRID_ATTR_STRIKETHROUGH, 9 }, |
947 | { GRID_ATTR_UNDERSCORE_2, 42 }, |
948 | { GRID_ATTR_UNDERSCORE_3, 43 }, |
949 | { GRID_ATTR_UNDERSCORE_4, 44 }, |
950 | { GRID_ATTR_UNDERSCORE_5, 45 }, |
951 | { GRID_ATTR_OVERLINE, 53 }, |
952 | }; |
953 | n = 0; |
954 | |
955 | |
956 | for (i = 0; i < nitems(attrs); i++) { |
957 | if (((~attr & attrs[i].mask) && |
958 | (lastattr & attrs[i].mask)) || |
959 | (lastgc->us != 8 && gc->us == 8)) { |
960 | s[n++] = 0; |
961 | lastattr &= GRID_ATTR_CHARSET; |
962 | break; |
963 | } |
964 | } |
965 | |
966 | for (i = 0; i < nitems(attrs); i++) { |
967 | if ((attr & attrs[i].mask) && !(lastattr & attrs[i].mask)) |
968 | s[n++] = attrs[i].code; |
969 | } |
970 | |
971 | |
972 | *buf = '\0'; |
973 | if (n > 0) { |
974 | if (flags & GRID_STRING_ESCAPE_SEQUENCES) |
975 | strlcat(buf, "\\033[", len); |
976 | else |
977 | strlcat(buf, "\033[", len); |
978 | for (i = 0; i < n; i++) { |
979 | if (s[i] < 10) |
980 | xsnprintf(tmp, sizeof tmp, "%d", s[i]); |
981 | else { |
982 | xsnprintf(tmp, sizeof tmp, "%d:%d", s[i] / 10, |
983 | s[i] % 10); |
984 | } |
985 | strlcat(buf, tmp, len); |
986 | if (i + 1 < n) |
987 | strlcat(buf, ";", len); |
988 | } |
989 | strlcat(buf, "m", len); |
990 | } |
991 | |
992 | |
993 | nnewc = grid_string_cells_fg(gc, newc); |
994 | noldc = grid_string_cells_fg(lastgc, oldc); |
995 | grid_string_cells_add_code(buf, len, n, s, newc, oldc, nnewc, noldc, |
996 | flags); |
997 | |
998 | |
999 | nnewc = grid_string_cells_bg(gc, newc); |
1000 | noldc = grid_string_cells_bg(lastgc, oldc); |
1001 | grid_string_cells_add_code(buf, len, n, s, newc, oldc, nnewc, noldc, |
1002 | flags); |
1003 | |
1004 | |
1005 | nnewc = grid_string_cells_us(gc, newc); |
1006 | noldc = grid_string_cells_us(lastgc, oldc); |
1007 | grid_string_cells_add_code(buf, len, n, s, newc, oldc, nnewc, noldc, |
1008 | flags); |
1009 | |
1010 | |
1011 | if ((attr & GRID_ATTR_CHARSET) && !(lastattr & GRID_ATTR_CHARSET)) { |
1012 | if (flags & GRID_STRING_ESCAPE_SEQUENCES) |
1013 | strlcat(buf, "\\016", len); |
1014 | else |
1015 | strlcat(buf, "\016", len); |
1016 | } |
1017 | if (!(attr & GRID_ATTR_CHARSET) && (lastattr & GRID_ATTR_CHARSET)) { |
1018 | if (flags & GRID_STRING_ESCAPE_SEQUENCES) |
1019 | strlcat(buf, "\\017", len); |
1020 | else |
1021 | strlcat(buf, "\017", len); |
1022 | } |
1023 | |
1024 | |
1025 | if (sc != NULL && sc->hyperlinks != NULL && lastgc->link != gc->link) { |
1026 | if (hyperlinks_get(sc->hyperlinks, gc->link, &uri, &id, NULL)) { |
1027 | *has_link = grid_string_cells_add_hyperlink(buf, len, |
1028 | id, uri, flags); |
1029 | } else if (*has_link) { |
1030 | grid_string_cells_add_hyperlink(buf, len, "", "", |
1031 | flags); |
1032 | *has_link = 0; |
1033 | } |
1034 | } |
1035 | } |
1036 | |
1037 | |
1038 | char * |
1039 | grid_string_cells(struct grid *gd, u_int px, u_int py, u_int nx, |
1040 | struct grid_cell **lastgc, int flags, struct screen *s) |
1041 | { |
1042 | struct grid_cell gc; |
1043 | static struct grid_cell lastgc1; |
1044 | const char *data; |
1045 | char *buf, code[8192]; |
1046 | size_t len, off, size, codelen; |
1047 | u_int xx, end; |
1048 | int has_link = 0; |
1049 | const struct grid_line *gl; |
1050 | |
1051 | if (lastgc != NULL && *lastgc == NULL) { |
1052 | memcpy(&lastgc1, &grid_default_cell, sizeof lastgc1); |
1053 | *lastgc = &lastgc1; |
1054 | } |
1055 | |
1056 | len = 128; |
1057 | buf = xmalloc(len); |
1058 | off = 0; |
1059 | |
1060 | gl = grid_peek_line(gd, py); |
1061 | if (flags & GRID_STRING_EMPTY_CELLS) |
1062 | end = gl->cellsize; |
1063 | else |
1064 | end = gl->cellused; |
1065 | for (xx = px; xx < px + nx; xx++) { |
1066 | if (gl == NULL || xx >= end) |
1067 | break; |
1068 | grid_get_cell(gd, xx, py, &gc); |
1069 | if (gc.flags & GRID_FLAG_PADDING) |
1070 | continue; |
1071 | |
1072 | if (flags & GRID_STRING_WITH_SEQUENCES) { |
1073 | grid_string_cells_code(*lastgc, &gc, code, sizeof code, |
1074 | flags, s, &has_link); |
1075 | codelen = strlen(code); |
1076 | memcpy(*lastgc, &gc, sizeof **lastgc); |
1077 | } else |
1078 | codelen = 0; |
1079 | |
1080 | data = gc.data.data; |
1081 | size = gc.data.size; |
1082 | if ((flags & GRID_STRING_ESCAPE_SEQUENCES) && |
1083 | size == 1 && |
1084 | *data == '\\') { |
1085 | data = "\\\\"; |
1086 | size = 2; |
1087 | } |
1088 | |
1089 | while (len < off + size + codelen + 1) { |
1090 | buf = xreallocarray(buf, 2, len); |
1091 | len *= 2; |
1092 | } |
1093 | |
1094 | if (codelen != 0) { |
1095 | memcpy(buf + off, code, codelen); |
1096 | off += codelen; |
1097 | } |
1098 | memcpy(buf + off, data, size); |
1099 | off += size; |
1100 | } |
1101 | |
1102 | if (has_link) { |
1103 | grid_string_cells_add_hyperlink(code, sizeof code, "", "", |
1104 | flags); |
1105 | codelen = strlen(code); |
1106 | while (len < off + size + codelen + 1) { |
1107 | buf = xreallocarray(buf, 2, len); |
1108 | len *= 2; |
1109 | } |
1110 | memcpy(buf + off, code, codelen); |
1111 | off += codelen; |
1112 | } |
1113 | |
1114 | if (flags & GRID_STRING_TRIM_SPACES) { |
1115 | while (off > 0 && buf[off - 1] == ' ') |
1116 | off--; |
1117 | } |
1118 | buf[off] = '\0'; |
1119 | |
1120 | return (buf); |
1121 | } |
1122 | |
1123 | |
1124 | |
1125 | |
1126 | |
1127 | void |
1128 | grid_duplicate_lines(struct grid *dst, u_int dy, struct grid *src, u_int sy, |
1129 | u_int ny) |
1130 | { |
1131 | struct grid_line *dstl, *srcl; |
1132 | u_int yy; |
1133 | |
1134 | if (dy + ny > dst->hsize + dst->sy) |
1135 | ny = dst->hsize + dst->sy - dy; |
1136 | if (sy + ny > src->hsize + src->sy) |
1137 | ny = src->hsize + src->sy - sy; |
1138 | grid_free_lines(dst, dy, ny); |
1139 | |
1140 | for (yy = 0; yy < ny; yy++) { |
1141 | srcl = &src->linedata[sy]; |
1142 | dstl = &dst->linedata[dy]; |
1143 | |
1144 | memcpy(dstl, srcl, sizeof *dstl); |
1145 | if (srcl->cellsize != 0) { |
1146 | dstl->celldata = xreallocarray(NULL, |
1147 | srcl->cellsize, sizeof *dstl->celldata); |
1148 | memcpy(dstl->celldata, srcl->celldata, |
1149 | srcl->cellsize * sizeof *dstl->celldata); |
1150 | } else |
1151 | dstl->celldata = NULL; |
1152 | if (srcl->extdsize != 0) { |
1153 | dstl->extdsize = srcl->extdsize; |
1154 | dstl->extddata = xreallocarray(NULL, dstl->extdsize, |
1155 | sizeof *dstl->extddata); |
1156 | memcpy(dstl->extddata, srcl->extddata, dstl->extdsize * |
1157 | sizeof *dstl->extddata); |
1158 | } else |
1159 | dstl->extddata = NULL; |
1160 | |
1161 | sy++; |
1162 | dy++; |
1163 | } |
1164 | } |
1165 | |
1166 | |
1167 | static void |
1168 | grid_reflow_dead(struct grid_line *gl) |
1169 | { |
1170 | memset(gl, 0, sizeof *gl); |
1171 | gl->flags = GRID_LINE_DEAD; |
1172 | } |
1173 | |
1174 | |
1175 | static struct grid_line * |
1176 | grid_reflow_add(struct grid *gd, u_int n) |
1177 | { |
1178 | struct grid_line *gl; |
1179 | u_int sy = gd->sy + n; |
1180 | |
1181 | gd->linedata = xreallocarray(gd->linedata, sy, sizeof *gd->linedata); |
1182 | gl = &gd->linedata[gd->sy]; |
1183 | memset(gl, 0, n * (sizeof *gl)); |
1184 | gd->sy = sy; |
1185 | return (gl); |
1186 | } |
1187 | |
1188 | |
1189 | static struct grid_line * |
1190 | grid_reflow_move(struct grid *gd, struct grid_line *from) |
1191 | { |
1192 | struct grid_line *to; |
1193 | |
1194 | to = grid_reflow_add(gd, 1); |
1195 | memcpy(to, from, sizeof *to); |
1196 | grid_reflow_dead(from); |
1197 | return (to); |
1198 | } |
1199 | |
1200 | |
1201 | static void |
1202 | grid_reflow_join(struct grid *target, struct grid *gd, u_int sx, u_int yy, |
1203 | u_int width, int already) |
1204 | { |
1205 | struct grid_line *gl, *from = NULL; |
1206 | struct grid_cell gc; |
1207 | u_int lines, left, i, to, line, want = 0; |
1208 | u_int at; |
1209 | int wrapped = 1; |
1210 | |
1211 | |
1212 | |
1213 | |
1214 | if (!already) { |
1215 | to = target->sy; |
1216 | gl = grid_reflow_move(target, &gd->linedata[yy]); |
1217 | } else { |
1218 | to = target->sy - 1; |
1219 | gl = &target->linedata[to]; |
1220 | } |
1221 | at = gl->cellused; |
1222 | |
1223 | |
1224 | |
1225 | |
1226 | lines = 0; |
1227 | for (;;) { |
1228 | |
1229 | |
1230 | |
1231 | |
1232 | if (yy + 1 + lines == gd->hsize + gd->sy) |
1233 | break; |
1234 | line = yy + 1 + lines; |
1235 | |
1236 | |
1237 | if (~gd->linedata[line].flags & GRID_LINE_WRAPPED) |
1238 | wrapped = 0; |
1239 | if (gd->linedata[line].cellused == 0) { |
1240 | if (!wrapped) |
1241 | break; |
1242 | lines++; |
1243 | continue; |
1244 | } |
1245 | |
1246 | |
1247 | |
1248 | |
1249 | |
1250 | |
1251 | grid_get_cell1(&gd->linedata[line], 0, &gc); |
1252 | if (width + gc.data.width > sx) |
1253 | break; |
1254 | width += gc.data.width; |
1255 | grid_set_cell(target, at, to, &gc); |
1256 | at++; |
1257 | |
1258 | |
1259 | from = &gd->linedata[line]; |
1260 | for (want = 1; want < from->cellused; want++) { |
1261 | grid_get_cell1(from, want, &gc); |
1262 | if (width + gc.data.width > sx) |
1263 | break; |
1264 | width += gc.data.width; |
1265 | |
1266 | grid_set_cell(target, at, to, &gc); |
1267 | at++; |
1268 | } |
1269 | lines++; |
1270 | |
1271 | |
1272 | |
1273 | |
1274 | |
1275 | if (!wrapped || want != from->cellused || width == sx) |
1276 | break; |
1277 | } |
1278 | if (lines == 0) |
1279 | return; |
1280 | |
1281 | |
1282 | |
1283 | |
1284 | |
1285 | |
1286 | left = from->cellused - want; |
1287 | if (left != 0) { |
1288 | grid_move_cells(gd, 0, want, yy + lines, left, 8); |
1289 | from->cellsize = from->cellused = left; |
1290 | lines--; |
1291 | } else if (!wrapped) |
1292 | gl->flags &= ~GRID_LINE_WRAPPED; |
1293 | |
1294 | |
1295 | for (i = yy + 1; i < yy + 1 + lines; i++) { |
1296 | free(gd->linedata[i].celldata); |
1297 | free(gd->linedata[i].extddata); |
1298 | grid_reflow_dead(&gd->linedata[i]); |
1299 | } |
1300 | |
1301 | |
1302 | if (gd->hscrolled > to + lines) |
1303 | gd->hscrolled -= lines; |
1304 | else if (gd->hscrolled > to) |
1305 | gd->hscrolled = to; |
1306 | } |
1307 | |
1308 | |
1309 | static void |
1310 | grid_reflow_split(struct grid *target, struct grid *gd, u_int sx, u_int yy, |
1311 | u_int at) |
1312 | { |
1313 | struct grid_line *gl = &gd->linedata[yy], *first; |
1314 | struct grid_cell gc; |
1315 | u_int line, lines, width, i, xx; |
1316 | u_int used = gl->cellused; |
1317 | int flags = gl->flags; |
1318 | |
1319 | |
1320 | if (~gl->flags & GRID_LINE_EXTENDED) |
| |
1321 | lines = 1 + (gl->cellused - 1) / sx; |
| |
1322 | else { |
1323 | lines = 2; |
1324 | width = 0; |
1325 | for (i = at; i < used; i++) { |
1326 | grid_get_cell1(gl, i, &gc); |
1327 | if (width + gc.data.width > sx) { |
1328 | lines++; |
1329 | width = 0; |
1330 | } |
1331 | width += gc.data.width; |
1332 | } |
1333 | } |
1334 | |
1335 | |
1336 | line = target->sy + 1; |
1337 | first = grid_reflow_add(target, lines); |
1338 | |
1339 | |
1340 | width = 0; |
1341 | xx = 0; |
1342 | for (i = at; i < used; i++) { |
1343 | grid_get_cell1(gl, i, &gc); |
1344 | if (width + gc.data.width > sx) { |
1345 | target->linedata[line].flags |= GRID_LINE_WRAPPED; |
1346 | |
1347 | line++; |
1348 | width = 0; |
1349 | xx = 0; |
1350 | } |
1351 | width += gc.data.width; |
1352 | grid_set_cell(target, xx, line, &gc); |
1353 | xx++; |
1354 | } |
1355 | if (flags & GRID_LINE_WRAPPED) |
1356 | target->linedata[line].flags |= GRID_LINE_WRAPPED; |
1357 | |
1358 | |
1359 | gl->cellsize = gl->cellused = at; |
1360 | gl->flags |= GRID_LINE_WRAPPED; |
1361 | memcpy(first, gl, sizeof *first); |
1362 | grid_reflow_dead(gl); |
1363 | |
1364 | |
1365 | if (yy <= gd->hscrolled) |
1366 | gd->hscrolled += lines - 1; |
1367 | |
1368 | |
1369 | |
1370 | |
1371 | |
1372 | if (width < sx && (flags & GRID_LINE_WRAPPED)) |
1373 | grid_reflow_join(target, gd, sx, yy, width, 1); |
1374 | } |
1375 | |
1376 | |
1377 | void |
1378 | grid_reflow(struct grid *gd, u_int sx) |
1379 | { |
1380 | struct grid *target; |
1381 | struct grid_line *gl; |
1382 | struct grid_cell gc; |
1383 | u_int yy, width, i, at; |
1384 | |
1385 | |
1386 | |
1387 | |
1388 | |
1389 | target = grid_create(gd->sx, 0, 0); |
1390 | |
1391 | |
1392 | |
1393 | |
1394 | for (yy = 0; yy < gd->hsize + gd->sy; yy++) { |
| 1 | Assuming the condition is true | |
|
| 2 | | Loop condition is true. Entering loop body | |
|
| 12 | | Assuming the condition is true | |
|
| 13 | | Loop condition is true. Entering loop body | |
|
1395 | gl = &gd->linedata[yy]; |
1396 | if (gl->flags & GRID_LINE_DEAD) |
| 3 | | Assuming the condition is false | |
|
| |
| 14 | | Assuming the condition is false | |
|
| |
1397 | continue; |
1398 | |
1399 | |
1400 | |
1401 | |
1402 | |
1403 | |
1404 | at = width = 0; |
1405 | if (~gl->flags & GRID_LINE_EXTENDED) { |
| 5 | | Assuming the condition is false | |
|
| |
| 16 | | Assuming the condition is true | |
|
| |
1406 | width = gl->cellused; |
1407 | if (width > sx) |
| 18 | | Assuming 'width' is > 'sx' | |
|
| |
1408 | at = sx; |
1409 | else |
1410 | at = width; |
1411 | } else { |
1412 | for (i = 0; i < gl->cellused; i++) { |
| 7 | | Assuming 'i' is >= field 'cellused' | |
|
| 8 | | Loop condition is false. Execution continues on line 1424 | |
|
1413 | grid_get_cell1(gl, i, &gc); |
1414 | if (at == 0 && width + gc.data.width > sx) |
1415 | at = i; |
1416 | width += gc.data.width; |
1417 | } |
1418 | } |
1419 | |
1420 | |
1421 | |
1422 | |
1423 | |
1424 | if (width == sx) { |
| 9 | | Assuming 'width' is equal to 'sx' | |
|
| |
| |
1425 | grid_reflow_move(target, gl); |
1426 | continue; |
| 11 | | Execution continues on line 1394 | |
|
1427 | } |
1428 | |
1429 | |
1430 | |
1431 | |
1432 | |
1433 | if (width > sx) { |
| |
1434 | grid_reflow_split(target, gd, sx, yy, at); |
| 22 | | Passing the value 0 via 3rd parameter 'sx' | |
|
| 23 | | Calling 'grid_reflow_split' | |
|
1435 | continue; |
1436 | } |
1437 | |
1438 | |
1439 | |
1440 | |
1441 | |
1442 | if (gl->flags & GRID_LINE_WRAPPED) |
1443 | grid_reflow_join(target, gd, sx, yy, width, 0); |
1444 | else |
1445 | grid_reflow_move(target, gl); |
1446 | } |
1447 | |
1448 | |
1449 | |
1450 | |
1451 | if (target->sy < gd->sy) |
1452 | grid_reflow_add(target, gd->sy - target->sy); |
1453 | gd->hsize = target->sy - gd->sy; |
1454 | if (gd->hscrolled > gd->hsize) |
1455 | gd->hscrolled = gd->hsize; |
1456 | free(gd->linedata); |
1457 | gd->linedata = target->linedata; |
1458 | free(target); |
1459 | } |
1460 | |
1461 | |
1462 | void |
1463 | grid_wrap_position(struct grid *gd, u_int px, u_int py, u_int *wx, u_int *wy) |
1464 | { |
1465 | u_int ax = 0, ay = 0, yy; |
1466 | |
1467 | for (yy = 0; yy < py; yy++) { |
1468 | if (gd->linedata[yy].flags & GRID_LINE_WRAPPED) |
1469 | ax += gd->linedata[yy].cellused; |
1470 | else { |
1471 | ax = 0; |
1472 | ay++; |
1473 | } |
1474 | } |
1475 | if (px >= gd->linedata[yy].cellused) |
1476 | ax = UINT_MAX; |
1477 | else |
1478 | ax += px; |
1479 | *wx = ax; |
1480 | *wy = ay; |
1481 | } |
1482 | |
1483 | |
1484 | void |
1485 | grid_unwrap_position(struct grid *gd, u_int *px, u_int *py, u_int wx, u_int wy) |
1486 | { |
1487 | u_int yy, ay = 0; |
1488 | |
1489 | for (yy = 0; yy < gd->hsize + gd->sy - 1; yy++) { |
1490 | if (ay == wy) |
1491 | break; |
1492 | if (~gd->linedata[yy].flags & GRID_LINE_WRAPPED) |
1493 | ay++; |
1494 | } |
1495 | |
1496 | |
1497 | |
1498 | |
1499 | |
1500 | if (wx == UINT_MAX) { |
1501 | while (gd->linedata[yy].flags & GRID_LINE_WRAPPED) |
1502 | yy++; |
1503 | wx = gd->linedata[yy].cellused; |
1504 | } else { |
1505 | while (gd->linedata[yy].flags & GRID_LINE_WRAPPED) { |
1506 | if (wx < gd->linedata[yy].cellused) |
1507 | break; |
1508 | wx -= gd->linedata[yy].cellused; |
1509 | yy++; |
1510 | } |
1511 | } |
1512 | *px = wx; |
1513 | *py = yy; |
1514 | } |
1515 | |
1516 | |
1517 | u_int |
1518 | grid_line_length(struct grid *gd, u_int py) |
1519 | { |
1520 | struct grid_cell gc; |
1521 | u_int px; |
1522 | |
1523 | px = grid_get_line(gd, py)->cellsize; |
1524 | if (px > gd->sx) |
1525 | px = gd->sx; |
1526 | while (px > 0) { |
1527 | grid_get_cell(gd, px - 1, py, &gc); |
1528 | if ((gc.flags & GRID_FLAG_PADDING) || |
1529 | gc.data.size != 1 || |
1530 | *gc.data.data != ' ') |
1531 | break; |
1532 | px--; |
1533 | } |
1534 | return (px); |
1535 | } |