/*	$OpenBSD: hashmap.c,v 1.8 2010/01/12 23:22:07 nicm Exp $	*/

/****************************************************************************

 * Copyright (c) 1998-2006,2007 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            *

 * "Software"), to deal in the Software without restriction, including      *

 * without limitation the rights to use, copy, modify, merge, publish,      *

 * distribute, distribute with modifications, sublicense, and/or sell       *

 * copies of the Software, and to permit persons to whom the Software is    *

 * furnished to do so, subject to the following conditions:                 *

 *                                                                          *

 * The above copyright notice and this permission notice shall be included  *

 * in all copies or substantial portions of the Software.                   *

 *                                                                          *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *

 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *

 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *

 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *

 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *

 * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *

 *                                                                          *

 * Except as contained in this notice, the name(s) of the above copyright   *

 * holders shall not be used in advertising or otherwise to promote the     *

 * sale, use or other dealings in this Software without prior written       *

 * authorization.                                                           *

 ****************************************************************************/

/****************************************************************************

 *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *

 *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *

 ****************************************************************************/

/******************************************************************************

NAME

   hashmap.c -- fill in scramble vector based on text hashes

SYNOPSIS

   void _nc_hash_map(void)

DESCRIPTION:

   This code attempts to recognize pairs of old and new lines in the physical

and virtual screens.  When a line pair is recognized, the old line index is

placed in the oldindex member of the virtual screen line, to be used by the

vertical-motion optimizer portion of the update logic (see hardscroll.c).

   Line pairs are recognized by applying a modified Heckel's algorithm,

sped up by hashing.  If a line hash is unique in both screens, those

lines must be a pair. Then if the lines just before or after the pair

are the same or similar, they are a pair too.

   We don't worry about false pairs produced by hash collisions, on the

assumption that such cases are rare and will only make the latter stages

of update less efficient, not introduce errors.

HOW TO TEST THIS:

Use the following production:

hashmap: hashmap.c

	$(CC) -g -DHASHDEBUG hashmap.c hardscroll.c ../objects/lib_trace.o -o hashmap

AUTHOR

    Eric S. Raymond <esr@snark.thyrsus.com>, May 1996

    Bug fixes and improvements by Alexander V. Lukyanov <lav@yars.free.net>, 1997

*****************************************************************************/

#include <curses.priv.h>

#include <term.h>		/* for back_color_erase */

MODULE_ID("$Id: hashmap.c,v 1.8 2010/01/12 23:22:07 nicm Exp $")

#ifdef HASHDEBUG

# define _tracef	printf

# undef TR

# define TR(n, a)	if (_nc_tracing & (n)) { _tracef a ; putchar('\n'); }

# undef screen_lines

# define screen_lines MAXLINES

# define TEXTWIDTH	1

int oldnums[MAXLINES], reallines[MAXLINES];

static NCURSES_CH_T oldtext[MAXLINES][TEXTWIDTH];

static NCURSES_CH_T newtext[MAXLINES][TEXTWIDTH];

# define OLDNUM(n)	oldnums[n]

# define OLDTEXT(n)	oldtext[n]

# define NEWTEXT(m)	newtext[m]

# define PENDING(n)     1

#else /* !HASHDEBUG */

# define OLDNUM(n)	SP->_oldnum_list[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)

#endif /* !HASHDEBUG */

#define oldhash		(SP->oldhash)

#define newhash		(SP->newhash)

#define hashtab		(SP->hashtab)

#define lines_alloc	(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 NCURSES_INLINE unsigned long

hash(NCURSES_CH_T * text)

{

    int i;

    unsigned long result = 0;

    }

}

/* approximate update cost */

static int

update_cost(NCURSES_CH_T * from, NCURSES_CH_T * to)

{

    int cost = 0;

    int i;

}

static int

update_cost_from_blank(NCURSES_CH_T * to)

{

    int cost = 0;

    int i;

    NCURSES_CH_T blank = blankchar;

}

/*

 * Returns true when moving line 'from' to line 'to' seems to be cost

 * effective. 'blank' indicates whether the line 'to' would become blank.

 */

static NCURSES_INLINE bool

cost_effective(const int from, const int to, const bool blank)

{

    int new_from;

    /*

     * On the left side of >= is the cost before moving;

     * on the right side -- cost after moving.

     */

}

static void

grow_hunks(void)

{

    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 i;

    int next_hunk;

    /*

     * This is tricky part.  We have unique pairs to use as anchors.

     * Use these to deduce the presence of spans of identical lines.

     */

    back_limit = 0;

    back_ref_limit = 0;

    i = 0;

	start = i;

	/* get forward limit */

	end = i;

	next_hunk = i;

	forward_limit = i;

	else

	    forward_ref_limit = OLDNUM(i);

	/* grow back */

		TR(TRACE_UPDATE | TRACE_MOVE,

		   ("connected new line %d to old line %d (backward continuation)",

		    i, i + shift));

	    } else {

		TR(TRACE_UPDATE | TRACE_MOVE,

		   ("not connecting new line %d to old line %d (backward continuation)",

		    i, i + shift));

		break;

	    }

	}

	i = end;

	/* grow forward */

		TR(TRACE_UPDATE | TRACE_MOVE,

		   ("connected new line %d to old line %d (forward continuation)",

		    i, i + shift));

	    } else {

		TR(TRACE_UPDATE | TRACE_MOVE,

		   ("not connecting new line %d to old line %d (forward continuation)",

		    i, i + shift));

		break;

	    }

	}

	back_ref_limit = back_limit = i;

    }

}

NCURSES_EXPORT(void)

_nc_hash_map(void)

{

    HASHMAP *sp;

    register int i;

    int start, shift, size;

	    }

	}

    }

	/* re-hash only changed lines */

	}

    } else {

	/* re-hash all */

	}

    }

#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);

    }

#endif

    /*

     * Set up and count line-hash values.

     */

		break;

    }

		break;

    }

    /*

     * Mark line pairs corresponding to unique hash pairs.

     *

     * We don't mark lines with offset 0, because it can make fail

     * extending hunks by cost_effective. Otherwise, it does not

     * have any side effects.

     */

	    TR(TRACE_UPDATE | TRACE_MOVE,

	       ("new line %d is hash-identical to old line %d (unique)",

		sp->newindex, sp->oldindex));

	}

    /*

     * Eliminate bad or impossible shifts -- this includes removing

     * those hunks which could not grow because of conflicts, as well

     * those which are to be moved too far, they are likely to destroy

     * more than carry.

     */

	    break;

	start = i;

	    }

	}

    }

    /* After clearing invalid hunks, try grow the rest. */

}

NCURSES_EXPORT(void)

_nc_make_oldhash(int i)

{

}

NCURSES_EXPORT(void)

_nc_scroll_oldhash(int n, int top, int bot)

{

    size_t size;

    int i;

    } else {

    }

}

#ifdef HASHDEBUG

static void

usage(void)

{

    static const char *table[] =

    {

	"hashmap test-driver",

	"",

	"#  comment",

	"l  get initial line number vector",

	"n  use following letters as text of new lines",

	"o  use following letters as text of old lines",

	"d  dump state of test arrays",

	"h  apply hash mapper and see scroll optimization",

	"?  this message"

    };

    size_t 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)

{

    char line[BUFSIZ], *st, *last;

    int 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;

	CharOf(oldtext[n][0]) = CharOf(newtext[n][0]) = '.';

    }

    if (isatty(fileno(stdin)))

	usage();

#ifdef TRACE

    _nc_tracing = TRACE_MOVE;

#endif

    for (;;) {

	/* grab a test command */

	if (fgets(line, sizeof(line), stdin) == (char *) NULL)

	    break;

	switch (line[0]) {

	case '#':		/* comment */

	    (void) fputs(line, stderr);

	    break;

	case 'l':		/* get initial line number vector */

	    for (n = 0; n < screen_lines; n++) {

		reallines[n] = n;

		oldnums[n] = _NEWINDEX;

	    }

	    n = 0;

	    st = strtok_r(line, " ", &last);

	    do {

		oldnums[n++] = atoi(st);

	    } while

		((st = strtok_r((char *) NULL, " "), &last) != 0);

	    break;

	case 'n':		/* use following letters as text of new lines */

	    for (n = 0; n < screen_lines; n++)

		CharOf(newtext[n][0]) = '.';

	    for (n = 0; n < screen_lines; n++)

		if (line[n + 1] == '\n')

		    break;

		else

		    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++)

		CharOf(oldtext[n][0]) = '.';

	    for (n = 0; n < screen_lines; n++)

		if (line[n + 1] == '\n')

		    break;

		else

		    CharOf(oldtext[n][0]) = line[n + 1];

	    break;

	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(CharOf(oldtext[n][0]));

	    putchar(']');

	    putchar('\n');

	    (void) fputs("New lines: [", stdout);

	    for (n = 0; n < screen_lines; n++)

		putchar(CharOf(newtext[n][0]));

	    putchar(']');

	    putchar('\n');

	    break;

	case 'h':		/* apply hash mapper and see scroll optimization */

	    _nc_hash_map();

	    (void) fputs("Result:\n", stderr);

#ifdef TRACE

	    _nc_linedump();

#endif

	    _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 */

/* hashmap.c ends here */