X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=ncurses%2Ftty%2Fhashmap.c;h=4a723865a4fdb0d425c3d67efd7bbe0050621865;hp=300ac9a3232a7b0a0450a71e6f267921aa3db3fb;hb=91fa4688e82518794fcf0c32a36f3fcca5e4c2d5;hpb=b1f61d9f3aa244512045a6b02e759825d7049d34 diff --git a/ncurses/tty/hashmap.c b/ncurses/tty/hashmap.c index 300ac9a3..4a723865 100644 --- a/ncurses/tty/hashmap.c +++ b/ncurses/tty/hashmap.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright (c) 1998 Free Software Foundation, Inc. * + * Copyright (c) 1998-2010,2011 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 * @@ -68,9 +68,12 @@ AUTHOR *****************************************************************************/ #include -#include /* 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.63 2011/10/22 16:34:50 tom Exp $") #ifdef HASHDEBUG @@ -81,61 +84,75 @@ MODULE_ID("$Id: hashmap.c,v 1.34 1999/11/28 00:10:57 tom Exp $") # define screen_lines MAXLINES # define TEXTWIDTH 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]; +static NCURSES_CH_T newtext[MAXLINES][TEXTWIDTH]; +# 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 const NCURSES_CH_T blankchar = NewChar(BLANK_TEXT); -static inline unsigned long hash(chtype *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--) - { + 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; - 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; 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; @@ -145,14 +162,15 @@ static int update_cost_from_blank(chtype *to) * 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; @@ -160,31 +178,21 @@ static inline bool cost_effective(const int from, const int to, const bool blank * 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, forward_limit; /* limits for cells to fill */ + int back_ref_limit, forward_ref_limit; /* limits for refrences */ int i; int next_hunk; @@ -196,46 +204,43 @@ static void grow_hunks(void) 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) - { + for (; i < screen_lines(sp); i = next_hunk) { start = i; - shift = OLDNUM(i) - i; + 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--; @@ -245,21 +250,17 @@ static void grow_hunks(void) /* 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++; @@ -271,92 +272,86 @@ static void grow_hunks(void) } } -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 */ } /* @@ -366,17 +361,16 @@ void _nc_hash_map(void) * 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 @@ -384,72 +378,89 @@ void _nc_hash_map(void) * 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);) { + 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", @@ -461,22 +472,24 @@ usage(void) "? 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; 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))) @@ -485,21 +498,18 @@ main(int argc GCC_UNUSED, char *argv[] GCC_UNUSED) #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; n++) { reallines[n] = n; oldnums[n] = _NEWINDEX; } @@ -508,46 +518,46 @@ main(int argc GCC_UNUSED, char *argv[] GCC_UNUSED) 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 */ + case 'n': /* use following letters as text of new lines */ for (n = 0; n < screen_lines; n++) - newtext[n][0] = '.'; + CharOf(newtext[n][0]) = '.'; for (n = 0; n < screen_lines; n++) - if (line[n+1] == '\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 */ + case 'o': /* use following letters as text of old lines */ for (n = 0; n < screen_lines; n++) - oldtext[n][0] = '.'; + CharOf(oldtext[n][0]) = '.'; for (n = 0; n < screen_lines; n++) - if (line[n+1] == '\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]); + putchar(CharOf(oldtext[n][0])); putchar(']'); putchar('\n'); (void) fputs("New lines: [", stdout); for (n = 0; n < screen_lines; n++) - putchar(newtext[n][0]); + 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 @@ -556,12 +566,17 @@ main(int argc GCC_UNUSED, char *argv[] GCC_UNUSED) _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 */