Release calc version 2.11.0t8.7

BUGS

@@ -68,16 +68,153 @@ importantly, fixes (in the form of a context diff patch) to:
 
 Known bugs:
 
-    * calc -i ignores quit binding or EOF input in some cases.  For example:
+    * When compiled on some Big Endian machines with BASEB forced to
+      be 16 (by setting LONGLONG_BITS= 0 in the Makefile), calc fails
+      a number of regression tests:
 
-	echo 'define f(x) { ' > myfile
-	calc -i read myfile
-	"./myfile", line 2: End-of-file in function body
-	Error in commands
-	>
+	4230: n = ftell(f)
+	4231: isnull(fputs(f,L,"\n",C,"\n",N,"\n"))
+	4232: fseek(f, n)
+	**** Non-true result (0): 4233: fgetstr(f) == LCN
+	4234: isnull(fclose(f))
+	4235: a = exp(27, 1e-1000)
+	4236: b = sqrt(7 + 5i, 1e-2000)
+	4252: fscanf(f, "%*[^|]%*c%n%*[^[]%*c%n", m, n) == 2
+	4253: fseek(f, m)
+	4254: fscanf(f, "%3c", x) == 1
+	**** Non-true result (0): 4255: x == "  Cu"
+	4256: fseek(f, n)
+	4257: fscanf(f, "%s", y) == 1
+	**** Non-true result (0): 4258: y == "Noll"
+	4259: isnull(fclose(f))
+	4260: x = rm("junk4200")
+	4261: Ending test_fileops
+	4600: Beginning test_fileop
+	4601: ttest(0,0): passed
+	4602: stest(): failed
+	**** search(f, "and") != 10 failed
+	4603: ttest(1,1): failed
+	**** Failure 2 for i = 0
+	4604: stest(): failed
+	**** search(f, "and") != 10 failed
+	4605: ttest(2,2): failed
+	**** Failure 2 for i = 0
+	4606: stest(): failed
+	**** search(f, "and") != 10 failed
+	4607: ttest(3,3): failed
+	**** Failure 2 for i = 0
+	4608: stest(): failed
+	**** search(f, "and") != 10 failed
+	4609: ttest(4,4): failed
+	**** Failure 2 for i = 0
+	4610: stest(): failed
+	**** search(f, "and") != 10 failed
+	4611: ttest(5,5): failed
+	**** Failure 2 for i = 0
+	4612: stest(): failed
+	**** search(f, "and") != 10 failed
+	4613: ttest(6,6): failed
+	**** Failure 2 for i = 0
+	4614: stest(): failed
+	**** search(f, "and") != 10 failed
+	4615: ttest(7,7): failed
+	**** Failure 2 for i = 0
+	4616: stest(): failed
+	**** search(f, "and") != 10 failed
+	4617: ttest(8,8): failed
+	**** Failure 2 for i = 0
+	4618: stest(): failed
+	**** search(f, "and") != 10 failed
+	4619: ttest(9,9): failed
+	**** Failure 1 for file size
+	4620: stest(): failed
+	**** fopen("junk4600", "w") failed
+	4621: Ending test_fileop
 
-      At this point, calc will re-prompt if you give it an EOF, or
-      type ^D while using lib/altbind or while ^D is bound to quit.
+	4700: Beginning test_charset
+	**** errcount:172  > ecnt:150
+	4701: "\a" == char(7)
+	4702: "\v" == char(11)
+	4703: "\e" == char(27)
+	5000: Beginning test_filesearch
+	5001: x = rm("-f", "junk5000")
+	5002: f = fopen("junk5000", "w")
+	**** Unable to open "junk5000" for writing
+
+	5100: Beginning test_newdecl
+	5101: test5100(1)
+	**** errcount:173  > ecnt:172
+	5102: a5100 == 0
+	5103: b5100 == 2
+	5104: test5100(1)
+	5927: test unused
+	5928: test unused
+	5929: test unused
+	**** errcount:180  > ecnt:177
+	5930: isassoc(loc) == 0
+	5931: isassoc(a) == 1
+	5932: isassoc(ofd) == 0
+	6079: test unused
+	6080: iserror(loc) == 0
+	6081: iserror(a) == 0
+	**** Non-true result (0): 6082: iserror(ofd) == 0
+	**** Non-true result (0): 6083: iserror(cfd) == 0
+	6084: iserror(blk) == 0
+	6085: iserror(nblk) == 0
+	6086: iserror(cfg) == 0
+	6139: test unused
+	6140: isfile(loc) == 0
+	6141: isfile(a) == 0
+	**** Non-true result (0): 6142: isfile(ofd) == 1
+	**** Non-true result (0): 6143: isfile(cfd) == 1
+	6144: isfile(blk) == 0
+	6145: isfile(nblk) == 0
+	6146: isfile(cfg) == 0
+
+	6700: Beginning test_blk
+	6701: A = blk(20);
+	**** errcount:181  > ecnt:180
+	6702: size(A) == 20
+	6703: sizeof(A) == 256
+	6704: B = A;
+	6822: C == A
+	6823: fs = fopen("junk6800", "w+");
+	6824: blkcpy(fs, A);
+	**** errcount:183  > ecnt:181
+	**** Non-true result (0): 6825: size(f) == 5
+	6826: blkcpy(B = blk(), fs);
+	**** errcount:184  > ecnt:183
+	**** Non-true result (0): 6827: B == A
+	6828: blkcpy(fs, A, ,100);
+	**** errcount:185  > ecnt:184
+	**** Non-true result (0): 6829: size(f) == 105
+	6830: blkcpy(C = blk(), fs, 2, ,100)
+	**** errcount:186  > ecnt:185
+	**** Non-true result (0): 6831: C == (blk() = {1,2}
+	6832: A = blk();
+	6833: blkcpy(A, "blk6800");
+	6834: size(A) == 9
+	6900: Beginning test_name
+	6901: x = rm("-f", "junk6900")
+	6902: f = fopen("junk6900", "w")
+	**** errcount:189  > ecnt:186
+	**** Non-true result (0): 6903: name(f) == "junk6900"
+	6904: fclose(f)
+	**** errcount:190  > ecnt:189
+	6905: name(f) == null()
+	6906: A = blk("blk6900")
+	6907: name(A) == "blk6900"
+	7002: B = blk();
+	7003: copy("abc yz", A);
+	7004: copy("defg", B);
+	**** errcount:191  > ecnt:190
+	7005: strprintf("%s", A) == "abc yz"
+	7006: strprintf("%s", A[2]) == "c yz"
+	7007: strprintf("%s", A[7]) == ""
+
+	9995: freeredc()
+	9996: freestatics()
+	**** 24 error(s) found  \/++\/
 
     We are sure some more bugs exist.  When you find them, please let
     us know!  See the above for details on how to report and were to

CHANGES

@@ -71,6 +71,73 @@ Following is the change from calc version 2.11.0t8 to date:
 
 	s = "curds" ' and ' "whey";
 
+    Added FNV hash to the regression test suite.
+
+    Added Ernest Bowen's <ernie@turing.une.edu.au> fix for the
+    FNV regression test of the hash() builtin function.
+
+    Added Ernest Bowen's <ernie@turing.une.edu.au> patch to improve
+    the way config("calc_debug").  Now the lower 4 bits of the
+    config("calc_debug") parameter have the following meaning:
+
+       n               Meaning of bit n of config("calc_debug")
+
+       0       Outputs shell commands prior to execution.
+
+       1       Outputs currently active functions when a quit instruction
+               is executed.
+
+       2       Some details of shs, shs1 and md5 hash states are included
+               in the output when these are printed.
+
+       3       When a function constructs a block value, tests are
+               made that the result has the properties required for use of
+               that block, e.g. that the pointer to the start of the
+               block is not NULL, and that its "length" is not negative.
+               A failure will result in a runtime error.
+
+    Changed the meaning of (config("calc_debug") & 1) from only printing
+    the shell commands (and pausing) while displaying help files into
+    the printing of any shell command prior to execution.
+
+    Documented the meaning of config("lib_debug"):
+
+	n               Meaning of bit n of config("lib_debug")
+
+	0       When a function is defined, redefined or undefined at
+		interactive level, a message saying what has been done
+		is displayed.
+
+	1       When a function is defined, redefined or undefined during
+		the reading of a file, a message saying what has been done
+		is displayed.
+
+	The value for config("lib_debug") in both oldstd and newstd is
+	3, but if calc is invoked with the -d flag, its initial value
+	is zero.  Thus, if calc is started without the -d flag, until
+	config("lib_debug") is changed, a message will be output when a
+	function is defined either interactively or during the reading
+	of a file.
+
+    Changed the calc lib files to reflect the new config("lib_debug")
+    bit field meaning.  Calc lib files that need to print extra information
+    should now do something such as:
+
+	if (config("lib_debug") & 3) {
+		print "obj xyz defined";
+		print "funcA([val1 [, val2]]) defined";
+		print "funcB(size, mass, ...) defined";
+	}
+
+    Fixed the help/custom_cal, help/new_custom, and help/copy files so
+    that they contain the correct contents instead of the 'usage' file.
+
+    Fixed problem with loss of bindings when .calc -i args runs into
+    an error while processing 'args' and drops into interactive mode
+    without the terminal bindings being set.
+
+    Fixed misc compiler warnings.
+
 
 Following is the change from calc version 2.11.0t7 to 2.11.0t7.5:
 

addop.c

@@ -164,8 +164,8 @@ endfunc(void)
 			size += dumpop(&fp->f_opcodes[size]);
 		}
 	}
-	if ((inputisterminal() && conf->lib_debug & 1) ||
-		(!inputisterminal() && conf->lib_debug & 2)) {
+	if ((inputisterminal() && conf->lib_debug & LIBDBG_STDIN_FUNC) ||
+		(!inputisterminal() && conf->lib_debug & LIBDBG_FILE_FUNC)) {
 		printf("%s(", fp->f_name);
 		for (index = 0; index <  fp->f_paramcount; index++) {
 			if (index)
@@ -238,8 +238,8 @@ rmuserfunc(char *name)
 		return;
 	freenumbers(functions[index]);
 	free(functions[index]);
-	if ((inputisterminal() && conf->lib_debug & 1) ||
-			(!inputisterminal() && conf->lib_debug & 2))
+	if ((inputisterminal() && conf->lib_debug & LIBDBG_STDIN_FUNC) ||
+		    (!inputisterminal() && conf->lib_debug & LIBDBG_FILE_FUNC))
 		printf("%s() undefined\n", name);
 	functions[index] = NULL;
 }

block.c

@@ -104,7 +104,7 @@ blkalloc(int len, int chunk)
 	/*
 	 * return BLOCK
 	 */
-	if (conf->calc_debug > 0) {
+	if (conf->calc_debug & CALCDBG_BLOCK) {
 		blkchk(nblk);
 	}
 	return nblk;
@@ -145,13 +145,11 @@ blk_free(BLOCK *blk)
  * debug time, we plan to call this function often.  Once we are satisfied,
  * we will normally call this code only in a few places.
  *
- * This function is normally called whenever the following builtins are called:
+ * If "calc_debug" has the bit corresponding to CALCDBG_BLOCK set, this
+ * function is called during execution of the following builtins:
  *
  *	alloc(), realloc(), free()
  *
- * unless the "calc_debug" is set to -1.  If "calc_debug" is > 0, then
- * most blk builtins will call this function.
- *
  * given:
  *	blk	- the BLOCK to check
  *
@@ -166,7 +164,7 @@ blkchk(BLOCK *blk)
 	/*
 	 * firewall - general sanity check
 	 */
-	if (conf->calc_debug == -1) {
+	if ((conf->calc_debug & CALCDBG_BLOCK) == 0) {
 		/* do nothing when debugging is disabled */
 		return;
 	}
@@ -231,7 +229,7 @@ blkrealloc(BLOCK *blk, int newlen, int newchunk)
 	/*
 	 * firewall
 	 */
-	if (conf->calc_debug != -1) {
+	if (conf->calc_debug & CALCDBG_BLOCK) {
 		blkchk(blk);
 	}
 
@@ -290,7 +288,7 @@ blkrealloc(BLOCK *blk, int newlen, int newchunk)
 			memset(blk->data, 0, blk->maxsize);
 		}
 		blk->datalen = 0;
-		if (conf->calc_debug > 0) {
+		if (conf->calc_debug & CALCDBG_BLOCK) {
 			blkchk(blk);
 		}
 		return blk;
@@ -321,7 +319,7 @@ blkrealloc(BLOCK *blk, int newlen, int newchunk)
 	/*
 	 * return realloced type
 	 */
-	if (conf->calc_debug > 0) {
+	if (conf->calc_debug & CALCDBG_BLOCK) {
 		blkchk(blk);
 	}
 	return blk;
@@ -349,7 +347,7 @@ blktrunc(BLOCK *blk)
 	/*
 	 * firewall
 	 */
-	if (conf->calc_debug != -1) {
+	if (conf->calc_debug & CALCDBG_BLOCK) {
 		blkchk(blk);
 	}
 
@@ -370,7 +368,7 @@ blktrunc(BLOCK *blk)
 		/*NOTREACHED*/
 	}
 	blk->data[0] = (USB8)0;
-	if (conf->calc_debug > 0) {
+	if (conf->calc_debug & CALCDBG_BLOCK) {
 		blkchk(blk);
 	}
 	return;

codegen.c

@@ -862,6 +862,17 @@ getstatement(LABEL *contlabel, LABEL *breaklabel, LABEL *nextcaselabel, LABEL *d
 		}
 		break;
 
+	case T_ABORT:
+		switch (gettoken()) {
+			case T_STRING:
+				addopone(OP_ABORT, tokenstring());
+				break;
+			default:
+				addopone(OP_ABORT, -1);
+				rescantoken();
+		}
+		break;
+
 	case T_SYMBOL:
 		if (nextchar() == ':') {	/****HACK HACK ****/
 			definelabel(tokensymbol());

config.h

@@ -134,13 +134,31 @@ struct config {
 	int blkverbose;		/* TRUE => print all lines if a block */
 	int blkbase;		/* block output base */
 	int blkfmt;		/* block output style */
-	int lib_debug;		/* library debug: <0 none, 0 default, >0 more */
-	int calc_debug;		/* internal debug: <0 none, 0 default,>0 more */
+	int lib_debug;		/* library debug, see LIB_DEBUG_XXX below */
+	int calc_debug;		/* internal debug, see CALC_DEBUG_XXX below */
 	int user_debug;		/* user defined debug value: 0 default */
 };
 typedef	struct config CONFIG;
 
 
+/*
+ * lib_debug bit masks
+ */
+#define LIBDBG_STDIN_FUNC   (0x00000001)    /* interactive func define debug */
+#define LIBDBG_FILE_FUNC    (0x00000002)    /* file read func define debug */
+#define LIBDBG_MASK	    (0x00000003)
+
+
+/*
+ * calc_debug bit masks
+ */
+#define CALCDBG_SYSTEM	    (0x00000001)    /* print system cmd prior to exec */
+#define CALCDBG_FUNC_QUIT   (0x00000002)    /* active functions when quit */
+#define CALCDBG_HASH_STATE  (0x00000004)    /* hash state details */
+#define CALCDBG_BLOCK	    (0x00000008)    /* block debug */
+#define CALCDBG_MASK	    (0x0000000f)
+
+
 /*
  * global configuration states and aliases
  */

func.c

@@ -1524,16 +1524,12 @@ static VALUE
 f_hash(int count, VALUE **vals)
 {
 	QCKHASH hash;
-	long lhash;
 	VALUE result;
 
 	hash = FNV1_32_BASIS;
 	while (count-- > 0)
 		hash = hashvalue(*vals++, hash);
-	lhash = (long) hash;
-	if (lhash < 0)
-		lhash = -lhash;
-	result.v_num = itoq(lhash);
+	result.v_num = utoq((FULL) hash);
 	result.v_type = V_NUM;
 	return result;
 }
@@ -6041,6 +6037,9 @@ f_system(VALUE *vp)
 		/*NOTREACHED*/
 	}
 	result.v_type = V_NUM;
+	if (conf->calc_debug & CALCDBG_SYSTEM) {
+		printf("%s\n", vp->v_str->s_str);
+	}
 	result.v_num = itoq((long) system(vp->v_str->s_str));
 	return result;
 }

help.c

@@ -121,9 +121,8 @@ givehelp(char *type)
 	    "else %s no such help, try: help help;fi",
 	    HELPDIR, type, pager, HELPDIR, type,
 	    CUSTOMHELPDIR, type, pager, CUSTOMHELPDIR, type, ECHO);
-	if (conf->calc_debug > 0) {
+	if (conf->calc_debug & CALCDBG_SYSTEM) {
 		printf("%s\n", helpcmd);
-		sleep(3);
 	}
 
 	/* execute the help command */

help/Makefile

@@ -258,7 +258,7 @@ calc: usage
 
 custom_cal: ../custom/CUSTOM_CAL
 	rm -f $@
-	cp usage $@
+	cp ../custom/CUSTOM_CAL $@
 	chmod 0444 $@
 	-@if [ -z "${Q}" ]; then \
 	    echo ''; \
@@ -270,7 +270,7 @@ custom_cal: ../custom/CUSTOM_CAL
 
 new_custom: ../custom/HOW_TO_ADD
 	rm -f $@
-	cp usage $@
+	cp ../custom/HOW_TO_ADD $@
 	chmod 0444 $@
 	-@if [ -z "${Q}" ]; then \
 	    echo ''; \
@@ -282,7 +282,7 @@ new_custom: ../custom/HOW_TO_ADD
 
 copy: blkcpy
 	rm -f $@
-	cp usage $@
+	cp blkcpy $@
 	chmod 0444 $@
 	-@if [ -z "${Q}" ]; then \
 	    echo ''; \

help/command

@@ -85,6 +85,10 @@ Command sequence
 	    This leaves the calculator, when given as a top-level
 	    command.
 
+    ABORT
+	    Forces an immediate quit regardless calc command line
+	    flags and termina state.
+
     CD
 	    Change the current directory to the home directory, if $HOME
 	    is set in the environment.

help/config

@@ -40,9 +40,9 @@ Configuration parameters
 	    "blkverbose"	TRUE=>print all lines, FALSE=>skip duplicates
 	    "blkbase"		block output base
 	    "blkfmt"		block output format
-	    "lib_debug"		calc library script debug level
-	    "calc_debug"	internal calc debug level
-	    "user_debug"	user defined debug level
+	    "lib_debug"		controls library script debug information
+	    "calc_debug"	controls internal calc debug information
+	    "user_debug"	for user defined debug information
 
 
     The "all" config value allows one to save/restore the configuration
@@ -78,7 +78,8 @@ Configuration parameters
     The "newstd" is not backward compatible with the historic
     configuration.  Even so, some people prefer this configuration
     and place the config("all", "newstd") command in their CALCRC
-    startup files.
+    startup files; newstd may also be established by invoking calc
+    with the flag -n.
 
     When nonzero, the "trace" parameter activates one or more features
     that may be useful for debugging.  These features correspond to
@@ -103,9 +104,12 @@ Configuration parameters
     the decimal point to be printed in real or exponential mode in
     normal unformatted printing (print, strprint, fprint) or in
     formatted printing (printf, strprintf, fprintf) when precision is not
-    specified.  The initial value is 20.  This parameter does not change
-    the stored value of a number.  Where rounding is necessary, the type
-    of rounding to be used is controlled by "outround".
+    specified.  The initial value for oldstd is 20, for newstd 10.
+    The parameter may be changed to the value d by either
+    config("display", d) or by display (d).  This parameter does not change
+    the stored value of a number.  Where rounding is necessary to
+    display up to d decimal places, the type of rounding to be used is
+    controlled by config("outround").
 
     The "epsilon" parameter specifies the default accuracy for the
     calculation of functions for which exact values are not possible or
@@ -118,9 +122,10 @@ Configuration parameters
     absolute value of the remainder usually does not exceed epsilon/2.
     Functions which require an epsilon value accept an
     optional argument which overrides this default epsilon value for
-    that single call.  (The value v can be assigned to the "epsilon"
-    parameter by epsilon(v) as well as by config("epsilon", v), and the
-    current value obtained by epsilon() as well as by config("epsilon").)
+    that single call.  The value v can be assigned to the "epsilon"
+    parameter by either config("epsilon", v) or epsilon(v); each of
+    these functions return the current epsilon value; config("epsilon")
+    or epsilon() returns but does not change the epsilon value.
     For the transcendental functions and the functions sqrt() and
     appr(), the calculated value is always a multiple of epsilon.
 
@@ -311,67 +316,64 @@ Configuration parameters
 
     The default "blkfmt" is "hd".
 
-    With regards to "lib_debug", "calc_debug" and "user_debug":
-    higher absolute values result in more detailed debugging and
-    more verbose debug messages.  The default value is 0 in which
-    a very amount of debugging will be performed with nil messages.
-    The -1 value is reserved for no debugging or messages.  Any
-    value <-1 will perform debugging silently (presumably collecting
-    data to be displayed at a later time).  Values >0 result in a
-    greater degree of debugging and more verbose messages.
+    The "lib_debug" parameter is intended for controlling the possible
+    display of special information relating to functions, objects, and
+    other structures created by instructions in calc scripts.
+    Zero value of config("lib_debug") means that no such information
+    is displayed.  For other values, the non-zero bits which currently
+    have meanings are as follows:
 
-    The "lib_debug" is reserved by convention for calc library scripts.
-    This config parameter takes the place of the lib_debug global variable.
-    By convention, "lib_debug" has the following meanings:
+	n		Meaning of bit n of config("lib_debug")
 
-	<-1	no debug messages are printed though some internal
-		    debug actions and information may be collected
+	0	When a function is defined, redefined or undefined at
+		interactive level, a message saying what has been done
+		is displayed.
 
-	-1	no debug messages are printed, no debug actions will be taken
+	1	When a function is defined, redefined or undefined during
+		the reading of a file, a message saying what has been done
+		is displayed.
 
-	0	only usage message regarding each important object are
-		    printed at the time of the read (default)
+    The value for config("lib_debug") in both oldstd and newstd is 3,
+    but if calc is invoked with the -d flag, its initial value is zero.
+    Thus, if calc is started without the -d flag, until config("lib_debug")
+    is changed, a message will be output when a function is defined
+    either interactively or during the reading of a file.
 
-	>0	messages regarding each important object are
-		    printed at the time of the read in addition
-		    to other debug messages
+    The "calc_debug" is intended for controlling internal calc routines
+    that test its operation, or collect or display information that
+    might be useful for debug purposes.  Much of the output from these
+    will make sense only to calc wizards.   Zero value (the default for
+    both oldstd and newstd) of config("lib_calc") corresponds to switching
+    off all these routines.  For nonzero value, particular bits
+    currently have the following meanings:
 
-    The "calc_debug" is reserved by convention for internal calc routines.
-    The output of "calc_debug" will change from release to release.
-    Generally this value is used by calc wizards and by the regress.cal
-    routine (make check).  By convention, "calc_debug" has the following
-    meanings:
+	n		Meaning of bit n of config("calc_debug")
 
-	<-1	reserved for future use
+	0	outputs shell commands prior to execution
 
-	-1	no debug messages are printed, no debug actions will be taken
+	1	outputs currently active functions when a quit instruction
+		is executed
 
-	0	very little, if any debugging is performed (and then mostly
-		    in alpha test code).  The only output is as a result of
-		    internal fatal errors (typically either math_error() or
-		    exit() will be called). (default)
+	2	some details of shs, shs1 and md5 hash states are included
+		in the output when these are printed
 
-	>0	a greater degree of debugging is performed and more
-		    verbose messages are printed (regress.cal uses 1).
+	3	when a function constructs a block value, tests are
+		made that the result has the properties required for use of
+		that block, e.g. that the pointer to the start of the
+		block is not NULL, and that its "length" is not negative.
+		A failure will result in a runtime error.
+
+    Bits >= 4 are reserved for future use and should not be used at this time.
 
     The "user_debug" is provided for use by users.  Calc ignores this value
     other than to set it to 0 by default (for both "oldstd" and "newstd").
-    No calc code or shipped library will change this value other than
-    during startup or during a config("all", xyz) call.
-
-    The following is suggested as a convention for use of "user_debug".
-    These are only suggestions: feel free to use it as you like:
-
-	<-1	no debug messages are printed though some internal
-		    debug actions and information may be collected
-
-	-1	no debug messages are printed, no debug actions will be taken
-
-	0	very little, if any debugging is performed.  The only output
-		    are from fatal errors. (default)
-
-	>0	a greater degree of debugging is performed and more
-		    verbose messages are printed
+    No calc code or shipped library should change this value.  Users
+    should feel free to use it in any way.   In particular they may
+    use particular bits for special purposes as with "calc_debug", or
+    they may use it to indicate a debug level with larger values
+    indicating more stringent and more informative tests with presumably
+    slower operation or more memory usage, and a particular value (like
+    -1 or 0) corresponding to "no tests".
 
     The following are synonyms for true:
 

help/hash

@@ -1,5 +1,5 @@
 NAME
-    hash - hash value
+    hash - FNV-1 hash value
 
 SYNOPSIS
     hash(x_1 [, x_2, x_3, ...])
@@ -12,23 +12,32 @@ TYPES
 DESCRIPTION
     Returns a hash value for one or more values of arbitrary types.
 
-    This function implements the Fowler/Noll/Vo hash-1 (FNV-1 hash).
-    The basis of the hash algorithm was taken from an idea sent
-    by Email to the IEEE POSIX P1003.2 mailing list from Phong Vo
-    (kpv@research.att.com) and Glenn Fowler (gsf@research.att.com).
-    Landon Curt Noll (http://reality.sgi.com/chongo) later improved on
-    their algorithm to come up with Fowler/Noll/Vo hash.
+    The basis of this hash algorithm was taken from an idea sent
+    as reviewer comments to the IEEE POSIX P1003.2 committee by:
 
-    See:
+         Phong Vo (http://www.research.att.com/info/kpv)
+         Glenn Fowler (http://www.research.att.com/~gsf/)
 
-	http://reality.sgi.com/chongo/tech/comp/fnv/index.html
+    In a subsequent ballot round:
 
-    for more information in this hash.
+         Landon Curt Noll (http://reality.sgi.com/chongo)
+
+    improved on their algorithm.  Some people tried this hash
+    and found that it worked rather well.  In an EMail message
+    to Landon, they named it ``Fowler/Noll/Vo'' or the FNV hash.
+
+    FNV hashes are architected to be fast while maintaining a low
+    collision rate. The FNV speed allows one to quickly hash lots
+    of data while maintaining a reasonable collision rate.  See:
+
+         http://reality.sgi.com/chongo/tech/comp/fnv/
+
+    for more details as well as other forms of the FNV hash.
 
 EXAMPLE
     > a = isqrt(2e1000); s = "xyz";
     > hash(a,s)
-	    1916476840
+	    2378490456
 
 LIMITS
     The number of arguments is not to exceed 100.
@@ -37,3 +46,4 @@ LIBRARY
     none
 
 SEE ALSO
+    sha, sha1, md5

help/statement

@@ -208,6 +208,9 @@ Statements
 
 	    Exit is an alias for quit.
 
+    ABORT
+	    Forces an immediate quit regardless calc command line
+	    flags and termina state.
 
     PRINT exprs
 	    For interactive expression evaluation, the values of all

help/todo

@@ -21,9 +21,6 @@ Very High priority items:
 
     * Update the errmax about the meaning of errmax(-1).
 
-    * Document the new meanings for bit values and the sign of
-      of config("lib_debug") in the appropriate help file(s).
-
     * Fix any 'Known bugs' as noted in the BUGS file or as
       displayed by 'calc help bugs'.
 
@@ -61,6 +58,8 @@ High priority items:
       ensure that they have not introduced new or re-introduced old bugs
       into calc.
 
+    * Consider using configure to build the calc Makefile.
+
 =-=
 
 Medium priority items:
@@ -91,3 +90,6 @@ Medium priority items:
       other stuff) in a separate library.
 
     * Clean the source code and document it better.
+
+    * Add a builtin function to access the 64 bit FNV hash which
+      is currently being used internally in seed.c.

help/wishlist

@@ -179,37 +179,3 @@ Calc Enhancement Wish List:
 
     *  Add read -once -try "filename" which would do nothing
        if "filename" was not a readable file.
-
-    * Blocks should have the following features:
-
-        + read/write to/from files (ala fread/fwrite)
-
-	+ misc memory functions (ala memcpy, memcmp, memset,
-	  memchr, etc.)
-
-	+ scatter and gather functions (to send every n-th octet
-	  to another block and to copy from n blocks, the 1st
-	  then 2nd then 3rd ... octets)
-
-    * Printing of blocks should be under the control of the
-      config() interface.  This should allow one to select
-      from any of the following formats:
-
-	+ as one long string
-
-	+ as a series of lines (< 80 chars wide)
-
-	+ in od command style (offset: value value value ...)
-
-	+ in hex dump style (offset: val val val val ...  3hf.Uas.c)
-
-    * In addition one should be able to control the following
-      aspects of printing blocks via the config() interface:
-
-	+ base (hex, octal, char, base 2)
-
-	+ amount of data (the first n octets or the entire block)
-
-	+ skipping printing of duplicate print lines (ala od)
-
-	+ have the ability to print the block as raw data

hist.c

@@ -242,7 +242,7 @@ int
 hist_getline(char *prompt, char *buf, int len)
 {
 	if (!inited)
-		(void) hist_init((char *) NULL);
+		(void) hist_init(calcbindings);
 
 	HS.prompt = prompt;
 	HS.bufsize = len - 2;

input.c

@@ -12,6 +12,12 @@
 #include <pwd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+
+#include "have_unistd.h"
+#if defined(HAVE_UNISTD_H)
+#include <unistd.h>
+#endif
+
 #include "calc.h"
 #include "conf.h"
 #include "hist.h"
@@ -633,6 +639,9 @@ ttychar(void)
 		if (*cmd == '\0' || *cmd == '\n')
 			cmd = shell;
 		if (allow_exec) {
+			if (conf->calc_debug & CALCDBG_SYSTEM) {
+				printf("%s\n", cmd);
+			}
 			system(cmd);
 		} else {
 			fprintf(stderr, "execution disallowed by -m flag\n");

lib/README

@@ -50,37 +50,41 @@ version of read:
 This will cause the needed library files to be read once.  If these
 files have already been read, the read -once will act as a noop.
 
-By convention, the config parameter "lib_debug"  is used to control
-the verbosity of debug information printed by lib files.  By default,
-the "lib_debug" has a value of 0.
+The "lib_debug" parameter is intended for controlling the possible
+display of special information relating to functions, objects, and
+other structures created by instructions in calc scripts.
+Zero value of config("lib_debug") means that no such information
+is displayed.  For other values, the non-zero bits which currently
+have meanings are as follows:
 
-The "lib_debug" config parameter takes the place of the lib_debug
-global variable.  By convention, "lib_debug" has the following meanings:
+    n	    Meaning of bit n of config("lib_debug")
 
-	<-1	no debug messages are printed though some internal
-		    debug actions and information may be collected
+    0	When a function is defined, redefined or undefined at
+	interactive level, a message saying what has been done
+	is displayed.
 
-	-1	no debug messages are printed, no debug actions will be taken
+    1	When a function is defined, redefined or undefined during
+	the reading of a file, a message saying what has been done
+	is displayed.
 
-	0	only usage message regarding each important object are
-		    printed at the time of the read (default)
+The value for config("lib_debug") in both oldstd and newstd is 3,
+but if calc is invoked with the -d flag, its initial value is zero.
+Thus, if calc is started without the -d flag, until config("lib_debug")
+is changed, a message will be output when a function is defined
+either interactively or during the reading of a file.
 
-	>0	messages regarding each important object are
-		    printed at the time of the read in addition
-		    to other debug messages
-
-When config("lib_debug") >= 0, function names and their arg are
-printed as they are defined.  Sometimes this printing is not enough
-information.  For example:
+Sometimes the information printed is not enough.  In addition to the
+standard information, one might want to print:
 
 	* useful obj definitions
 	* functions with optional args
 	* functions with optional args where the param() interface is used
 
 For these cases we suggest that you place at the bottom of your code
-something like:
+something that prints extra information if config("lib_debug") has
+either of the bottom 2 bits set:
 
-	if (config("lib_debug") >= 0) {
+	if (config("lib_debug") & 3) {
 		print "obj xyz defined";
 		print "funcA([val1 [, val2]]) defined";
 		print "funcB(size, mass, ...) defined";

lib/chrem.cal

@@ -174,7 +174,7 @@ define chrem()
     }
 }
 
-if (config("lib_debug") >= 0) {
+if (config("lib_debug") & 3) {
     print "chrem(r1,m1 [,r2,m2 ...]) defined";
     print "chrem(rlist [,mlist]) defined";
 }

lib/deg.cal

@@ -111,6 +111,6 @@ define fixdms(a)
 	a.deg %= 360;
 }
 
-if (config("lib_debug") >= 0) {
+if (config("lib_debug") & 3) {
     print "obj dms {deg, min, sec} defined";
 }

lib/lucas.cal

@@ -1027,7 +1027,7 @@ gen_v1(h, n)
 define
 ldebug(funct, str)
 {
-	if (config("lib_debug") > 0) {
+	if (config("lib_debug") & 3) {
 		print "DEBUG:", funct:":", str;
 	}
 	return;

lib/lucas_chk.cal

@@ -331,7 +331,7 @@ lucas_chk(high_n, quiet)
 
 		/* skip primes where h>=2^n */
 		if (highbit(h_p[i]) >= n_p[i]) {
-			if (config("lib_debug") > 0) {
+			if (config("lib_debug") & 3) {
 				print "h>=2^n skip:", h_p[i]:"*2^":n_p[i]:"-1";
 			}
 			continue;

lib/lucas_tbl.cal

@@ -152,7 +152,7 @@ d_val[97]=1045;  a_val[97]=33;  b_val[97]=1;  r_val[97]=44;
 d_val[99]=9797;  a_val[99]=97;  b_val[99]=1;  r_val[99]=388;
 d_val[100]=  51; a_val[100]= 7; b_val[100]=1; r_val[100]=2;
 
-if (config("lib_debug") >= 0) {
+if (config("lib_debug") & 3) {
     print "d_val[100] defined";
     print "a_val[100] defined";
     print "b_val[100] defined";

lib/mfactor.cal

@@ -312,6 +312,6 @@ define mfactor(n, start_k, rept_loop, p_elim)
 	return q;
 }
 
-if (config("lib_debug") >= 0) {
+if (config("lib_debug") & 3) {
 	print "mfactor(n [, start_k=1 [, rept_loop=10000 [, p_elim=17]]])"
 }

lib/mod.cal

@@ -189,7 +189,7 @@ define mod_pow(a, b)
 }
 
 
-if (config("lib_debug") >= 0) {
+if (config("lib_debug") & 3) {
     print "obj mod {a} defined";
     print "mod_value defined";
     print "set mod_value as needed";

lib/poly.cal

@@ -687,6 +687,6 @@ a=pol(1,4,4,2,3,1);
 b=pol(5,16,8,1);
 c=pol(1+2i,3+4i,5+6i);
 
-if (config("lib_debug") >= 0) {
+if (config("lib_debug") & 3) {
 	print "obj poly {p} defined";
 }

lib/quat.cal

@@ -195,6 +195,6 @@ define quat_shift(a, b)
 	return x.s;
 }
 
-if (config("lib_debug") >= 0) {
+if (config("lib_debug") & 3) {
     print "obj quat {s, v} defined";
 }

lib/randrun.cal

@@ -122,6 +122,6 @@ define randrun(run_cnt)
     printf("max length=%d\n", max_run);
 }
 
-if (config("lib_debug") >= 0) {
+if (config("lib_debug") & 3) {
     print "randrun([run_length]) defined";
 }

lib/regress.cal

@@ -28,8 +28,8 @@ global ecnt;				/* expected value of errcount() */
 ecnt = 0;				/* clear expected errcount() value */
 
 initcfg = config("all", "oldstd");	/* set config to startup default */
-initcfg = config("lib_debug", -4);	/* disable lib startup messages */
-initcfg = config("calc_debug", 1);	/* enable more internal debugging */
+initcfg = config("lib_debug", 0);	/* disable lib startup messages */
+initcfg = config("calc_debug", 0);	/* disable internal debugging */
 initcfg = config("all");		/* save state for later use */
 
 print '003: parsed global definitions';
@@ -7150,9 +7150,11 @@ define test_somenew()
 
 	a = isqrt(2e1000); s = "xyz";
 	print				'8217: a = isqrt(2e1000); s = "xyz";';
-	vrfy(hash(a,s) == 1916476840,	'8218: hash(a,s) == 1916476840');
+	vrfy(hash(a,s) == 2708885378,	'8218: hash(a,s) == 2708885378');
+	vrfy(hash("curds n whey") == 2376141927,
+			'8219: hash("curds n whey") == 2376141927');
 
-	print '8219: Ending test_somenew';
+	print '8220: Ending test_somenew';
 }
 print '189: parsed test_somenew()';
 

lib/seedrandom.cal

@@ -113,7 +113,7 @@ define seedrandom(seed1, seed2, size, trials)
 			p = 2*fp+1;
 		} while (ptest(p,1,0) == 0);
 	} while(ptest(p, trials) == 0 || ptest(fp, trials) == 0);
-	if (config("lib_debug") > 0) {
+	if (config("lib_debug") & 3) {
 		print "/* 1st Blum prime */ p=", p;
 	}
 
@@ -127,7 +127,7 @@ define seedrandom(seed1, seed2, size, trials)
 			q = 2*fq+1;
 		} while (ptest(q,1,0) == 0);
 	} while(ptest(q, trials) == 0 || ptest(fq, trials) == 0);
-	if (config("lib_debug") > 0) {
+	if (config("lib_debug") & 3) {
 		print "/* 2nd Blum prime */ q=", q;
 	}
 
@@ -137,7 +137,7 @@ define seedrandom(seed1, seed2, size, trials)
 	n = p*q;				/* the Blum modulus */
  	binsize = highbit(n)+1;			/* smallest power of 2 > p*q */
 	r = pmod(rand(1<<ceil(binsize*4/5), 1<<(binsize-2)), 2, n);
-	if (config("lib_debug") >= 0) {
+	if (config("lib_debug") & 3) {
 		print "/* seed quadratic residue */ r=", r;
 		print "/* newn", binsize, "bit quadratic residue*/ newn=", n;
 	}
@@ -154,6 +154,6 @@ define seedrandom(seed1, seed2, size, trials)
 	return old_state;
 }
 
-if (config("lib_debug") >= 0) {
+if (config("lib_debug") & 3) {
     print "seedrandom(seed1, seed2, size [, trials]) defined";
 }

lib/surd.cal

@@ -261,7 +261,7 @@ define surd_rel(a, b)
 	return sgn(x^2 - y^2 * surd_type) * sgn(x);
 }
 
-if (config("lib_debug") >= 0) {
+if (config("lib_debug") & 3) {
     print "obj surd {a, b} defined";
     print "surd_type defined";
     print "set surd_type as needed";

lib/varargs.cal

@@ -23,6 +23,6 @@ define sc()
 	return s;
 }
 
-if (config("lib_debug") >= 0) {
+if (config("lib_debug") & 3) {
     print "sc(a, b, ...) defined";
 }

lib_calc.c

@@ -89,19 +89,19 @@ int i_flag = FALSE;	/* TRUE => go interactive if permitted */
 /*
  * global values
  */
-char *calcpath;		/* $CALCPATH or default */
-char *calcrc;		/* $CALCRC or default */
-char *calcbindings;	/* $CALCBINDINGS or default */
-char *home;		/* $HOME or default */
-char *pager;		/* $PAGER or default */
-char *shell;		/* $SHELL or default */
-int stdin_tty = FALSE;	/* TRUE if stdin is a tty */
+char *calcpath = NULL;		/* $CALCPATH or default */
+char *calcrc = NULL;		/* $CALCRC or default */
+char *calcbindings = NULL;	/* $CALCBINDINGS or default */
+char *home = NULL;		/* $HOME or default */
+char *pager = NULL;		/* $PAGER or default */
+char *shell = NULL;		/* $SHELL or default */
+int stdin_tty = FALSE;		/* TRUE if stdin is a tty */
 int havecommands = FALSE;	/* TRUE if have one or more cmd args */
 int stoponerror = FALSE;	/* >0 => stop, <0 => continue on error */
-int post_init = FALSE;	/* TRUE setjmp for math_error is ready */
+int post_init = FALSE;		/* TRUE setjmp for math_error is ready */
 
-int no_env = FALSE;	/* TRUE (-e) => ignore env vars on startup */
-int errmax = ERRMAX;	/* if >= 0,  maximum value for errcount */
+int no_env = FALSE;		/* TRUE (-e) => ignore env vars on startup */
+int errmax = ERRMAX;		/* if >= 0,  maximum value for errcount */
 
 NUMBER *epsilon_default;	/* default allowed error for float calcs */
 

md5.c

@@ -656,7 +656,7 @@ MD5_print(HASH *state)
 	/*
 	 * form the hash value
 	 */
-	if (conf->calc_debug > 0) {
+	if (conf->calc_debug & CALCDBG_HASH_STATE) {
 		char buf[DEBUG_SIZE+1];	/* hash value buffer */
 
 		/*

opcodes.c

@@ -33,6 +33,7 @@ static BOOL saveval = TRUE;		/* to enable or disable saving */
 static int calc_errno;			/* most recent error-number */
 static int errcount;			/* counts calls to error_value */
 static BOOL go;
+static BOOL abort_now;
 
 /*
  * global symbols
@@ -3139,13 +3140,21 @@ o_quit(FUNC *fp, long index)
 	if (cp)
 		printf("%s\n", cp);
 	else
-		printf("Quit statement executed\n");
+		printf("Quit or abort executed\n");
 	if (!inputisterminal() && fp->f_name[0] == '*')
 		closeinput();
 	go = FALSE;
 }
 
 
+static void
+o_abort(FUNC *fp, long index)
+{
+	abort_now = TRUE;
+	o_quit(fp, index);
+}
+
+
 static void
 o_getepsilon(void)
 {
@@ -3533,7 +3542,8 @@ static struct opcode opcodes[MAX_OPCODE+1] = {
 	{o_backslash,	OPNUL,	"BACKSLASH"},	/* unary backslash op */
 	{o_setminus,	OPNUL,	"SETMINUS"},	/* binary backslash op */
 	{o_plus,	OPNUL,	"PLUS"},	/* unary + op */
-	{o_jumpnn,	OPJMP,	"JUMPNN"}	/* jump if non-null */
+	{o_jumpnn,	OPJMP,	"JUMPNN"},	/* jump if non-null */
+	{o_abort,	OPONE,	"ABORT"}	/* abort operation */
 };
 
 
@@ -3567,6 +3577,7 @@ calculate(FUNC *fp, int argcount)
 	funcname = fp->f_name;
 	funcline = 0;
 	go = TRUE;
+	abort_now = FALSE;
 	origargcount = argcount;
 	while (argcount < fp->f_paramcount) {
 		stack++;
@@ -3697,12 +3708,19 @@ calculate(FUNC *fp, int argcount)
 		freevalue(&locals[i]);
 	if (locals != localtable)
 		free(locals);
-	if (conf->calc_debug & 2)
+	if (conf->calc_debug & CALCDBG_FUNC_QUIT)
 		printf("\t\"%s\": line %ld\n", funcname, funcline);
 	while (stack > beginstack)
 		freevalue(stack--);
 	funcname = oldname;
 	funcline = oldline;
+	if (abort_now) {
+		if (!stdin_tty)
+			run_state = RUN_EXIT;
+		else if (run_state < RUN_PRE_TOP_LEVEL)
+			run_state = RUN_PRE_TOP_LEVEL;
+		longjmp(jmpbuf, 1);
+	}
 	return;
 }
 
@@ -3748,8 +3766,10 @@ dumpop(unsigned long *pc)
 		case OP_PRINTSTRING: case OP_STRING:
 			printf(" \"%s\"\n", findstring((long)(*pc))->s_str);
 			return 2;
-		case OP_QUIT:
-			printf(" \"%s\"\n", findstring((long)(*pc))->s_str);
+		case OP_QUIT: case OP_ABORT:
+			if ((long)(*pc) >= 0)
+			    printf(" \"%s\"", findstring((long)(*pc))->s_str);
+			putchar('\n');
 			return 2;
 		case OP_INDEXADDR:
 			printf(" %ld %ld\n", pc[0], pc[1]);

opcodes.h

@@ -144,7 +144,8 @@
 #define OP_SETMINUS	129L	/* binary backslash */
 #define OP_PLUS		130L	/* unary + */
 #define OP_JUMPNN	131L	/* jump if top value is non-null */
-#define MAX_OPCODE	131L	/* highest legal opcode */
+#define OP_ABORT	132L	/* abort operation */
+#define MAX_OPCODE	132L	/* highest legal opcode */
 
 
 /*

quickhash.c

@@ -56,11 +56,6 @@
 #include "zrand.h"
 #include "zrandom.h"
 
-#define ZMOST 2		/* most significant HALFs to hash */
-#define ZLEAST 2	/* least significant HALFs to hash */
-#define ZMIDDLE 4	/* HALFs in the middle to hash */
-
-
 /*
  * forward declarations
  */
@@ -71,7 +66,8 @@ static QCKHASH objhash(OBJECT *op, QCKHASH val);
 static QCKHASH randhash(RAND *r, QCKHASH val);
 static QCKHASH randomhash(RANDOM *state, QCKHASH val);
 static QCKHASH config_hash(CONFIG *cfg, QCKHASH val);
-static QCKHASH fnv_strhash(char *str, QCKHASH val);
+static QCKHASH fnv_strhash(char *ch, QCKHASH val);
+static QCKHASH fnv_STRhash(STRING *str, QCKHASH val);
 static QCKHASH fnv_fullhash(FULL *v, LEN len, QCKHASH val);
 static QCKHASH fnv_zhash(ZVALUE z, QCKHASH val);
 static QCKHASH hash_hash(HASH *hash, QCKHASH val);
@@ -79,22 +75,29 @@ static QCKHASH blk_hash(BLOCK *blk, QCKHASH val);
 
 
 /*
- * fnv - compute the next Fowler/Noll/Vo hash given a variable
+ * FNV-0 - Fowler/Noll/Vo-0 32 bit hash
  *
- * The basis of the hash algorithm was taken from an idea
- * sent by Email to the IEEE Posix P1003.2 mailing list from
- * Phong Vo (kpv@research.att.com) and Glenn Fowler (gsf@research.att.com).
- * Landon Curt Noll (http://reality.sgi.com/chongo) later improved on there
- * algorithm to come up with Fowler/Noll/Vo hash.
+ * The basis of this hash algorithm was taken from an idea sent
+ * as reviewer comments to the IEEE POSIX P1003.2 committee by:
  *
- * The magic lies in the constant 16777619, which for 32 bit hashing
- * is able to process 234936 words from the web2 dictionary without
- * any collisions.
+ *      Phong Vo (http://www.research.att.com/info/kpv)
+ *      Glenn Fowler (http://www.research.att.com/~gsf/)
  *
- * See:
- *	http://reality.sgi.com/chongo/src/fnv/fnv_hash.tar.gz
- *	http://reality.sgi.com/chongo/src/fnv/h32.c
- *	http://reality.sgi.com/chongo/src/fnv/h64.c
+ * In a subsequent ballot round:
+ *
+ *      Landon Curt Noll (http://reality.sgi.com/chongo)
+ *
+ * improved on their algorithm.  Some people tried this hash
+ * and found that it worked rather well.  In an EMail message
+ * to Landon, they named it ``Fowler/Noll/Vo'' or the FNV hash.
+ *
+ * FNV hashes are architected to be fast while maintaining a low
+ * collision rate. The FNV speed allows one to quickly hash lots
+ * of data while maintaining a reasonable collision rate.  See:
+ *
+ *      http://reality.sgi.com/chongo/tech/comp/fnv/
+ *
+ * for more details as well as other forms of the FNV hash.
  *
  * given:
  *	x	the value to hash (must not be longer than 32 bits)
@@ -160,7 +163,7 @@ hashvalue(VALUE *vp, QCKHASH val)
 		case V_COM:
 			return fnv_chash(vp->v_com, val);
 		case V_STR:
-			return fnv_strhash(vp->v_str->s_str, val);
+			return fnv_STRhash(vp->v_str, val);
 		case V_NULL:
 			return val;
 		case V_OBJ:
@@ -431,7 +434,29 @@ config_hash(CONFIG *cfg, QCKHASH val)
 
 
 /*
- * fnv_strhash - Fowler/Noll/Vo 32 bit hash of a string
+ * fnv_strhash - Fowler/Noll/Vo 32 bit hash of a null-terminated string
+ *
+ * given:
+ *	ch	the start of the string to hash
+ *	val	initial hash value
+ *
+ * returns:
+ *	a 32 bit QCKHASH value
+ */
+static QCKHASH
+fnv_strhash(char *ch, QCKHASH val)
+{
+	/*
+	 * hash each character in the string
+	 */
+	while (*ch) {
+		val = fnv(*ch++, val);
+	}
+	return val;
+}
+
+/*
+ * fnv_STRhash - Fowler/Noll/Vo 32 bit hash of a STRING
  *
  * given:
  *	str	the string to hash
@@ -441,13 +466,19 @@ config_hash(CONFIG *cfg, QCKHASH val)
  *	a 32 bit QCKHASH value
  */
 static QCKHASH
-fnv_strhash(char *str, QCKHASH val)
+fnv_STRhash(STRING *str, QCKHASH val)
 {
+	char *ch;
+	long n;
+
+	ch = str->s_str;
+	n = str->s_len;
+
 	/*
 	 * hash each character in the string
 	 */
-	while (*str) {
-		val = fnv(*str++, val);
+	while (n-- > 0) {
+		val = fnv(*ch++, val);
 	}
 	return val;
 }
@@ -490,48 +521,36 @@ fnv_fullhash(FULL *v, LEN len, QCKHASH val)
 static QCKHASH
 fnv_zhash(ZVALUE z, QCKHASH val)
 {
-	int skip;		/* HALFs to skip in the middle */
-	int i;
+	LEN n;
+	HALF *hp;
+#if BASEB == 16
+	FULL f;
+#endif
 
 	/*
-	 * hash the sign and length
+	 * hash the sign
 	 */
-	if (zisneg(z)) {
-		val = fnv(-(z.len), val+V_NUM);
-	} else {
-		val = fnv(z.len, val+V_NUM);
+	val = fnv(z.sign, val + V_NUM);
+
+	n = z.len;
+	hp = z.v;
+
+#if BASEB == 16
+	while (n > 1) {
+		f = (FULL) *hp++;
+		f |= (FULL) *hp++ << BASEB;
+		val = fnv(f, val);
+		n -= 2;
 	}
-
-	/*
-	 * if a ZVALUE is short enough, hash it all
-	 */
-	if (z.len <= ZMOST+ZLEAST+ZMIDDLE) {
-		/* hash all HALFs of a short ZVALUE */
-		for (i=0; i < z.len; ++i) {
-			val = fnv(z.v[i], val);
-		}
-
-	/*
-	 * otherwise hash the ZLEAST significant HALFs followed by
-	 * ZMIDDLE HALFs followed by the ZMOST significant HALFs.
-	 */
-	} else {
-		/* hash the ZLEAST significant HALFs */
-		for (i=0; i < ZLEAST; ++i) {
-			val = fnv(z.v[i], val);
-		}
-
-		/* hash ZMIDDLE HALFs in the middle */
-		skip = (z.len-ZLEAST-ZMOST)/(ZMIDDLE + 1);
-		for (i=ZLEAST-1+skip; i < ZLEAST-1+skip*(ZMIDDLE+1); i+=skip) {
-			val = fnv(z.v[i], val);
-		}
-
-		/* hash the ZMOST significant HALFs */
-		for (i=z.len-1-ZMOST; i < z.len; ++i) {
-			val = fnv(z.v[i], val);
-		}
+	if (n) {
+		val = fnv(*hp, val);
 	}
+#else
+	while (n--  > 0) {
+		val = fnv(*hp, val);
+		++hp;
+	}
+#endif
 	return val;
 }
 

seed.c

@@ -87,7 +87,7 @@ typedef struct s_hash64 hash64;
 
 
 /*
- * FNV-1 basis
+ * FNV-1 initial basis
  *
  * We start the hash at a non-zero value at the beginning so that
  * hashing blocks of data with all 0 bits do not map onto the same
@@ -131,7 +131,7 @@ typedef struct s_hash64 hash64;
 
 
 /*
- * hash_buf - perform a 64 bit Fowler/Noll/Vo hash on a buffer
+ * hash_buf - perform a Fowler/Noll/Vo-1 64 bit hash
  *
  * input:
  *	buf	- start of buffer to hash
@@ -152,20 +152,29 @@ hash_buf(char *buf, unsigned len)
 	char *buf_end = buf+len;	/* beyond end of hash area */
 
 	/*
-	 * Fowler/Noll/Vo hash - hash each character in the string
+	 * FNV-1 - Fowler/Noll/Vo-1 64 bit hash
 	 *
-	 * The basis of the hash algorithm was taken from an idea
-	 * sent by Email to the IEEE POSIX P1003.2 mailing list from
-	 * Phong Vo (kpv@research.att.com) and Glenn Fowler
-	 * (gsf@research.att.com).
-	 *
-	 * See:
-	 *	http://reality.sgi.com/chongo/tech/comp/fnv/index.html
-	 *
-	 * for information on 32bit and 64bit Fowler/Noll/Vo hashes.
-	 *
-	 * Landon Curt Noll (http://reality.sgi.com/chongo) later improved
-	 * on their algorithm to come up with Fowler/Noll/Vo hash.
+         * The basis of this hash algorithm was taken from an idea sent
+         * as reviewer comments to the IEEE POSIX P1003.2 committee by:
+         *
+         *      Phong Vo (http://www.research.att.com/info/kpv)
+         *      Glenn Fowler (http://www.research.att.com/~gsf/)
+         *
+         * In a subsequent ballot round:
+         *
+         *      Landon Curt Noll (http://reality.sgi.com/chongo)
+         *
+         * improved on their algorithm.  Some people tried this hash
+         * and found that it worked rather well.  In an EMail message
+         * to Landon, they named it ``Fowler/Noll/Vo'' or the FNV hash.
+         *
+         * FNV hashes are architected to be fast while maintaining a low
+         * collision rate. The FNV speed allows one to quickly hash lots
+         * of data while maintaining a reasonable collision rate.  See:
+         *
+         *      http://reality.sgi.com/chongo/tech/comp/fnv/
+         *
+         * for more details as well as other forms of the FNV hash.
 	 */
 #if defined(HAVE_B64)
 	/* hash each octet of the buffer */
@@ -221,8 +230,8 @@ hash_buf(char *buf, unsigned len)
 
 	/* convert to hash64 */
 	/* hval.w32[1] = 0xffff&(val[3]<<16)+val[2]; */
-	hval.w32[1] = val[3]<<16 + val[2];
-	hval.w32[0] = val[1]<<16 + val[0];
+	hval.w32[1] = (val[3]<<16) + val[2];
+	hval.w32[0] = (val[1]<<16) + val[0];
 
 #endif /* HAVE_B64 */
 

shs.c

@@ -696,7 +696,7 @@ shs_print(HASH *state)
 	/*
 	 * form the hash value
 	 */
-	if (conf->calc_debug > 0) {
+	if (conf->calc_debug & CALCDBG_HASH_STATE) {
 		char buf[DEBUG_SIZE+1];	/* hash value buffer */
 
 		/*

shs1.c

@@ -672,7 +672,7 @@ shs1_print(HASH *state)
 	/*
 	 * form the hash value
 	 */
-	if (conf->calc_debug > 0) {
+	if (conf->calc_debug & CALCDBG_HASH_STATE) {
 		char buf[DEBUG_SIZE+1];	/* hash value buffer */
 
 		/*

token.c

@@ -83,6 +83,7 @@ static struct keyword keywords[] = {
 	{"print",	T_PRINT},
 	{"cd",		T_CD},
 	{"undefine",	T_UNDEFINE},
+	{"abort",	T_ABORT},
 	{NULL,		0}
 };
 

token.h

@@ -110,6 +110,7 @@
 #define T_PRINT			124	/* print keyword */
 #define T_CD			125	/* change directory keyword */
 #define T_UNDEFINE		126	/* undefine keyword */
+#define T_ABORT			127	/* abort operation */
 
 
 #define iskeyword(n) ((n) > 100)	/* TRUE if token is a keyword */

version.c

@@ -12,7 +12,7 @@
 #define MAJOR_VER	2	/* major version */
 #define MINOR_VER	11	/* minor version */
 #define MAJOR_PATCH	0	/* patch level or 0 if no patch */
-#define MINOR_PATCH	"8.4"	/* test number or empty string if no patch */
+#define MINOR_PATCH	"8.7"	/* test number or empty string if no patch */
 
 /*
  * calc version constants