/****************************************************************************
- * Copyright (c) 1998 Free Software Foundation, Inc. *
+ * Copyright (c) 1998-2015,2016 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
*****************************************************************************/
#include <curses.priv.h>
-#include <term.h> /* for back_color_erase */
-MODULE_ID("$Id: hashmap.c,v 1.34 1999/11/28 00:10:57 tom Exp $")
+#ifndef CUR
+#define CUR SP_TERMTYPE
+#endif
+
+MODULE_ID("$Id: hashmap.c,v 1.66 2016/05/28 23:32:40 tom Exp $")
#ifdef HASHDEBUG
# define _tracef printf
# undef TR
+# ifdef TRACE
# define TR(n, a) if (_nc_tracing & (n)) { _tracef a ; putchar('\n'); }
+# else
+# define TR(n, a) { _tracef a ; putchar('\n'); }
+# endif
# undef screen_lines
-# define screen_lines MAXLINES
-# define TEXTWIDTH 1
+# define screen_lines(sp) MAXLINES
+# define TEXTWIDTH(sp) 1
int oldnums[MAXLINES], reallines[MAXLINES];
-static chtype oldtext[MAXLINES][TEXTWIDTH], newtext[MAXLINES][TEXTWIDTH];
-# define OLDNUM(n) oldnums[n]
-# define OLDTEXT(n) oldtext[n]
-# define NEWTEXT(m) newtext[m]
-# define PENDING(n) 1
+static NCURSES_CH_T oldtext[MAXLINES][TEXTWIDTH(sp)];
+static NCURSES_CH_T newtext[MAXLINES][TEXTWIDTH(sp)];
+# define OLDNUM(sp,n) oldnums[n]
+# define OLDTEXT(sp,n) oldtext[n]
+# define NEWTEXT(sp,m) newtext[m]
+# define PENDING(sp,n) 1
#else /* !HASHDEBUG */
-# define OLDNUM(n) _nc_oldnums[n]
-# define OLDTEXT(n) curscr->_line[n].text
-# define NEWTEXT(m) newscr->_line[m].text
-# define TEXTWIDTH (curscr->_maxx+1)
-# define PENDING(n) (newscr->_line[n].firstchar != _NOCHANGE)
+# define OLDNUM(sp,n) (sp)->_oldnum_list[n]
+# define OLDTEXT(sp,n) CurScreen(sp)->_line[n].text
+# define NEWTEXT(sp,m) NewScreen(sp)->_line[m].text
+# define TEXTWIDTH(sp) (CurScreen(sp)->_maxx + 1)
+# define PENDING(sp,n) (NewScreen(sp)->_line[n].firstchar != _NOCHANGE)
#endif /* !HASHDEBUG */
-#define oldhash (SP->oldhash)
-#define newhash (SP->newhash)
+#define oldhash(sp) ((sp)->oldhash)
+#define newhash(sp) ((sp)->newhash)
+#define hashtab(sp) ((sp)->hashtab)
+#define lines_alloc(sp) ((sp)->hashtab_len)
+
+#if USE_WIDEC_SUPPORT
+#define HASH_VAL(ch) (ch.chars[0])
+#else
+#define HASH_VAL(ch) (ch)
+#endif
-static inline unsigned long hash(chtype *text)
+static const NCURSES_CH_T blankchar = NewChar(BLANK_TEXT);
+
+static NCURSES_INLINE unsigned long
+hash(SCREEN *sp, NCURSES_CH_T * text)
{
int i;
- chtype ch;
+ NCURSES_CH_T ch;
unsigned long result = 0;
- for (i = TEXTWIDTH; i>0; i--)
- {
+ (void) sp;
+
+ for (i = TEXTWIDTH(sp); i > 0; i--) {
ch = *text++;
- result += (result<<5) + ch;
+ result += (result << 5) + (unsigned long) HASH_VAL(ch);
}
return result;
}
/* approximate update cost */
-static int update_cost(chtype *from,chtype *to)
+static int
+update_cost(SCREEN *sp, NCURSES_CH_T * from, NCURSES_CH_T * to)
{
- int cost=0;
+ int cost = 0;
int i;
+ (void) sp;
- for (i=TEXTWIDTH; i>0; i--)
- if (*from++ != *to++)
+ for (i = TEXTWIDTH(sp); i > 0; i--, from++, to++)
+ if (!(CharEq(*from, *to)))
cost++;
return cost;
}
-static int update_cost_from_blank(chtype *to)
+
+static int
+update_cost_from_blank(SCREEN *sp, NCURSES_CH_T * to)
{
- int cost=0;
+ int cost = 0;
int i;
- chtype blank = BLANK;
+ NCURSES_CH_T blank = blankchar;
+ (void) sp;
if (back_color_erase)
- blank |= (stdscr->_bkgd & A_COLOR);
+ SetPair(blank, GetPair(stdscr->_nc_bkgd));
- for (i=TEXTWIDTH; i>0; i--)
- if (blank != *to++)
+ for (i = TEXTWIDTH(sp); i > 0; i--, to++)
+ if (!(CharEq(blank, *to)))
cost++;
return cost;
* Returns true when moving line 'from' to line 'to' seems to be cost
* effective. 'blank' indicates whether the line 'to' would become blank.
*/
-static inline bool cost_effective(const int from, const int to, const bool blank)
+static NCURSES_INLINE bool
+cost_effective(SCREEN *sp, const int from, const int to, const int blank)
{
int new_from;
if (from == to)
return FALSE;
- new_from = OLDNUM(from);
+ new_from = OLDNUM(sp, from);
if (new_from == _NEWINDEX)
new_from = from;
* On the left side of >= is the cost before moving;
* on the right side -- cost after moving.
*/
- return (((blank ? update_cost_from_blank(NEWTEXT(to))
- : update_cost(OLDTEXT(to),NEWTEXT(to)))
- + update_cost(OLDTEXT(new_from),NEWTEXT(from)))
- >= ((new_from==from ? update_cost_from_blank(NEWTEXT(from))
- : update_cost(OLDTEXT(new_from),NEWTEXT(from)))
- + update_cost(OLDTEXT(from),NEWTEXT(to)))) ? TRUE : FALSE;
-}
-
-
-typedef struct
-{
- unsigned long hashval;
- int oldcount, newcount;
- int oldindex, newindex;
+ return (((blank ? update_cost_from_blank(sp, NEWTEXT(sp, to))
+ : update_cost(sp, OLDTEXT(sp, to), NEWTEXT(sp, to)))
+ + update_cost(sp, OLDTEXT(sp, new_from), NEWTEXT(sp, from)))
+ >= ((new_from == from ? update_cost_from_blank(sp, NEWTEXT(sp, from))
+ : update_cost(sp, OLDTEXT(sp, new_from), NEWTEXT(sp, from)))
+ + update_cost(sp, OLDTEXT(sp, from), NEWTEXT(sp, to))))
+ ? TRUE : FALSE;
}
- sym;
-
-static sym *hashtab=0;
-static int lines_alloc=0;
-static void grow_hunks(void)
+static void
+grow_hunks(SCREEN *sp)
{
- int start, end, shift;
- int back_limit, forward_limit; /* limits for cells to fill */
- int back_ref_limit, forward_ref_limit; /* limits for refrences */
+ int back_limit; /* limits for cells to fill */
+ int back_ref_limit; /* limit for references */
int i;
int next_hunk;
back_ref_limit = 0;
i = 0;
- while (i < screen_lines && OLDNUM(i) == _NEWINDEX)
+ while (i < screen_lines(sp) && OLDNUM(sp, i) == _NEWINDEX)
i++;
- for ( ; i < screen_lines; i=next_hunk)
- {
- start = i;
- shift = OLDNUM(i) - i;
+ for (; i < screen_lines(sp); i = next_hunk) {
+ int forward_limit;
+ int forward_ref_limit;
+ int end;
+ int start = i;
+ int shift = OLDNUM(sp, i) - i;
/* get forward limit */
- i = start+1;
- while (i < screen_lines && OLDNUM(i) != _NEWINDEX && OLDNUM(i) - i == shift)
+ i = start + 1;
+ while (i < screen_lines(sp)
+ && OLDNUM(sp, i) != _NEWINDEX
+ && OLDNUM(sp, i) - i == shift)
i++;
end = i;
- while (i < screen_lines && OLDNUM(i) == _NEWINDEX)
+ while (i < screen_lines(sp) && OLDNUM(sp, i) == _NEWINDEX)
i++;
next_hunk = i;
forward_limit = i;
- if (i >= screen_lines || OLDNUM(i) >= i)
+ if (i >= screen_lines(sp) || OLDNUM(sp, i) >= i)
forward_ref_limit = i;
else
- forward_ref_limit = OLDNUM(i);
+ forward_ref_limit = OLDNUM(sp, i);
- i = start-1;
+ i = start - 1;
/* grow back */
if (shift < 0)
back_limit = back_ref_limit + (-shift);
- while (i >= back_limit)
- {
- if(newhash[i] == oldhash[i+shift]
- || cost_effective(i+shift, i, shift<0))
- {
- OLDNUM(i) = i+shift;
+ while (i >= back_limit) {
+ if (newhash(sp)[i] == oldhash(sp)[i + shift]
+ || cost_effective(sp, i + shift, i, shift < 0)) {
+ OLDNUM(sp, i) = i + shift;
TR(TRACE_UPDATE | TRACE_MOVE,
("connected new line %d to old line %d (backward continuation)",
- i, i+shift));
- }
- else
- {
+ i, i + shift));
+ } else {
TR(TRACE_UPDATE | TRACE_MOVE,
("not connecting new line %d to old line %d (backward continuation)",
- i, i+shift));
+ i, i + shift));
break;
}
i--;
/* grow forward */
if (shift > 0)
forward_limit = forward_ref_limit - shift;
- while (i < forward_limit)
- {
- if(newhash[i] == oldhash[i+shift]
- || cost_effective(i+shift, i, shift>0))
- {
- OLDNUM(i) = i+shift;
+ while (i < forward_limit) {
+ if (newhash(sp)[i] == oldhash(sp)[i + shift]
+ || cost_effective(sp, i + shift, i, shift > 0)) {
+ OLDNUM(sp, i) = i + shift;
TR(TRACE_UPDATE | TRACE_MOVE,
("connected new line %d to old line %d (forward continuation)",
- i, i+shift));
- }
- else
- {
+ i, i + shift));
+ } else {
TR(TRACE_UPDATE | TRACE_MOVE,
("not connecting new line %d to old line %d (forward continuation)",
- i, i+shift));
+ i, i + shift));
break;
}
i++;
}
}
-void _nc_hash_map(void)
+NCURSES_EXPORT(void)
+NCURSES_SP_NAME(_nc_hash_map) (NCURSES_SP_DCL0)
{
- sym *sp;
+ HASHMAP *hsp;
register int i;
- int start, shift, size;
-
- if (screen_lines > lines_alloc)
- {
- if (hashtab)
- free (hashtab);
- hashtab = typeMalloc(sym, (screen_lines+1)*2);
- if (!hashtab)
- {
- if (oldhash)
- {
- FreeAndNull(oldhash);
+ if (screen_lines(SP_PARM) > lines_alloc(SP_PARM)) {
+ if (hashtab(SP_PARM))
+ free(hashtab(SP_PARM));
+ hashtab(SP_PARM) = typeMalloc(HASHMAP,
+ ((size_t) screen_lines(SP_PARM) + 1) * 2);
+ if (!hashtab(SP_PARM)) {
+ if (oldhash(SP_PARM)) {
+ FreeAndNull(oldhash(SP_PARM));
}
- lines_alloc = 0;
+ lines_alloc(SP_PARM) = 0;
return;
}
- lines_alloc = screen_lines;
+ lines_alloc(SP_PARM) = screen_lines(SP_PARM);
}
- if (oldhash && newhash)
- {
+ if (oldhash(SP_PARM) && newhash(SP_PARM)) {
/* re-hash only changed lines */
- for (i = 0; i < screen_lines; i++)
- {
- if (PENDING(i))
- newhash[i] = hash(NEWTEXT(i));
+ for (i = 0; i < screen_lines(SP_PARM); i++) {
+ if (PENDING(SP_PARM, i))
+ newhash(SP_PARM)[i] = hash(SP_PARM, NEWTEXT(SP_PARM, i));
}
- }
- else
- {
+ } else {
/* re-hash all */
- if (oldhash == 0)
- oldhash = typeCalloc (unsigned long, screen_lines);
- if (newhash == 0)
- newhash = typeCalloc (unsigned long, screen_lines);
- if (!oldhash || !newhash)
- return; /* malloc failure */
- for (i = 0; i < screen_lines; i++)
- {
- newhash[i] = hash(NEWTEXT(i));
- oldhash[i] = hash(OLDTEXT(i));
+ if (oldhash(SP_PARM) == 0)
+ oldhash(SP_PARM) = typeCalloc(unsigned long,
+ (size_t) screen_lines(SP_PARM));
+ if (newhash(SP_PARM) == 0)
+ newhash(SP_PARM) = typeCalloc(unsigned long,
+ (size_t) screen_lines(SP_PARM));
+ if (!oldhash(SP_PARM) || !newhash(SP_PARM))
+ return; /* malloc failure */
+ for (i = 0; i < screen_lines(SP_PARM); i++) {
+ newhash(SP_PARM)[i] = hash(SP_PARM, NEWTEXT(SP_PARM, i));
+ oldhash(SP_PARM)[i] = hash(SP_PARM, OLDTEXT(SP_PARM, i));
}
}
#ifdef HASH_VERIFY
- for (i = 0; i < screen_lines; i++)
- {
- if(newhash[i] != hash(NEWTEXT(i)))
- fprintf(stderr,"error in newhash[%d]\n",i);
- if(oldhash[i] != hash(OLDTEXT(i)))
- fprintf(stderr,"error in oldhash[%d]\n",i);
+ for (i = 0; i < screen_lines(SP_PARM); i++) {
+ if (newhash(SP_PARM)[i] != hash(SP_PARM, NEWTEXT(SP_PARM, i)))
+ fprintf(stderr, "error in newhash[%d]\n", i);
+ if (oldhash(SP_PARM)[i] != hash(SP_PARM, OLDTEXT(SP_PARM, i)))
+ fprintf(stderr, "error in oldhash[%d]\n", i);
}
#endif
/*
* Set up and count line-hash values.
*/
- memset(hashtab, '\0', sizeof(*hashtab)*(screen_lines+1)*2);
- for (i = 0; i < screen_lines; i++)
- {
- unsigned long hashval = oldhash[i];
-
- for (sp = hashtab; sp->hashval; sp++)
- if (sp->hashval == hashval)
+ memset(hashtab(SP_PARM), '\0',
+ sizeof(*(hashtab(SP_PARM)))
+ * ((size_t) screen_lines(SP_PARM) + 1) * 2);
+ for (i = 0; i < screen_lines(SP_PARM); i++) {
+ unsigned long hashval = oldhash(SP_PARM)[i];
+
+ for (hsp = hashtab(SP_PARM); hsp->hashval; hsp++)
+ if (hsp->hashval == hashval)
break;
- sp->hashval = hashval; /* in case this is a new entry */
- sp->oldcount++;
- sp->oldindex = i;
+ hsp->hashval = hashval; /* in case this is a new entry */
+ hsp->oldcount++;
+ hsp->oldindex = i;
}
- for (i = 0; i < screen_lines; i++)
- {
- unsigned long hashval = newhash[i];
+ for (i = 0; i < screen_lines(SP_PARM); i++) {
+ unsigned long hashval = newhash(SP_PARM)[i];
- for (sp = hashtab; sp->hashval; sp++)
- if (sp->hashval == hashval)
+ for (hsp = hashtab(SP_PARM); hsp->hashval; hsp++)
+ if (hsp->hashval == hashval)
break;
- sp->hashval = hashval; /* in case this is a new entry */
- sp->newcount++;
- sp->newindex = i;
+ hsp->hashval = hashval; /* in case this is a new entry */
+ hsp->newcount++;
+ hsp->newindex = i;
- OLDNUM(i) = _NEWINDEX; /* initialize old indices array */
+ OLDNUM(SP_PARM, i) = _NEWINDEX; /* initialize old indices array */
}
/*
* extending hunks by cost_effective. Otherwise, it does not
* have any side effects.
*/
- for (sp = hashtab; sp->hashval; sp++)
- if (sp->oldcount == 1 && sp->newcount == 1
- && sp->oldindex != sp->newindex)
- {
+ for (hsp = hashtab(SP_PARM); hsp->hashval; hsp++)
+ if (hsp->oldcount == 1 && hsp->newcount == 1
+ && hsp->oldindex != hsp->newindex) {
TR(TRACE_UPDATE | TRACE_MOVE,
("new line %d is hash-identical to old line %d (unique)",
- sp->newindex, sp->oldindex));
- OLDNUM(sp->newindex) = sp->oldindex;
+ hsp->newindex, hsp->oldindex));
+ OLDNUM(SP_PARM, hsp->newindex) = hsp->oldindex;
}
- grow_hunks();
+ grow_hunks(SP_PARM);
/*
* Eliminate bad or impossible shifts -- this includes removing
* those which are to be moved too far, they are likely to destroy
* more than carry.
*/
- for (i = 0; i < screen_lines; )
- {
- while (i < screen_lines && OLDNUM(i) == _NEWINDEX)
+ for (i = 0; i < screen_lines(SP_PARM);) {
+ int start, shift, size;
+
+ while (i < screen_lines(SP_PARM) && OLDNUM(SP_PARM, i) == _NEWINDEX)
i++;
- if (i >= screen_lines)
+ if (i >= screen_lines(SP_PARM))
break;
start = i;
- shift = OLDNUM(i) - i;
+ shift = OLDNUM(SP_PARM, i) - i;
i++;
- while (i < screen_lines && OLDNUM(i) != _NEWINDEX && OLDNUM(i) - i == shift)
+ while (i < screen_lines(SP_PARM)
+ && OLDNUM(SP_PARM, i) != _NEWINDEX
+ && OLDNUM(SP_PARM, i) - i == shift)
i++;
size = i - start;
- if (size < 3 || size+min(size/8,2) < abs(shift))
- {
- while (start < i)
- {
- OLDNUM(start) = _NEWINDEX;
+ if (size < 3 || size + min(size / 8, 2) < abs(shift)) {
+ while (start < i) {
+ OLDNUM(SP_PARM, start) = _NEWINDEX;
start++;
}
}
}
/* After clearing invalid hunks, try grow the rest. */
- grow_hunks();
+ grow_hunks(SP_PARM);
+}
-#if NO_LEAKS
- FreeAndNull(hashtab);
- lines_alloc = 0;
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(void)
+_nc_hash_map(void)
+{
+ NCURSES_SP_NAME(_nc_hash_map) (CURRENT_SCREEN);
+}
#endif
+
+NCURSES_EXPORT(void)
+NCURSES_SP_NAME(_nc_make_oldhash) (NCURSES_SP_DCLx int i)
+{
+ if (oldhash(SP_PARM))
+ oldhash(SP_PARM)[i] = hash(SP_PARM, OLDTEXT(SP_PARM, i));
}
-void _nc_make_oldhash(int i)
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(void)
+_nc_make_oldhash(int i)
{
- if (oldhash)
- oldhash[i] = hash(OLDTEXT(i));
+ NCURSES_SP_NAME(_nc_make_oldhash) (CURRENT_SCREEN, i);
}
+#endif
-void _nc_scroll_oldhash(int n, int top, int bot)
+NCURSES_EXPORT(void)
+NCURSES_SP_NAME(_nc_scroll_oldhash) (NCURSES_SP_DCLx int n, int top, int bot)
{
- int size;
+ size_t size;
int i;
- if (!oldhash)
+ if (!oldhash(SP_PARM))
return;
- size = sizeof(*oldhash) * (bot-top+1-abs(n));
- if (n > 0)
- {
- memmove (oldhash+top, oldhash+top+n, size);
- for (i = bot; i > bot-n; i--)
- oldhash[i] = hash(OLDTEXT(i));
- }
- else
- {
- memmove (oldhash+top-n, oldhash+top, size);
- for (i = top; i < top-n; i++)
- oldhash[i] = hash(OLDTEXT(i));
+ size = sizeof(*(oldhash(SP_PARM))) * (size_t) (bot - top + 1 - abs(n));
+ if (n > 0) {
+ memmove(oldhash(SP_PARM) + top, oldhash(SP_PARM) + top + n, size);
+ for (i = bot; i > bot - n; i--)
+ oldhash(SP_PARM)[i] = hash(SP_PARM, OLDTEXT(SP_PARM, i));
+ } else {
+ memmove(oldhash(SP_PARM) + top - n, oldhash(SP_PARM) + top, size);
+ for (i = top; i < top - n; i++)
+ oldhash(SP_PARM)[i] = hash(SP_PARM, OLDTEXT(SP_PARM, i));
}
}
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(void)
+_nc_scroll_oldhash(int n, int top, int bot)
+{
+ NCURSES_SP_NAME(_nc_scroll_oldhash) (CURRENT_SCREEN, n, top, bot);
+}
+#endif
#ifdef HASHDEBUG
static void
usage(void)
{
- static const char *table[] = {
+ static const char *table[] =
+ {
"hashmap test-driver",
"",
"# comment",
"? this message"
};
size_t n;
- for (n = 0; n < sizeof(table)/sizeof(table[0]); n++)
+ for (n = 0; n < sizeof(table) / sizeof(table[0]); n++)
fprintf(stderr, "%s\n", table[n]);
}
int
-main(int argc GCC_UNUSED, char *argv[] GCC_UNUSED)
+main(int argc GCC_UNUSED, char *argv[]GCC_UNUSED)
{
- char line[BUFSIZ], *st;
- int n;
+ char line[BUFSIZ], *st;
+ int n;
- SP = typeCalloc(SCREEN,1);
- for (n = 0; n < screen_lines; n++)
- {
+ if (setupterm(NULL, fileno(stdout), (int *) 0) == ERR)
+ return EXIT_FAILURE;
+ (void) _nc_alloc_screen();
+
+ for (n = 0; n < screen_lines(sp); n++) {
reallines[n] = n;
oldnums[n] = _NEWINDEX;
- oldtext[n][0] = newtext[n][0] = '.';
+ CharOf(oldtext[n][0]) = CharOf(newtext[n][0]) = '.';
}
- if (isatty(fileno(stdin)))
+ if (NC_ISATTY(fileno(stdin)))
usage();
#ifdef TRACE
_nc_tracing = TRACE_MOVE;
#endif
- for (;;)
- {
+ for (;;) {
/* grab a test command */
- if (fgets(line, sizeof(line), stdin) == (char *)NULL)
- exit(EXIT_SUCCESS);
+ if (fgets(line, sizeof(line), stdin) == (char *) NULL)
+ break;
- switch(line[0])
- {
- case '#': /* comment */
+ switch (line[0]) {
+ case '#': /* comment */
(void) fputs(line, stderr);
break;
- case 'l': /* get initial line number vector */
- for (n = 0; n < screen_lines; n++)
- {
+ case 'l': /* get initial line number vector */
+ for (n = 0; n < screen_lines(sp); n++) {
reallines[n] = n;
oldnums[n] = _NEWINDEX;
}
do {
oldnums[n++] = atoi(st);
} while
- ((st = strtok((char *)NULL, " ")) != 0);
+ ((st = strtok((char *) NULL, " ")) != 0);
break;
- case 'n': /* use following letters as text of new lines */
- for (n = 0; n < screen_lines; n++)
- newtext[n][0] = '.';
- for (n = 0; n < screen_lines; n++)
- if (line[n+1] == '\n')
+ case 'n': /* use following letters as text of new lines */
+ for (n = 0; n < screen_lines(sp); n++)
+ CharOf(newtext[n][0]) = '.';
+ for (n = 0; n < screen_lines(sp); n++)
+ if (line[n + 1] == '\n')
break;
else
- newtext[n][0] = line[n+1];
+ CharOf(newtext[n][0]) = line[n + 1];
break;
- case 'o': /* use following letters as text of old lines */
- for (n = 0; n < screen_lines; n++)
- oldtext[n][0] = '.';
- for (n = 0; n < screen_lines; n++)
- if (line[n+1] == '\n')
+ case 'o': /* use following letters as text of old lines */
+ for (n = 0; n < screen_lines(sp); n++)
+ CharOf(oldtext[n][0]) = '.';
+ for (n = 0; n < screen_lines(sp); n++)
+ if (line[n + 1] == '\n')
break;
else
- oldtext[n][0] = line[n+1];
+ CharOf(oldtext[n][0]) = line[n + 1];
break;
- case 'd': /* dump state of test arrays */
+ case 'd': /* dump state of test arrays */
#ifdef TRACE
_nc_linedump();
#endif
(void) fputs("Old lines: [", stdout);
- for (n = 0; n < screen_lines; n++)
- putchar(oldtext[n][0]);
+ for (n = 0; n < screen_lines(sp); n++)
+ putchar(CharOf(oldtext[n][0]));
putchar(']');
putchar('\n');
(void) fputs("New lines: [", stdout);
- for (n = 0; n < screen_lines; n++)
- putchar(newtext[n][0]);
+ for (n = 0; n < screen_lines(sp); n++)
+ putchar(CharOf(newtext[n][0]));
putchar(']');
putchar('\n');
break;
- case 'h': /* apply hash mapper and see scroll optimization */
+ case 'h': /* apply hash mapper and see scroll optimization */
_nc_hash_map();
(void) fputs("Result:\n", stderr);
#ifdef TRACE
_nc_scroll_optimize();
(void) fputs("Done.\n", stderr);
break;
+ default:
case '?':
usage();
break;
}
}
+#if NO_LEAKS
+ _nc_free_and_exit(EXIT_SUCCESS);
+#else
return EXIT_SUCCESS;
+#endif
}
#endif /* HASHDEBUG */