| File: | src/usr.bin/vi/build/../vi/vs_split.c |
| Warning: | line 465, column 2 Value stored to 'gp' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | /* $OpenBSD: vs_split.c,v 1.16 2016/05/27 09:18:12 martijn Exp $ */ |
| 2 | |
| 3 | /*- |
| 4 | * Copyright (c) 1993, 1994 |
| 5 | * The Regents of the University of California. All rights reserved. |
| 6 | * Copyright (c) 1993, 1994, 1995, 1996 |
| 7 | * Keith Bostic. All rights reserved. |
| 8 | * |
| 9 | * See the LICENSE file for redistribution information. |
| 10 | */ |
| 11 | |
| 12 | #include "config.h" |
| 13 | |
| 14 | #include <sys/types.h> |
| 15 | #include <sys/queue.h> |
| 16 | #include <sys/time.h> |
| 17 | |
| 18 | #include <bitstring.h> |
| 19 | #include <errno(*__errno()).h> |
| 20 | #include <limits.h> |
| 21 | #include <stdio.h> |
| 22 | #include <stdlib.h> |
| 23 | #include <string.h> |
| 24 | |
| 25 | #include "../common/common.h" |
| 26 | #include "vi.h" |
| 27 | |
| 28 | static SCR *vs_getbg(SCR *, char *); |
| 29 | |
| 30 | /* |
| 31 | * vs_split -- |
| 32 | * Create a new screen. |
| 33 | * |
| 34 | * PUBLIC: int vs_split(SCR *, SCR *, int); |
| 35 | */ |
| 36 | int |
| 37 | vs_split(SCR *sp, SCR *new, int ccl) |
| 38 | { |
| 39 | GS *gp; |
| 40 | SMAP *smp; |
| 41 | size_t half; |
| 42 | int issmallscreen, splitup; |
| 43 | |
| 44 | gp = sp->gp; |
| 45 | |
| 46 | /* Check to see if it's possible. */ |
| 47 | /* XXX: The IS_ONELINE fix will change this, too. */ |
| 48 | if (sp->rows < 4) { |
| 49 | msgq(sp, M_ERR, |
| 50 | "Screen must be larger than %d lines to split", 4 - 1); |
| 51 | return (1); |
| 52 | } |
| 53 | |
| 54 | /* Wait for any messages in the screen. */ |
| 55 | vs_resolve(sp, NULL((void *)0), 1); |
| 56 | |
| 57 | half = sp->rows / 2; |
| 58 | if (ccl && half > 6) |
| 59 | half = 6; |
| 60 | |
| 61 | /* Get a new screen map. */ |
| 62 | CALLOC(sp, _HMAP(new), SIZE_HMAP(sp), sizeof(SMAP)){ if ((((((VI_PRIVATE *)((new)->vi_private))->h_smap)) = calloc(((((VI_PRIVATE *)((sp)->vi_private))->srows + 1 )), (sizeof(SMAP)))) == ((void *)0)) msgq((sp), M_SYSERR, ((void *)0)); }; |
| 63 | if (_HMAP(new)(((VI_PRIVATE *)((new)->vi_private))->h_smap) == NULL((void *)0)) |
| 64 | return (1); |
| 65 | _HMAP(new)(((VI_PRIVATE *)((new)->vi_private))->h_smap)->lno = sp->lno; |
| 66 | _HMAP(new)(((VI_PRIVATE *)((new)->vi_private))->h_smap)->coff = 0; |
| 67 | _HMAP(new)(((VI_PRIVATE *)((new)->vi_private))->h_smap)->soff = 1; |
| 68 | |
| 69 | /* |
| 70 | * Small screens: see vs_refresh.c section 6a. Set a flag so |
| 71 | * we know to fix the screen up later. |
| 72 | */ |
| 73 | issmallscreen = IS_SMALL(sp)((sp)->t_minrows != (sp)->t_maxrows); |
| 74 | |
| 75 | /* The columns in the screen don't change. */ |
| 76 | new->cols = sp->cols; |
| 77 | |
| 78 | /* |
| 79 | * Split the screen, and link the screens together. If creating a |
| 80 | * screen to edit the colon command line or the cursor is in the top |
| 81 | * half of the current screen, the new screen goes under the current |
| 82 | * screen. Else, it goes above the current screen. |
| 83 | * |
| 84 | * Recalculate current cursor position based on sp->lno, we're called |
| 85 | * with the cursor on the colon command line. Then split the screen |
| 86 | * in half and update the shared information. |
| 87 | */ |
| 88 | splitup = |
| 89 | !ccl && (vs_sm_cursor(sp, &smp) ? 0 : (smp - HMAP(((VI_PRIVATE *)((sp)->vi_private))->h_smap)) + 1) >= half; |
| 90 | if (splitup) { /* Old is bottom half. */ |
| 91 | new->rows = sp->rows - half; /* New. */ |
| 92 | new->woff = sp->woff; |
| 93 | sp->rows = half; /* Old. */ |
| 94 | sp->woff += new->rows; |
| 95 | /* Link in before old. */ |
| 96 | TAILQ_INSERT_BEFORE(sp, new, q)do { (new)->q.tqe_prev = (sp)->q.tqe_prev; (new)->q. tqe_next = (sp); *(sp)->q.tqe_prev = (new); (sp)->q.tqe_prev = &(new)->q.tqe_next; } while (0); |
| 97 | |
| 98 | /* |
| 99 | * If the parent is the bottom half of the screen, shift |
| 100 | * the map down to match on-screen text. |
| 101 | */ |
| 102 | memmove(_HMAP(sp)(((VI_PRIVATE *)((sp)->vi_private))->h_smap), _HMAP(sp)(((VI_PRIVATE *)((sp)->vi_private))->h_smap) + new->rows, |
| 103 | (sp->t_maxrows - new->rows) * sizeof(SMAP)); |
| 104 | } else { /* Old is top half. */ |
| 105 | new->rows = half; /* New. */ |
| 106 | sp->rows -= half; /* Old. */ |
| 107 | new->woff = sp->woff + sp->rows; |
| 108 | /* Link in after old. */ |
| 109 | TAILQ_INSERT_AFTER(&gp->dq, sp, new, q)do { if (((new)->q.tqe_next = (sp)->q.tqe_next) != ((void *)0)) (new)->q.tqe_next->q.tqe_prev = &(new)->q .tqe_next; else (&gp->dq)->tqh_last = &(new)-> q.tqe_next; (sp)->q.tqe_next = (new); (new)->q.tqe_prev = &(sp)->q.tqe_next; } while (0); |
| 110 | } |
| 111 | |
| 112 | /* Adjust maximum text count. */ |
| 113 | sp->t_maxrows = IS_ONELINE(sp)((sp)->rows == 1) ? 1 : sp->rows - 1; |
| 114 | new->t_maxrows = IS_ONELINE(new)((new)->rows == 1) ? 1 : new->rows - 1; |
| 115 | |
| 116 | /* |
| 117 | * Small screens: see vs_refresh.c, section 6a. |
| 118 | * |
| 119 | * The child may have different screen options sizes than the parent, |
| 120 | * so use them. Guarantee that text counts aren't larger than the |
| 121 | * new screen sizes. |
| 122 | */ |
| 123 | if (issmallscreen) { |
| 124 | /* Fix the text line count for the parent. */ |
| 125 | if (splitup) |
| 126 | sp->t_rows -= new->rows; |
| 127 | |
| 128 | /* Fix the parent screen. */ |
| 129 | if (sp->t_rows > sp->t_maxrows) |
| 130 | sp->t_rows = sp->t_maxrows; |
| 131 | if (sp->t_minrows > sp->t_maxrows) |
| 132 | sp->t_minrows = sp->t_maxrows; |
| 133 | |
| 134 | /* Fix the child screen. */ |
| 135 | new->t_minrows = new->t_rows = O_VAL(sp, O_WINDOW)((((&((sp))->opts[((O_WINDOW))])->flags) & ((0x01 ))) ? ((sp))->gp->opts[((sp))->opts[((O_WINDOW))].o_cur .val].o_cur.val : ((sp))->opts[((O_WINDOW))].o_cur.val); |
| 136 | if (new->t_rows > new->t_maxrows) |
| 137 | new->t_rows = new->t_maxrows; |
| 138 | if (new->t_minrows > new->t_maxrows) |
| 139 | new->t_minrows = new->t_maxrows; |
| 140 | } else { |
| 141 | sp->t_minrows = sp->t_rows = IS_ONELINE(sp)((sp)->rows == 1) ? 1 : sp->rows - 1; |
| 142 | |
| 143 | /* |
| 144 | * The new screen may be a small screen, even if the parent |
| 145 | * was not. Don't complain if O_WINDOW is too large, we're |
| 146 | * splitting the screen so the screen is much smaller than |
| 147 | * normal. |
| 148 | */ |
| 149 | new->t_minrows = new->t_rows = O_VAL(sp, O_WINDOW)((((&((sp))->opts[((O_WINDOW))])->flags) & ((0x01 ))) ? ((sp))->gp->opts[((sp))->opts[((O_WINDOW))].o_cur .val].o_cur.val : ((sp))->opts[((O_WINDOW))].o_cur.val); |
| 150 | if (new->t_rows > new->rows - 1) |
| 151 | new->t_minrows = new->t_rows = |
| 152 | IS_ONELINE(new)((new)->rows == 1) ? 1 : new->rows - 1; |
| 153 | } |
| 154 | |
| 155 | /* Adjust the ends of the new and old maps. */ |
| 156 | _TMAP(sp)(((VI_PRIVATE *)((sp)->vi_private))->t_smap) = IS_ONELINE(sp)((sp)->rows == 1) ? |
| 157 | _HMAP(sp)(((VI_PRIVATE *)((sp)->vi_private))->h_smap) : _HMAP(sp)(((VI_PRIVATE *)((sp)->vi_private))->h_smap) + (sp->t_rows - 1); |
| 158 | _TMAP(new)(((VI_PRIVATE *)((new)->vi_private))->t_smap) = IS_ONELINE(new)((new)->rows == 1) ? |
| 159 | _HMAP(new)(((VI_PRIVATE *)((new)->vi_private))->h_smap) : _HMAP(new)(((VI_PRIVATE *)((new)->vi_private))->h_smap) + (new->t_rows - 1); |
| 160 | |
| 161 | /* Reset the length of the default scroll. */ |
| 162 | if ((sp->defscroll = sp->t_maxrows / 2) == 0) |
| 163 | sp->defscroll = 1; |
| 164 | if ((new->defscroll = new->t_maxrows / 2) == 0) |
| 165 | new->defscroll = 1; |
| 166 | |
| 167 | /* |
| 168 | * Initialize the screen flags: |
| 169 | * |
| 170 | * If we're in vi mode in one screen, we don't have to reinitialize. |
| 171 | * This isn't just a cosmetic fix. The path goes like this: |
| 172 | * |
| 173 | * return into vi(), SC_SSWITCH set |
| 174 | * call vs_refresh() with SC_STATUS set |
| 175 | * call vs_resolve to display the status message |
| 176 | * call vs_refresh() because the SC_SCR_VI bit isn't set |
| 177 | * |
| 178 | * Things go downhill at this point. |
| 179 | * |
| 180 | * Draw the new screen from scratch, and add a status line. |
| 181 | */ |
| 182 | F_SET(new,(((new)->flags) |= ((0x00000020 | 0x02000000 | (((sp)-> flags) & ((0x00000001 | 0x00000002 | 0x00000008 | 0x00000004 )))))) |
| 183 | SC_SCR_REFORMAT | SC_STATUS |(((new)->flags) |= ((0x00000020 | 0x02000000 | (((sp)-> flags) & ((0x00000001 | 0x00000002 | 0x00000008 | 0x00000004 )))))) |
| 184 | F_ISSET(sp, SC_EX | SC_VI | SC_SCR_VI | SC_SCR_EX))(((new)->flags) |= ((0x00000020 | 0x02000000 | (((sp)-> flags) & ((0x00000001 | 0x00000002 | 0x00000008 | 0x00000004 )))))); |
| 185 | return (0); |
| 186 | } |
| 187 | |
| 188 | /* |
| 189 | * vs_discard -- |
| 190 | * Discard the screen, folding the real-estate into a related screen, |
| 191 | * if one exists, and return that screen. |
| 192 | * |
| 193 | * PUBLIC: int vs_discard(SCR *, SCR **); |
| 194 | */ |
| 195 | int |
| 196 | vs_discard(SCR *sp, SCR **spp) |
| 197 | { |
| 198 | SCR *nsp; |
| 199 | dir_t dir; |
| 200 | |
| 201 | /* |
| 202 | * Save the old screen's cursor information. |
| 203 | * |
| 204 | * XXX |
| 205 | * If called after file_end(), and the underlying file was a tmp |
| 206 | * file, it may have gone away. |
| 207 | */ |
| 208 | if (sp->frp != NULL((void *)0)) { |
| 209 | sp->frp->lno = sp->lno; |
| 210 | sp->frp->cno = sp->cno; |
| 211 | F_SET(sp->frp, FR_CURSORSET)(((sp->frp)->flags) |= ((0x0001))); |
| 212 | } |
| 213 | |
| 214 | /* |
| 215 | * Add into a previous screen and then into a subsequent screen, as |
| 216 | * they're the closest to the current screen. If that doesn't work, |
| 217 | * there was no screen to join. |
| 218 | */ |
| 219 | if ((nsp = TAILQ_PREV(sp, _dqh, q)(*(((struct _dqh *)((sp)->q.tqe_prev))->tqh_last)))) { |
| 220 | nsp->rows += sp->rows; |
| 221 | sp = nsp; |
| 222 | dir = FORWARD; |
| 223 | } else if ((nsp = TAILQ_NEXT(sp, q)((sp)->q.tqe_next))) { |
| 224 | nsp->woff = sp->woff; |
| 225 | nsp->rows += sp->rows; |
| 226 | sp = nsp; |
| 227 | dir = BACKWARD; |
| 228 | } else { |
| 229 | sp = NULL((void *)0); |
| 230 | dir = 0; /* unused */ |
| 231 | } |
| 232 | |
| 233 | if (spp != NULL((void *)0)) |
| 234 | *spp = sp; |
| 235 | if (sp == NULL((void *)0)) |
| 236 | return (0); |
| 237 | |
| 238 | /* |
| 239 | * Make no effort to clean up the discarded screen's information. If |
| 240 | * it's not exiting, we'll do the work when the user redisplays it. |
| 241 | * |
| 242 | * Small screens: see vs_refresh.c section 6a. Adjust text line info, |
| 243 | * unless it's a small screen. |
| 244 | * |
| 245 | * Reset the length of the default scroll. |
| 246 | */ |
| 247 | if (!IS_SMALL(sp)((sp)->t_minrows != (sp)->t_maxrows)) |
| 248 | sp->t_rows = sp->t_minrows = sp->rows - 1; |
| 249 | sp->t_maxrows = sp->rows - 1; |
| 250 | sp->defscroll = sp->t_maxrows / 2; |
| 251 | *(HMAP(((VI_PRIVATE *)((sp)->vi_private))->h_smap) + (sp->t_rows - 1)) = *TMAP(((VI_PRIVATE *)((sp)->vi_private))->t_smap); |
| 252 | TMAP(((VI_PRIVATE *)((sp)->vi_private))->t_smap) = HMAP(((VI_PRIVATE *)((sp)->vi_private))->h_smap) + (sp->t_rows - 1); |
| 253 | |
| 254 | /* |
| 255 | * Draw the new screen from scratch, and add a status line. |
| 256 | * |
| 257 | * XXX |
| 258 | * We could play games with the map, if this were ever to be a |
| 259 | * performance problem, but I wrote the code a few times and it |
| 260 | * was never clean or easy. |
| 261 | */ |
| 262 | switch (dir) { |
| 263 | case FORWARD: |
| 264 | vs_sm_fill(sp, OOBLNO0, P_TOP); |
| 265 | break; |
| 266 | case BACKWARD: |
| 267 | vs_sm_fill(sp, OOBLNO0, P_BOTTOM); |
| 268 | break; |
| 269 | default: |
| 270 | abort(); |
| 271 | } |
| 272 | |
| 273 | F_SET(sp, SC_STATUS)(((sp)->flags) |= ((0x02000000))); |
| 274 | return (0); |
| 275 | } |
| 276 | |
| 277 | /* |
| 278 | * vs_fg -- |
| 279 | * Background the current screen, and foreground a new one. |
| 280 | * |
| 281 | * PUBLIC: int vs_fg(SCR *, SCR **, CHAR_T *, int); |
| 282 | */ |
| 283 | int |
| 284 | vs_fg(SCR *sp, SCR **nspp, CHAR_T *name, int newscreen) |
| 285 | { |
| 286 | GS *gp; |
| 287 | SCR *nsp; |
| 288 | |
| 289 | gp = sp->gp; |
| 290 | |
| 291 | if (newscreen) |
| 292 | /* Get the specified background screen. */ |
| 293 | nsp = vs_getbg(sp, name); |
| 294 | else |
| 295 | /* Swap screens. */ |
| 296 | if (vs_swap(sp, &nsp, name)) |
| 297 | return (1); |
| 298 | |
| 299 | if ((*nspp = nsp) == NULL((void *)0)) { |
| 300 | msgq_str(sp, M_ERR, name, |
| 301 | name == NULL((void *)0) ? |
| 302 | "There are no background screens" : |
| 303 | "There's no background screen editing a file named %s"); |
| 304 | return (1); |
| 305 | } |
| 306 | |
| 307 | if (newscreen) { |
| 308 | /* Remove the new screen from the background queue. */ |
| 309 | TAILQ_REMOVE(&gp->hq, nsp, q)do { if (((nsp)->q.tqe_next) != ((void *)0)) (nsp)->q.tqe_next ->q.tqe_prev = (nsp)->q.tqe_prev; else (&gp->hq) ->tqh_last = (nsp)->q.tqe_prev; *(nsp)->q.tqe_prev = (nsp)->q.tqe_next; ; ; } while (0); |
| 310 | |
| 311 | /* Split the screen; if we fail, hook the screen back in. */ |
| 312 | if (vs_split(sp, nsp, 0)) { |
| 313 | TAILQ_INSERT_TAIL(&gp->hq, nsp, q)do { (nsp)->q.tqe_next = ((void *)0); (nsp)->q.tqe_prev = (&gp->hq)->tqh_last; *(&gp->hq)->tqh_last = (nsp); (&gp->hq)->tqh_last = &(nsp)->q.tqe_next ; } while (0); |
| 314 | return (1); |
| 315 | } |
| 316 | } else { |
| 317 | /* Move the old screen to the background queue. */ |
| 318 | TAILQ_REMOVE(&gp->dq, sp, q)do { if (((sp)->q.tqe_next) != ((void *)0)) (sp)->q.tqe_next ->q.tqe_prev = (sp)->q.tqe_prev; else (&gp->dq)-> tqh_last = (sp)->q.tqe_prev; *(sp)->q.tqe_prev = (sp)-> q.tqe_next; ; ; } while (0); |
| 319 | TAILQ_INSERT_TAIL(&gp->hq, sp, q)do { (sp)->q.tqe_next = ((void *)0); (sp)->q.tqe_prev = (&gp->hq)->tqh_last; *(&gp->hq)->tqh_last = (sp); (&gp->hq)->tqh_last = &(sp)->q.tqe_next ; } while (0); |
| 320 | } |
| 321 | return (0); |
| 322 | } |
| 323 | |
| 324 | /* |
| 325 | * vs_bg -- |
| 326 | * Background the screen, and switch to the next one. |
| 327 | * |
| 328 | * PUBLIC: int vs_bg(SCR *); |
| 329 | */ |
| 330 | int |
| 331 | vs_bg(SCR *sp) |
| 332 | { |
| 333 | GS *gp; |
| 334 | SCR *nsp; |
| 335 | |
| 336 | gp = sp->gp; |
| 337 | |
| 338 | /* Try and join with another screen. */ |
| 339 | if (vs_discard(sp, &nsp)) |
| 340 | return (1); |
| 341 | if (nsp == NULL((void *)0)) { |
| 342 | msgq(sp, M_ERR, |
| 343 | "You may not background your only displayed screen"); |
| 344 | return (1); |
| 345 | } |
| 346 | |
| 347 | /* Move the old screen to the background queue. */ |
| 348 | TAILQ_REMOVE(&gp->dq, sp, q)do { if (((sp)->q.tqe_next) != ((void *)0)) (sp)->q.tqe_next ->q.tqe_prev = (sp)->q.tqe_prev; else (&gp->dq)-> tqh_last = (sp)->q.tqe_prev; *(sp)->q.tqe_prev = (sp)-> q.tqe_next; ; ; } while (0); |
| 349 | TAILQ_INSERT_TAIL(&gp->hq, sp, q)do { (sp)->q.tqe_next = ((void *)0); (sp)->q.tqe_prev = (&gp->hq)->tqh_last; *(&gp->hq)->tqh_last = (sp); (&gp->hq)->tqh_last = &(sp)->q.tqe_next ; } while (0); |
| 350 | |
| 351 | /* Toss the screen map. */ |
| 352 | free(_HMAP(sp)(((VI_PRIVATE *)((sp)->vi_private))->h_smap)); |
| 353 | _HMAP(sp)(((VI_PRIVATE *)((sp)->vi_private))->h_smap) = NULL((void *)0); |
| 354 | |
| 355 | /* Switch screens. */ |
| 356 | sp->nextdisp = nsp; |
| 357 | F_SET(sp, SC_SSWITCH)(((sp)->flags) |= ((0x00001000))); |
| 358 | |
| 359 | return (0); |
| 360 | } |
| 361 | |
| 362 | /* |
| 363 | * vs_swap -- |
| 364 | * Swap the current screen with a backgrounded one. |
| 365 | * |
| 366 | * PUBLIC: int vs_swap(SCR *, SCR **, char *); |
| 367 | */ |
| 368 | int |
| 369 | vs_swap(SCR *sp, SCR **nspp, char *name) |
| 370 | { |
| 371 | GS *gp; |
| 372 | SCR *nsp; |
| 373 | |
| 374 | gp = sp->gp; |
| 375 | |
| 376 | /* Get the specified background screen. */ |
| 377 | if ((*nspp = nsp = vs_getbg(sp, name)) == NULL((void *)0)) |
| 378 | return (0); |
| 379 | |
| 380 | /* |
| 381 | * Save the old screen's cursor information. |
| 382 | * |
| 383 | * XXX |
| 384 | * If called after file_end(), and the underlying file was a tmp |
| 385 | * file, it may have gone away. |
| 386 | */ |
| 387 | if (sp->frp != NULL((void *)0)) { |
| 388 | sp->frp->lno = sp->lno; |
| 389 | sp->frp->cno = sp->cno; |
| 390 | F_SET(sp->frp, FR_CURSORSET)(((sp->frp)->flags) |= ((0x0001))); |
| 391 | } |
| 392 | |
| 393 | /* Switch screens. */ |
| 394 | sp->nextdisp = nsp; |
| 395 | F_SET(sp, SC_SSWITCH)(((sp)->flags) |= ((0x00001000))); |
| 396 | |
| 397 | /* Initialize terminal information. */ |
| 398 | VIP(nsp)((VI_PRIVATE *)((nsp)->vi_private))->srows = VIP(sp)((VI_PRIVATE *)((sp)->vi_private))->srows; |
| 399 | |
| 400 | /* Initialize screen information. */ |
| 401 | nsp->cols = sp->cols; |
| 402 | nsp->rows = sp->rows; /* XXX: Only place in vi that sets rows. */ |
| 403 | nsp->woff = sp->woff; |
| 404 | |
| 405 | /* |
| 406 | * Small screens: see vs_refresh.c, section 6a. |
| 407 | * |
| 408 | * The new screens may have different screen options sizes than the |
| 409 | * old one, so use them. Make sure that text counts aren't larger |
| 410 | * than the new screen sizes. |
| 411 | */ |
| 412 | if (IS_SMALL(nsp)((nsp)->t_minrows != (nsp)->t_maxrows)) { |
| 413 | nsp->t_minrows = nsp->t_rows = O_VAL(nsp, O_WINDOW)((((&((nsp))->opts[((O_WINDOW))])->flags) & ((0x01 ))) ? ((nsp))->gp->opts[((nsp))->opts[((O_WINDOW))]. o_cur.val].o_cur.val : ((nsp))->opts[((O_WINDOW))].o_cur.val ); |
| 414 | if (nsp->t_rows > sp->t_maxrows) |
| 415 | nsp->t_rows = nsp->t_maxrows; |
| 416 | if (nsp->t_minrows > sp->t_maxrows) |
| 417 | nsp->t_minrows = nsp->t_maxrows; |
| 418 | } else |
| 419 | nsp->t_rows = nsp->t_maxrows = nsp->t_minrows = nsp->rows - 1; |
| 420 | |
| 421 | /* Reset the length of the default scroll. */ |
| 422 | nsp->defscroll = nsp->t_maxrows / 2; |
| 423 | |
| 424 | /* Allocate a new screen map. */ |
| 425 | CALLOC_RET(nsp, _HMAP(nsp), SIZE_HMAP(nsp), sizeof(SMAP)){ if ((((((VI_PRIVATE *)((nsp)->vi_private))->h_smap)) = calloc(((((VI_PRIVATE *)((nsp)->vi_private))->srows + 1 )), (sizeof(SMAP)))) == ((void *)0)) { msgq((nsp), M_SYSERR, ( (void *)0)); return (1); } }; |
| 426 | _TMAP(nsp)(((VI_PRIVATE *)((nsp)->vi_private))->t_smap) = _HMAP(nsp)(((VI_PRIVATE *)((nsp)->vi_private))->h_smap) + (nsp->t_rows - 1); |
| 427 | |
| 428 | /* Fill the map. */ |
| 429 | if (vs_sm_fill(nsp, nsp->lno, P_FILL)) |
| 430 | return (1); |
| 431 | |
| 432 | /* |
| 433 | * The new screen replaces the old screen in the parent/child list. |
| 434 | * We insert the new screen after the old one. If we're exiting, |
| 435 | * the exit will delete the old one, if we're foregrounding, the fg |
| 436 | * code will move the old one to the background queue. |
| 437 | */ |
| 438 | TAILQ_REMOVE(&gp->hq, nsp, q)do { if (((nsp)->q.tqe_next) != ((void *)0)) (nsp)->q.tqe_next ->q.tqe_prev = (nsp)->q.tqe_prev; else (&gp->hq) ->tqh_last = (nsp)->q.tqe_prev; *(nsp)->q.tqe_prev = (nsp)->q.tqe_next; ; ; } while (0); |
| 439 | TAILQ_INSERT_AFTER(&gp->dq, sp, nsp, q)do { if (((nsp)->q.tqe_next = (sp)->q.tqe_next) != ((void *)0)) (nsp)->q.tqe_next->q.tqe_prev = &(nsp)->q .tqe_next; else (&gp->dq)->tqh_last = &(nsp)-> q.tqe_next; (sp)->q.tqe_next = (nsp); (nsp)->q.tqe_prev = &(sp)->q.tqe_next; } while (0); |
| 440 | |
| 441 | /* |
| 442 | * Don't change the screen's cursor information other than to |
| 443 | * note that the cursor is wrong. |
| 444 | */ |
| 445 | F_SET(VIP(nsp), VIP_CUR_INVALID)(((((VI_PRIVATE *)((nsp)->vi_private)))->flags) |= ((0x0001 ))); |
| 446 | |
| 447 | /* Draw the new screen from scratch, and add a status line. */ |
| 448 | F_SET(nsp, SC_SCR_REDRAW | SC_STATUS)(((nsp)->flags) |= ((0x00000040 | 0x02000000))); |
| 449 | return (0); |
| 450 | } |
| 451 | |
| 452 | /* |
| 453 | * vs_resize -- |
| 454 | * Change the absolute size of the current screen. |
| 455 | * |
| 456 | * PUBLIC: int vs_resize(SCR *, long, adj_t); |
| 457 | */ |
| 458 | int |
| 459 | vs_resize(SCR *sp, long count, adj_t adj) |
| 460 | { |
| 461 | GS *gp; |
| 462 | SCR *g, *s; |
| 463 | size_t g_off, s_off; |
| 464 | |
| 465 | gp = sp->gp; |
Value stored to 'gp' is never read | |
| 466 | |
| 467 | /* |
| 468 | * Figure out which screens will grow, which will shrink, and |
| 469 | * make sure it's possible. |
| 470 | */ |
| 471 | if (count == 0) |
| 472 | return (0); |
| 473 | if (adj == A_SET) { |
| 474 | if (sp->t_maxrows == count) |
| 475 | return (0); |
| 476 | if (sp->t_maxrows > count) { |
| 477 | adj = A_DECREASE; |
| 478 | count = sp->t_maxrows - count; |
| 479 | } else { |
| 480 | adj = A_INCREASE; |
| 481 | count = count - sp->t_maxrows; |
| 482 | } |
| 483 | } |
| 484 | |
| 485 | g_off = s_off = 0; |
| 486 | if (adj == A_DECREASE) { |
| 487 | if (count < 0) |
| 488 | count = -count; |
| 489 | s = sp; |
| 490 | if (s->t_maxrows < MINIMUM_SCREEN_ROWS1 + count) |
| 491 | goto toosmall; |
| 492 | if ((g = TAILQ_PREV(sp, _dqh, q)(*(((struct _dqh *)((sp)->q.tqe_prev))->tqh_last))) == NULL((void *)0)) { |
| 493 | if ((g = TAILQ_NEXT(sp, q)((sp)->q.tqe_next)) == NULL((void *)0)) |
| 494 | goto toobig; |
| 495 | g_off = -count; |
| 496 | } else |
| 497 | s_off = count; |
| 498 | } else { |
| 499 | g = sp; |
| 500 | if ((s = TAILQ_NEXT(sp, q)((sp)->q.tqe_next))) |
| 501 | if (s->t_maxrows < MINIMUM_SCREEN_ROWS1 + count) |
| 502 | s = NULL((void *)0); |
| 503 | else |
| 504 | s_off = count; |
| 505 | else |
| 506 | s = NULL((void *)0); |
| 507 | if (s == NULL((void *)0)) { |
| 508 | if ((s = TAILQ_PREV(sp, _dqh, q)(*(((struct _dqh *)((sp)->q.tqe_prev))->tqh_last))) == NULL((void *)0)) { |
| 509 | toobig: msgq(sp, M_BERR, adj == A_DECREASE ? |
| 510 | "The screen cannot shrink" : |
| 511 | "The screen cannot grow"); |
| 512 | return (1); |
| 513 | } |
| 514 | if (s->t_maxrows < MINIMUM_SCREEN_ROWS1 + count) { |
| 515 | toosmall: msgq(sp, M_BERR, |
| 516 | "The screen can only shrink to %d rows", |
| 517 | MINIMUM_SCREEN_ROWS1); |
| 518 | return (1); |
| 519 | } |
| 520 | g_off = -count; |
| 521 | } |
| 522 | } |
| 523 | |
| 524 | /* |
| 525 | * Fix up the screens; we could optimize the reformatting of the |
| 526 | * screen, but this isn't likely to be a common enough operation |
| 527 | * to make it worthwhile. |
| 528 | */ |
| 529 | s->rows += -count; |
| 530 | s->woff += s_off; |
| 531 | g->rows += count; |
| 532 | g->woff += g_off; |
| 533 | |
| 534 | g->t_rows += count; |
| 535 | if (g->t_minrows == g->t_maxrows) |
| 536 | g->t_minrows += count; |
| 537 | g->t_maxrows += count; |
| 538 | _TMAP(g)(((VI_PRIVATE *)((g)->vi_private))->t_smap) += count; |
| 539 | F_SET(g, SC_SCR_REFORMAT | SC_STATUS)(((g)->flags) |= ((0x00000020 | 0x02000000))); |
| 540 | |
| 541 | s->t_rows -= count; |
| 542 | s->t_maxrows -= count; |
| 543 | if (s->t_minrows > s->t_maxrows) |
| 544 | s->t_minrows = s->t_maxrows; |
| 545 | _TMAP(s)(((VI_PRIVATE *)((s)->vi_private))->t_smap) -= count; |
| 546 | F_SET(s, SC_SCR_REFORMAT | SC_STATUS)(((s)->flags) |= ((0x00000020 | 0x02000000))); |
| 547 | |
| 548 | return (0); |
| 549 | } |
| 550 | |
| 551 | /* |
| 552 | * vs_getbg -- |
| 553 | * Get the specified background screen, or, if name is NULL, the first |
| 554 | * background screen. |
| 555 | */ |
| 556 | static SCR * |
| 557 | vs_getbg(SCR *sp, char *name) |
| 558 | { |
| 559 | GS *gp; |
| 560 | SCR *nsp; |
| 561 | char *p; |
| 562 | |
| 563 | gp = sp->gp; |
| 564 | |
| 565 | /* If name is NULL, return the first background screen on the list. */ |
| 566 | if (name == NULL((void *)0)) |
| 567 | return (TAILQ_FIRST(&gp->hq)((&gp->hq)->tqh_first)); |
| 568 | |
| 569 | /* Search for a full match. */ |
| 570 | TAILQ_FOREACH(nsp, &gp->hq, q)for((nsp) = ((&gp->hq)->tqh_first); (nsp) != ((void *)0); (nsp) = ((nsp)->q.tqe_next)) { |
| 571 | if (!strcmp(nsp->frp->name, name)) |
| 572 | return(nsp); |
| 573 | } |
| 574 | |
| 575 | /* Search for a last-component match. */ |
| 576 | TAILQ_FOREACH(nsp, &gp->hq, q)for((nsp) = ((&gp->hq)->tqh_first); (nsp) != ((void *)0); (nsp) = ((nsp)->q.tqe_next)) { |
| 577 | if ((p = strrchr(nsp->frp->name, '/')) == NULL((void *)0)) |
| 578 | p = nsp->frp->name; |
| 579 | else |
| 580 | ++p; |
| 581 | if (!strcmp(p, name)) |
| 582 | return(nsp); |
| 583 | } |
| 584 | |
| 585 | return (NULL((void *)0)); |
| 586 | } |