/*- * Copyright (c) 1993, 1994 * The Regents of the University of California. All rights reserved. * Copyright (c) 1993, 1994, 1995, 1996 * Keith Bostic. All rights reserved. * * See the LICENSE file for redistribution information. */ #include "config.h" #ifndef lint static const char sccsid[] = "$Id: vs_split.c,v 10.43 2015/04/05 15:21:55 zy Exp $"; #endif /* not lint */ #include <sys/types.h> #include <sys/queue.h> #include <sys/time.h> #include <bitstring.h> #include <errno.h> #include <limits.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include "../common/common.h" #include "vi.h" typedef enum { HORIZ_FOLLOW, HORIZ_PRECEDE, VERT_FOLLOW, VERT_PRECEDE } jdir_t; static SCR *vs_getbg(SCR *, char *); static void vs_insert(SCR *sp, GS *gp); static int vs_join(SCR *, SCR **, jdir_t *); /* * vs_split -- * Create a new screen, horizontally. * * PUBLIC: int vs_split(SCR *, SCR *, int); */ int vs_split( SCR *sp, SCR *new, int ccl) /* Colon-command line split. */ { GS *gp; SMAP *smp; size_t half; int issmallscreen, splitup; gp = sp->gp; /* Check to see if it's possible. */ /* XXX: The IS_ONELINE fix will change this, too. */ if (sp->rows < 4) { msgq(sp, M_ERR, "222|Screen must be larger than %d lines to split", 4 - 1); return (1); } /* Wait for any messages in the screen. */ vs_resolve(sp, NULL, 1); /* Get a new screen map. */ CALLOC(sp, _HMAP(new), SMAP *, SIZE_HMAP(sp), sizeof(SMAP)); if (_HMAP(new) == NULL) return (1); _HMAP(new)->lno = sp->lno; _HMAP(new)->coff = 0; _HMAP(new)->soff = 1; /* Split the screen in half. */ half = sp->rows / 2; if (ccl && half > 6) half = 6; /* * Small screens: see vs_refresh.c section 6a. Set a flag so * we know to fix the screen up later. */ issmallscreen = IS_SMALL(sp); /* The columns in the screen don't change. */ new->coff = sp->coff; new->cols = sp->cols; /* * Split the screen, and link the screens together. If creating a * screen to edit the colon command line or the cursor is in the top * half of the current screen, the new screen goes under the current * screen. Else, it goes above the current screen. * * Recalculate current cursor position based on sp->lno, we're called * with the cursor on the colon command line. Then split the screen * in half and update the shared information. */ splitup = !ccl && (vs_sm_cursor(sp, &smp) ? 0 : (smp - HMAP) + 1) >= half; if (splitup) { /* Old is bottom half. */ new->rows = sp->rows - half; /* New. */ new->roff = sp->roff; sp->rows = half; /* Old. */ sp->roff += new->rows; /* * If the parent is the bottom half of the screen, shift * the map down to match on-screen text. */ memcpy(_HMAP(sp), _HMAP(sp) + new->rows, (sp->t_maxrows - new->rows) * sizeof(SMAP)); } else { /* Old is top half. */ new->rows = half; /* New. */ sp->rows -= half; /* Old. */ new->roff = sp->roff + sp->rows; } /* Adjust maximum text count. */ sp->t_maxrows = IS_ONELINE(sp) ? 1 : sp->rows - 1; new->t_maxrows = IS_ONELINE(new) ? 1 : new->rows - 1; /* * Small screens: see vs_refresh.c, section 6a. * * The child may have different screen options sizes than the parent, * so use them. Guarantee that text counts aren't larger than the * new screen sizes. */ if (issmallscreen) { /* Fix the text line count for the parent. */ if (splitup) sp->t_rows -= new->rows; /* Fix the parent screen. */ if (sp->t_rows > sp->t_maxrows) sp->t_rows = sp->t_maxrows; if (sp->t_minrows > sp->t_maxrows) sp->t_minrows = sp->t_maxrows; /* Fix the child screen. */ new->t_minrows = new->t_rows = O_VAL(sp, O_WINDOW); if (new->t_rows > new->t_maxrows) new->t_rows = new->t_maxrows; if (new->t_minrows > new->t_maxrows) new->t_minrows = new->t_maxrows; } else { sp->t_minrows = sp->t_rows = IS_ONELINE(sp) ? 1 : sp->rows - 1; /* * The new screen may be a small screen, even if the parent * was not. Don't complain if O_WINDOW is too large, we're * splitting the screen so the screen is much smaller than * normal. */ new->t_minrows = new->t_rows = O_VAL(sp, O_WINDOW); if (new->t_rows > new->rows - 1) new->t_minrows = new->t_rows = IS_ONELINE(new) ? 1 : new->rows - 1; } /* Adjust the ends of the new and old maps. */ _TMAP(sp) = IS_ONELINE(sp) ? _HMAP(sp) : _HMAP(sp) + (sp->t_rows - 1); _TMAP(new) = IS_ONELINE(new) ? _HMAP(new) : _HMAP(new) + (new->t_rows - 1); /* Reset the length of the default scroll. */ if ((sp->defscroll = sp->t_maxrows / 2) == 0) sp->defscroll = 1; if ((new->defscroll = new->t_maxrows / 2) == 0) new->defscroll = 1; /* Fit the screen into the logical chain. */ vs_insert(new, sp->gp); /* Tell the display that we're splitting. */ (void)gp->scr_split(sp, new); /* * Initialize the screen flags: * * If we're in vi mode in one screen, we don't have to reinitialize. * This isn't just a cosmetic fix. The path goes like this: * * return into vi(), SC_SSWITCH set * call vs_refresh() with SC_STATUS set * call vs_resolve to display the status message * call vs_refresh() because the SC_SCR_VI bit isn't set * * Things go downhill at this point. * * Draw the new screen from scratch, and add a status line. */ F_SET(new, SC_SCR_REFORMAT | SC_STATUS | F_ISSET(sp, SC_EX | SC_VI | SC_SCR_VI | SC_SCR_EX | SC_READONLY)); return (0); } /* * vs_vsplit -- * Create a new screen, vertically. * * PUBLIC: int vs_vsplit(SCR *, SCR *); */ int vs_vsplit(SCR *sp, SCR *new) { GS *gp; size_t cols; gp = sp->gp; /* Check to see if it's possible. */ if (sp->cols / 2 <= MINIMUM_SCREEN_COLS) { msgq(sp, M_ERR, "288|Screen must be larger than %d columns to split", MINIMUM_SCREEN_COLS * 2); return (1); } /* Wait for any messages in the screen. */ vs_resolve(sp, NULL, 1); /* Get a new screen map. */ CALLOC(sp, _HMAP(new), SMAP *, SIZE_HMAP(sp), sizeof(SMAP)); if (_HMAP(new) == NULL) return (1); _HMAP(new)->lno = sp->lno; _HMAP(new)->coff = 0; _HMAP(new)->soff = 1; /* * Split the screen in half; we have to sacrifice a column to delimit * the screens. * * XXX * We always split to the right... that makes more sense to me, and * I don't want to play the stupid games that I play when splitting * horizontally. * * XXX * We reserve a column for the screen, "knowing" that curses needs * one. This should be worked out with the display interface. */ cols = sp->cols / 2; new->cols = sp->cols - cols - 1; sp->cols = cols; new->coff = sp->coff + cols + 1; sp->cno = 0; /* Nothing else changes. */ new->rows = sp->rows; new->t_rows = sp->t_rows; new->t_maxrows = sp->t_maxrows; new->t_minrows = sp->t_minrows; new->roff = sp->roff; new->defscroll = sp->defscroll; _TMAP(new) = _HMAP(new) + (new->t_rows - 1); /* Fit the screen into the logical chain. */ vs_insert(new, sp->gp); /* Tell the display that we're splitting. */ (void)gp->scr_split(sp, new); /* Redraw the old screen from scratch. */ F_SET(sp, SC_SCR_REFORMAT | SC_STATUS); /* * Initialize the screen flags: * * If we're in vi mode in one screen, we don't have to reinitialize. * This isn't just a cosmetic fix. The path goes like this: * * return into vi(), SC_SSWITCH set * call vs_refresh() with SC_STATUS set * call vs_resolve to display the status message * call vs_refresh() because the SC_SCR_VI bit isn't set * * Things go downhill at this point. * * Draw the new screen from scratch, and add a status line. */ F_SET(new, SC_SCR_REFORMAT | SC_STATUS | F_ISSET(sp, SC_EX | SC_VI | SC_SCR_VI | SC_SCR_EX | SC_READONLY)); return (0); } /* * vs_insert -- * Insert the new screen into the correct place in the logical * chain. */ static void vs_insert(SCR *sp, GS *gp) { SCR *tsp; gp = sp->gp; /* Move past all screens with lower row numbers. */ TAILQ_FOREACH(tsp, gp->dq, q) if (tsp->roff >= sp->roff) break; /* * Move past all screens with the same row number and lower * column numbers. */ for (; tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) if (tsp->roff != sp->roff || tsp->coff > sp->coff) break; /* * If we reached the end, this screen goes there. Otherwise, * put it before or after the screen where we stopped. */ if (tsp == NULL) { TAILQ_INSERT_TAIL(gp->dq, sp, q); } else if (tsp->roff < sp->roff || (tsp->roff == sp->roff && tsp->coff < sp->coff)) { TAILQ_INSERT_AFTER(gp->dq, tsp, sp, q); } else TAILQ_INSERT_BEFORE(tsp, sp, q); } /* * vs_discard -- * Discard the screen, folding the real-estate into a related screen, * if one exists, and return that screen. * * PUBLIC: int vs_discard(SCR *, SCR **); */ int vs_discard(SCR *sp, SCR **spp) { GS *gp; SCR *tsp, **lp, *list[100]; jdir_t jdir; gp = sp->gp; /* * Save the old screen's cursor information. * * XXX * If called after file_end(), and the underlying file was a tmp * file, it may have gone away. */ if (sp->frp != NULL) { sp->frp->lno = sp->lno; sp->frp->cno = sp->cno; F_SET(sp->frp, FR_CURSORSET); } /* If no other screens to join, we're done. */ if (!IS_SPLIT(sp)) { (void)gp->scr_discard(sp, NULL); if (spp != NULL) *spp = NULL; return (0); } /* * Find a set of screens that cover one of the screen's borders. * Check the vertical axis first, for no particular reason. * * XXX * It's possible (I think?), to create a screen that shares no full * border with any other set of screens, so we can't discard it. We * just complain at the user until they clean it up. */ if (vs_join(sp, list, &jdir)) return (1); /* * Modify the affected screens. Redraw the modified screen(s) from * scratch, setting a status line. If this is ever a performance * problem we could play games with the map, but I wrote that code * before and it was never clean or easy. * * Don't clean up the discarded screen's information. If the screen * isn't exiting, we'll do the work when the user redisplays it. */ switch (jdir) { case HORIZ_FOLLOW: case HORIZ_PRECEDE: for (lp = &list[0]; (tsp = *lp) != NULL; ++lp) { /* * Small screens: see vs_refresh.c section 6a. Adjust * text line info, unless it's a small screen. * * Reset the length of the default scroll. * * Reset the map references. */ tsp->rows += sp->rows; if (!IS_SMALL(tsp)) tsp->t_rows = tsp->t_minrows = tsp->rows - 1; tsp->t_maxrows = tsp->rows - 1; tsp->defscroll = tsp->t_maxrows / 2; *(_HMAP(tsp) + (tsp->t_rows - 1)) = *_TMAP(tsp); _TMAP(tsp) = _HMAP(tsp) + (tsp->t_rows - 1); switch (jdir) { case HORIZ_FOLLOW: tsp->roff = sp->roff; vs_sm_fill(tsp, OOBLNO, P_TOP); break; case HORIZ_PRECEDE: vs_sm_fill(tsp, OOBLNO, P_BOTTOM); break; default: abort(); } F_SET(tsp, SC_STATUS); } break; case VERT_FOLLOW: case VERT_PRECEDE: for (lp = &list[0]; (tsp = *lp) != NULL; ++lp) { if (jdir == VERT_FOLLOW) tsp->coff = sp->coff; tsp->cols += sp->cols + 1; /* XXX: DIVIDER */ vs_sm_fill(tsp, OOBLNO, P_TOP); F_SET(tsp, SC_STATUS); } break; default: abort(); } /* Find the closest screen that changed and move to it. */ tsp = list[0]; if (spp != NULL) *spp = tsp; /* Tell the display that we're discarding a screen. */ (void)gp->scr_discard(sp, list); return (0); } /* * vs_join -- * Find a set of screens that covers a screen's border. */ static int vs_join(SCR *sp, SCR **listp, jdir_t *jdirp) { GS *gp; SCR **lp, *tsp; int first; size_t tlen; gp = sp->gp; /* Check preceding vertical. */ for (lp = listp, tlen = sp->rows, tsp = TAILQ_FIRST(gp->dq); tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) { if (sp == tsp) continue; /* Test if precedes the screen vertically. */ if (tsp->coff + tsp->cols + 1 != sp->coff) continue; /* * Test if a subset on the vertical axis. If overlaps the * beginning or end, we can't join on this axis at all. */ if (tsp->roff > sp->roff + sp->rows) continue; if (tsp->roff < sp->roff) { if (tsp->roff + tsp->rows >= sp->roff) break; continue; } if (tsp->roff + tsp->rows > sp->roff + sp->rows) break; #ifdef DEBUG if (tlen < tsp->rows) abort(); #endif tlen -= tsp->rows; *lp++ = tsp; } if (tlen == 0) { *lp = NULL; *jdirp = VERT_PRECEDE; return (0); } /* Check following vertical. */ for (lp = listp, tlen = sp->rows, tsp = TAILQ_FIRST(gp->dq); tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) { if (sp == tsp) continue; /* Test if follows the screen vertically. */ if (tsp->coff != sp->coff + sp->cols + 1) continue; /* * Test if a subset on the vertical axis. If overlaps the * beginning or end, we can't join on this axis at all. */ if (tsp->roff > sp->roff + sp->rows) continue; if (tsp->roff < sp->roff) { if (tsp->roff + tsp->rows >= sp->roff) break; continue; } if (tsp->roff + tsp->rows > sp->roff + sp->rows) break; #ifdef DEBUG if (tlen < tsp->rows) abort(); #endif tlen -= tsp->rows; *lp++ = tsp; } if (tlen == 0) { *lp = NULL; *jdirp = VERT_FOLLOW; return (0); } /* Check preceding horizontal. */ for (first = 0, lp = listp, tlen = sp->cols, tsp = TAILQ_FIRST(gp->dq); tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) { if (sp == tsp) continue; /* Test if precedes the screen horizontally. */ if (tsp->roff + tsp->rows != sp->roff) continue; /* * Test if a subset on the horizontal axis. If overlaps the * beginning or end, we can't join on this axis at all. */ if (tsp->coff > sp->coff + sp->cols) continue; if (tsp->coff < sp->coff) { if (tsp->coff + tsp->cols >= sp->coff) break; continue; } if (tsp->coff + tsp->cols > sp->coff + sp->cols) break; #ifdef DEBUG if (tlen < tsp->cols) abort(); #endif tlen -= tsp->cols + first; first = 1; *lp++ = tsp; } if (tlen == 0) { *lp = NULL; *jdirp = HORIZ_PRECEDE; return (0); } /* Check following horizontal. */ for (first = 0, lp = listp, tlen = sp->cols, tsp = TAILQ_FIRST(gp->dq); tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) { if (sp == tsp) continue; /* Test if precedes the screen horizontally. */ if (tsp->roff != sp->roff + sp->rows) continue; /* * Test if a subset on the horizontal axis. If overlaps the * beginning or end, we can't join on this axis at all. */ if (tsp->coff > sp->coff + sp->cols) continue; if (tsp->coff < sp->coff) { if (tsp->coff + tsp->cols >= sp->coff) break; continue; } if (tsp->coff + tsp->cols > sp->coff + sp->cols) break; #ifdef DEBUG if (tlen < tsp->cols) abort(); #endif tlen -= tsp->cols + first; first = 1; *lp++ = tsp; } if (tlen == 0) { *lp = NULL; *jdirp = HORIZ_FOLLOW; return (0); } return (1); } /* * vs_fg -- * Background the current screen, and foreground a new one. * * PUBLIC: int vs_fg(SCR *, SCR **, CHAR_T *, int); */ int vs_fg(SCR *sp, SCR **nspp, CHAR_T *name, int newscreen) { GS *gp; SCR *nsp; char *np; size_t nlen; gp = sp->gp; if (name) INT2CHAR(sp, name, STRLEN(name) + 1, np, nlen); else np = NULL; if (newscreen) /* Get the specified background screen. */ nsp = vs_getbg(sp, np); else /* Swap screens. */ if (vs_swap(sp, &nsp, np)) return (1); if ((*nspp = nsp) == NULL) { msgq_wstr(sp, M_ERR, name, name == NULL ? "223|There are no background screens" : "224|There's no background screen editing a file named %s"); return (1); } if (newscreen) { /* Remove the new screen from the background queue. */ TAILQ_REMOVE(gp->hq, nsp, q); /* Split the screen; if we fail, hook the screen back in. */ if (vs_split(sp, nsp, 0)) { TAILQ_INSERT_TAIL(gp->hq, nsp, q); return (1); } } else { /* Move the old screen to the background queue. */ TAILQ_REMOVE(gp->dq, sp, q); TAILQ_INSERT_TAIL(gp->hq, sp, q); } return (0); } /* * vs_bg -- * Background the screen, and switch to the next one. * * PUBLIC: int vs_bg(SCR *); */ int vs_bg(SCR *sp) { GS *gp; SCR *nsp; gp = sp->gp; /* Try and join with another screen. */ if (vs_discard(sp, &nsp)) return (1); if (nsp == NULL) { msgq(sp, M_ERR, "225|You may not background your only displayed screen"); return (1); } /* Move the old screen to the background queue. */ TAILQ_REMOVE(gp->dq, sp, q); TAILQ_INSERT_TAIL(gp->hq, sp, q); /* Toss the screen map. */ free(_HMAP(sp)); _HMAP(sp) = NULL; /* Switch screens. */ sp->nextdisp = nsp; F_SET(sp, SC_SSWITCH); return (0); } /* * vs_swap -- * Swap the current screen with a backgrounded one. * * PUBLIC: int vs_swap(SCR *, SCR **, char *); */ int vs_swap(SCR *sp, SCR **nspp, char *name) { GS *gp; SCR *nsp, *list[2]; gp = sp->gp; /* Get the specified background screen. */ if ((*nspp = nsp = vs_getbg(sp, name)) == NULL) return (0); /* * Save the old screen's cursor information. * * XXX * If called after file_end(), and the underlying file was a tmp * file, it may have gone away. */ if (sp->frp != NULL) { sp->frp->lno = sp->lno; sp->frp->cno = sp->cno; F_SET(sp->frp, FR_CURSORSET); } /* Switch screens. */ sp->nextdisp = nsp; F_SET(sp, SC_SSWITCH); /* Initialize terminal information. */ VIP(nsp)->srows = VIP(sp)->srows; /* Initialize screen information. */ nsp->cols = sp->cols; nsp->rows = sp->rows; /* XXX: Only place in vi that sets rows. */ nsp->roff = sp->roff; /* * Small screens: see vs_refresh.c, section 6a. * * The new screens may have different screen options sizes than the * old one, so use them. Make sure that text counts aren't larger * than the new screen sizes. */ if (IS_SMALL(nsp)) { nsp->t_minrows = nsp->t_rows = O_VAL(nsp, O_WINDOW); if (nsp->t_rows > sp->t_maxrows) nsp->t_rows = nsp->t_maxrows; if (nsp->t_minrows > sp->t_maxrows) nsp->t_minrows = nsp->t_maxrows; } else nsp->t_rows = nsp->t_maxrows = nsp->t_minrows = nsp->rows - 1; /* Reset the length of the default scroll. */ nsp->defscroll = nsp->t_maxrows / 2; /* Allocate a new screen map. */ CALLOC_RET(nsp, _HMAP(nsp), SMAP *, SIZE_HMAP(nsp), sizeof(SMAP)); _TMAP(nsp) = _HMAP(nsp) + (nsp->t_rows - 1); /* Fill the map. */ nsp->gp = sp->gp; if (vs_sm_fill(nsp, nsp->lno, P_FILL)) return (1); /* * The new screen replaces the old screen in the parent/child list. * We insert the new screen after the old one. If we're exiting, * the exit will delete the old one, if we're foregrounding, the fg * code will move the old one to the background queue. */ TAILQ_REMOVE(gp->hq, nsp, q); TAILQ_INSERT_AFTER(gp->dq, sp, nsp, q); /* * Don't change the screen's cursor information other than to * note that the cursor is wrong. */ F_SET(VIP(nsp), VIP_CUR_INVALID); /* Draw the new screen from scratch, and add a status line. */ F_SET(nsp, SC_SCR_REDRAW | SC_STATUS); list[0] = nsp; list[1] = NULL; (void)gp->scr_discard(sp, list); return (0); } /* * vs_resize -- * Change the absolute size of the current screen. * * PUBLIC: int vs_resize(SCR *, long, adj_t); */ int vs_resize(SCR *sp, long int count, adj_t adj) { GS *gp; SCR *g, *s, *prev, *next, *list[3] = {NULL, NULL, NULL}; size_t g_off, s_off; gp = sp->gp; /* * Figure out which screens will grow, which will shrink, and * make sure it's possible. */ if (count == 0) return (0); if (adj == A_SET) { if (sp->t_maxrows == count) return (0); if (sp->t_maxrows > count) { adj = A_DECREASE; count = sp->t_maxrows - count; } else { adj = A_INCREASE; count = count - sp->t_maxrows; } } /* Find first overlapping screen */ for (next = TAILQ_NEXT(sp, q); next != NULL && (next->coff >= sp->coff + sp->cols || next->coff + next->cols <= sp->coff); next = TAILQ_NEXT(next, q)); /* See if we can use it */ if (next != NULL && (sp->coff != next->coff || sp->cols != next->cols)) next = NULL; for (prev = TAILQ_PREV(sp, _dqh, q); prev != NULL && (prev->coff >= sp->coff + sp->cols || prev->coff + prev->cols <= sp->coff); prev = TAILQ_PREV(prev, _dqh, q)); if (prev != NULL && (sp->coff != prev->coff || sp->cols != prev->cols)) prev = NULL; g_off = s_off = 0; if (adj == A_DECREASE) { if (count < 0) count = -count; s = sp; if (s->t_maxrows < MINIMUM_SCREEN_ROWS + count) goto toosmall; if ((g = prev) == NULL) { if ((g = next) == NULL) goto toobig; g_off = -count; } else s_off = count; } else { g = sp; if ((s = next) != NULL && s->t_maxrows >= MINIMUM_SCREEN_ROWS + count) s_off = count; else s = NULL; if (s == NULL) { if ((s = prev) == NULL) { toobig: msgq(sp, M_BERR, adj == A_DECREASE ? "227|The screen cannot shrink" : "228|The screen cannot grow"); return (1); } if (s->t_maxrows < MINIMUM_SCREEN_ROWS + count) { toosmall: msgq(sp, M_BERR, "226|The screen can only shrink to %d rows", MINIMUM_SCREEN_ROWS); return (1); } g_off = -count; } } /* * Fix up the screens; we could optimize the reformatting of the * screen, but this isn't likely to be a common enough operation * to make it worthwhile. */ s->rows += -count; s->roff += s_off; g->rows += count; g->roff += g_off; g->t_rows += count; if (g->t_minrows == g->t_maxrows) g->t_minrows += count; g->t_maxrows += count; _TMAP(g) += count; F_SET(g, SC_SCR_REFORMAT | SC_STATUS); s->t_rows -= count; s->t_maxrows -= count; if (s->t_minrows > s->t_maxrows) s->t_minrows = s->t_maxrows; _TMAP(s) -= count; F_SET(s, SC_SCR_REFORMAT | SC_STATUS); /* XXXX */ list[0] = g; list[1] = s; gp->scr_discard(0, list); return (0); } /* * vs_getbg -- * Get the specified background screen, or, if name is NULL, the first * background screen. */ static SCR * vs_getbg(SCR *sp, char *name) { GS *gp; SCR *nsp; char *p; gp = sp->gp; /* If name is NULL, return the first background screen on the list. */ if (name == NULL) return (TAILQ_FIRST(gp->hq)); /* Search for a full match. */ TAILQ_FOREACH(nsp, gp->hq, q) if (!strcmp(nsp->frp->name, name)) break; if (nsp != NULL) return (nsp); /* Search for a last-component match. */ TAILQ_FOREACH(nsp, gp->hq, q) { if ((p = strrchr(nsp->frp->name, '/')) == NULL) p = nsp->frp->name; else ++p; if (!strcmp(p, name)) break; } if (nsp != NULL) return (nsp); return (NULL); }