Release calc version 2.11.0t8.8

BUGS

@@ -68,21 +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
+	4230: n = ftell(f)
-	calc -i read myfile
+	4231: isnull(fputs(f,L,"\n",C,"\n",N,"\n"))
-	"./myfile", line 2: End-of-file in function body
+	4232: fseek(f, n)
-	Error in commands
+	**** 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
+	4700: Beginning test_charset
-      type ^D while using lib/altbind or while ^D is bound to quit.
+	**** 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
 
-    * When compiled on Solaris with the Solaris cc using -Xc option
+	5100: Beginning test_newdecl
-      (which forces BASEB=16) and without -DFORCE_STDC, calc fails
+	5101: test5100(1)
-      regression test #8218 because hash(a,s), where a = isqrt(2e1000)
+	**** errcount:173  > ecnt:172
-      and s = "xyz", returns 1418255679 instead of 2378490456.
+	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

@@ -129,6 +129,18 @@ Following is the change from calc version 2.11.0t8 to date:
 		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.
+
+    Updated to some extend, the help/statement and help/command help
+    files with new information about SHOW, QUIT, EXIT and ABORT.
+
+    Fixed misc compiler warnings.
+
 
 Following is the change from calc version 2.11.0t7 to 2.11.0t7.5:
 

calc.h

@@ -164,6 +164,7 @@ extern int d_flag;		/* TRUE => disable heading, lib_debug == 0 */
 extern int c_flag;		/* TRUE => continue after error if permitted */
 extern int i_flag;		/* TRUE => try to go interactive after error */
 extern int stoponerror;		/* >0 => stop, <0 => continue, ==0 => use -c */
+extern BOOL abort_now;		/* TRUE => try to go interactive */
 
 extern char *pager;		/* $PAGER or default */
 extern int stdin_tty;		/* TRUE if stdin is a tty */

codegen.c

@@ -86,6 +86,7 @@ getcommands(BOOL toplevel)
 	/* firewall */
 	name[0] = '\0';
 	name[MAXCMD+1] = '\0';
+	abort_now = FALSE;
 
 	/* getcommands */
 	if (!toplevel)
@@ -164,6 +165,13 @@ getcommands(BOOL toplevel)
 			if (evaluate(FALSE))
 				updateoldvalue(curfunc);
 			freefunc(curfunc);
+			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);
+			}
 		}
 	}
 }
@@ -862,8 +870,19 @@ 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 ****/
+		if (nextchar() == ':') {	/****HACK HACK****/
 			definelabel(tokensymbol());
 			if (gettoken() == T_RIGHTBRACE) {
 				rescantoken();

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

@@ -14,12 +14,10 @@ Command sequence
     described in the next section.
 
 
-    NOTE: Calc commands are in lower case.   UPPER case is used below
+    define a function
-	  for emphasis only, and should be considered in lower case.
+    -----------------
-
+    define function(params) { body }
-
+    define function(params) = expression
-    DEFINE function(params) { body }
-    DEFINE function(params) = expression
 	    This first form defines a full function which can consist
 	    of declarations followed by many statements which implement
 	    the function.
@@ -30,13 +28,22 @@ Command sequence
 	    and question mark operators can be useful.  Examples of
 	    simple functions are:
 
-		    define sumcubes(a, b) = a^3 + b^3;
+		    define sumcubes(a, b) = a^3 + b^3
-		    define pimod(a) = a % pi();
+		    define pimod(a) = a % pi()
+		    define printnum(a, n, p)
+		    {
+			if (p == 0) {
+			    print a: "^": n, "=", a^n;
+			} else {
+			    print a: "^": n, "mod", p, "=", pmod(a,n,p);
+			}
+		    }
 
-    HELP
-	    This displays a general help message.
 
-    READ filename
+    read calc commands
+    ------------------
+    read filename
+    read -once filename
 	    This reads definitions from the specified filename.
 	    The name can be quoted if desired.  The calculator
 	    uses the CALCPATH environment variable to search
@@ -52,14 +59,11 @@ Command sequence
 	    evaluate or functions to define, just like at the top
 	    level command level.
 
-	    If the -m mode disallows opening of files for reading,
+	    When -once is given, the read command acts like the regular
-	    this command will be disabled.
+	    read expect that it will ignore filename if is has been
+	    previously read.
 
-    READ -once filename
+	    The read -once form is particularly useful in a library that
-	    This command acts like the regular READ expect that it
-	    will ignore filename if is has been previously read.
-
-	    This command is particularly useful in a library that
 	    needs to read a 2nd library.  By using the READ -once
 	    command, one will not reread that 2nd library, nor will
 	    once risk entering into a infinite READ loop (where
@@ -69,7 +73,10 @@ Command sequence
 	    If the -m mode disallows opening of files for reading,
 	    this command will be disabled.
 
-    WRITE filename
+
+    write calc commands
+    -------------------
+    write filename
 	    This writes the values of all global variables to the
 	    specified filename, in such a way that the file can be
 	    later read in order to recreate the variable values.
@@ -81,19 +88,221 @@ Command sequence
 	    If the -m mode disallows opening of files for writing,
 	    this command will be disabled.
 
-    QUIT
-	    This leaves the calculator, when given as a top-level
-	    command.
 
-    CD
+    quit or exit
-	    Change the current directory to the home directory, if $HOME
+    ------------
+    quit
+    quit string
+    exit
+    exit string
+	    The action of these commands depends on where they are used.
+	    At the interactive level, they will cause calc it edit.
+	    This is the normal way to leave the calculator.  In any
+	    other use, they will stop the current calculation as if
+	    an error had occurred.
+
+	    If a string is given, then the string is printed as the reason
+	    for quitting, otherwise a general quit message is printed.
+	    The routine name and line number which executed the quit is
+	    also printed in either case.
+
+	    Exit is an alias for quit.
+
+	    Quit is useful when a routine detects invalid arguments,
+	    in order to stop a calculation cleanly.  For example,
+	    for a square root routine, an error can be given if the
+	    supplied parameter was a negative number, as in:
+
+		    define mysqrt(n)
+		    {
+			if (! isnum(n))
+			    quit "non-numeric argument";
+			if (n < 0)
+			    quit "Negative argument";
+			return sqrt(n);
+		    }
+
+	    See 'more information about abort and quit' below for
+	    more information.
+
+
+
+    abort
+    -----
+    abort
+    abort string
+	    This command behaves like QUIT except that it will attempt
+	    to return to the interactive level if permitted, otherwise
+	    calc exit.
+
+	    See 'more information about abort and quit' below for
+	    more information.
+
+
+    change current directory
+    ------------------------
+    cd
+    cd dir
+	    Change the current directory to 'dir'.  If 'dir' is ommitted,
+	    change the current directory to the home directory, if $HOME
 	    is set in the environment.
 
-    CD dir
+
-	    Change the current directory to dir.
+    show information
+    ----------------
+    show item
+	    This command displays some information where 'item' is
+	    one of the following:
+
+		    blocks		unfreed named blocks
+		    builtin		built in functions
+		    config		config parameters and values
+		    constants		cache of numeric constants
+		    custom		custom functions if calc -C was used
+		    errors		new error-values created
+		    files		open files, file position and sizes
+		    function		user-defined functions
+		    globaltypes		global variables
+		    objfunctions	possible object functions
+		    objtypes		defined objects
+		    opcodes func	internal opcodes for function `func'
+		    sizes		size in octets of calc value types
+		    realglobals		numeric global variables
+		    statics		unscoped static variables
+		    numbers		calc number cache
+		    redcdata		REDC data defined
+		    strings		calc string cache
+		    literals		calc literal cache
+
+	    Only the first 4 characters of item are examined, so:
+
+		    show globals
+		    show global
+		    show glob
+
+	    do the same thing.
+
+
+    calc help
+    ---------
+    help
+    help name
+	    This displays a help related to 'name' or general
+	    help of none is given.
+
+
+    =-=
+
+
+    more information about abort and quit
+    =====================================
+
+    Consider the following calc file called myfile.cal:
+
+	print "start of myfile.cal";
+	define q() {quit "quit from q()"; print "end of q()"}
+	define a() {abort "abort from a()"}
+	x = 3;
+	{print "start #1"; if (x > 1) q()} print "after #1";
+	{print "start #2"; if (x > 1) a()} print "after #2";
+	{print "start #3"; if (x > 1) quit "quit from 3rd statement"}
+	print "end of myfile.cal";
+
+    The command:
+
+	calc read myfile
+
+    will produce:
+
+	q() defined
+	a() defined
+	start statment #1
+	quit from q()
+	after statment #1
+	start statment #2
+	abort from a()
+
+    The QUIT within the q() function prevented the ``end of q()''
+    statement from being evaluated.  This QUIT command caused
+    control to be returned to just after the place where q()
+    was called.
+
+    Notice that unlike QUIT, the ABORT inside function a() halts
+    the processing of statements from the input source (myfile.cal).
+    Because calc was not interactive, ABORT causes calc to exit.
+
+    The command:
+
+	calc -i read myfile
+
+    will produce:
+
+	q() defined
+	a() defined
+	start statment #1
+	quit from q()
+	after statment #1
+	start statment #2
+	abort from a()
+	>		<==== calc interactive prompt
+
+    because the '-i' calc causes ABORT to drop into an
+    interactive prompt.  However typing a QUIT or ABORT
+    at the interactive prompt level will always calc to exit,
+    even when calc is invoked with '-i'.
+
+    Also observe that both of these commands:
+
+	cat myfile.cal | calc
+	cat myfile.cal | calc -i
+
+    will produce:
+
+	q() defined
+	a() defined
+	start statment #1
+	quit from q()
+	after statment #1
+	start statment #2
+	abort from a()
+
+    The ABORT inside function a() halts the processing of statements
+    from the input source (standard input).  Because standard input
+    is not a terminal, using '-i' does not force it to drop into
+    an interactive prompt.
+
+    If one were to type in the contents of myfile.cal interactively,
+    calc will produce:
+
+	> print "start of myfile.cal";
+	start of myfile.cal
+	> define q() {quit "quit from q()"; print "end of q()"}
+	q() defined
+	> define a() {abort "abort from a()"}
+	a() defined
+	> x = 3;
+	> {print "start #1"; if (x > 1) q()} print "after #1";
+	start statment #1
+	quit from q()
+	after statment #1
+	> {print "start #2"; if (x > 1) a()} print "after #2";
+	start statment #2
+	abort from a()
+	> {print "start #3"; if (x > 1) quit "quit from 3rd statement"}
+	start #3
+	quit from 3rd statement
+
+    The ABORT from within the a() function returned control to
+    the interactive level.
+
+    The QUIT (after the if (x > 1) ...) will cause calc to exit
+    because it was given at the interactive prompt level.
+
+
+    =-=
 
 
     Also see the help topic:
 
 	    statement       flow control and declaration statements
-	    usage		for -m modes
+	    usage	    how to invoke the calc command and calc -options

help/statement

@@ -10,28 +10,38 @@ Statements
     expressions are optional and may be omitted (as in RETURN).
 
 
-    NOTE: Calc commands are in lower case.   UPPER case is used below
+    C-like statements
-	  for emphasis only, and should be considered in lower case.
+    -----------------
-
+    { statement }
-
+    { statement; ... statement }
-    IF (expr) statement
+    if (expr) statement
-    IF (expr) statement ELSE statement
+    if (expr) statement ELSE statement
-    FOR (optionalexpr ; optionalexpr ; optionalexpr) statement
+    for (optionalexpr ; optionalexpr ; optionalexpr) statement
-    WHILE (expr) statement
+    while (expr) statement
-    DO statement WHILE (expr)
+    do statement while (expr)
-    CONTINUE
+    continue
-    BREAK
+    break
-    GOTO label
+    goto label
 	    These all work like in normal C.
 
-    RETURN optionalexpr
+	    See 'help expression' for details on expressions.
+	    See 'help builtin' for details on calc builtin functions.
+
+
+    return
+    ------
+    return optionalexpr
+    return ( optionalexpr )
 	    This returns a value from a function.  Functions always
 	    have a return value, even if this statement is not used.
 	    If no return statement is executed, or if no expression
 	    is specified in the return statement, then the return
 	    value from the function is the null type.
 
-    SWITCH (expr) { caseclauses }
+
+    switch
+    ------
+    switch (expr) { caseclauses }
 	    Switch statements work similarly to C, except for the
 	    following.  A switch can be done on any type of value,
 	    and the case statements can be of any type of values.
@@ -42,17 +52,12 @@ Statements
 	    is the exception, and only matches once all other cases
 	    have been tested.
 
-    { statements }
-	    This is a normal list of statements, each one ended by
-	    a semicolon.  Unlike the C language, no declarations are
-	    permitted within an inner-level compound statement.
-	    Declarations are only permitted at the beginning of a
-	    function definition, or at the beginning of an expression
-	    sequence.
 
-    MAT variable [dimension] [dimension] ...
+    matrix
-    MAT variable [dimension, dimension, ...]
+    ------
-    MAT variable [] = { value, ... }
+    mat variable [dimension] [dimension] ...
+    mat variable [dimension, dimension, ...]
+    mat variable [] = { value, ... }
 	    This creates a matrix variable with the specified dimensions.
 	    Matrices can have from 1 to 4 dimensions.  When specifying
 	    multiple dimensions, you can use either the standard C syntax,
@@ -119,8 +124,11 @@ Statements
 		    local mat temp[5];
 		    static mat strtable[] = {"hi", "there", "folks");
 
-    OBJ type { elementnames } optionalvariables
+
-    OBJ type variable
+    object
+    ------
+    obj type { elementnames } optionalvariables
+    obj type variable
 	    These create a new object type, or create one or more
 	    variables of the specified type.  For this calculator,
 	    an object is just a structure which is implicitly acted
@@ -183,33 +191,12 @@ Statements
 		    static obj point temp2 = {4, 3};
 		    global obj point p1, p2, p3;
 
-    EXIT string
-    QUIT string
-	    This command is used in two cases.  At the top command
-	    line level, quit will exit from the calculator.  This
-	    is the normal way to leave the calculator.  In any other
-	    use, quit will abort the current calculation as if an
-	    error had occurred.  If a string is given, then the string
-	    is printed as the reason for quitting, otherwise a general
-	    quit message is printed.  The routine name and line number
-	    which executed the quit is also printed in either case.
 
-	    Quit is useful when a routine detects invalid arguments,
+    print expressions
-	    in order to stop a calculation cleanly.  For example,
+    -----------------
-	    for a square root routine, an error can be given if the
+    print expr
-	    supplied parameter was a negative number, as in:
+    print expr, ... expr
-
+    print expr: ... expr
-		    define mysqrt(n)
-		    {
-			    if (n < 0)
-				    quit "Negative argument";
-			    ...
-		    }
-
-	    Exit is an alias for quit.
-
-
-    PRINT exprs
 	    For interactive expression evaluation, the values of all
 	    typed-in expressions are automatically displayed to the
 	    user.  However, within a function or loop, the printing of
@@ -228,8 +215,8 @@ Statements
 	    expression unless the statement ends with a colon.  As
 	    examples:
 
-		    print 3, 4;		prints "3 4" and newline.
+		    print 3, 4;			prints "3 4" and newline.
-		    print 5:;		prints "5" with no newline.
+		    print 5:;			prints "5" with no newline.
 		    print 'a' : 'b' , 'c';	prints "ab c" and newline.
 		    print;			prints a newline.
 
@@ -247,25 +234,9 @@ Statements
 	    prints the name of the file that was opened.
 
 
-    SHOW item
-	    This command displays some information.
-
-		    builtin		built in functions
-		    global		global variables
-		    function	user-defined functions
-		    objfunc		possible object functions
-		    config		config parameters and values
-		    objtype		defined objects
-
-	    Only the first 4 characters of item are examined, so:
-
-		    show globals
-		    show global
-		    show glob
-
-	    do the same thing.
-
-
     Also see the help topic:
 
 	    command         top level commands
+	    expression	    calc expression syntax
+	    builtin	    calc builtin functions
+	    usage	    how to invoke the calc command and calc -options

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;

lib/regress.cal

@@ -3302,7 +3302,7 @@ define test_fileops()
 
 	print '4261: Ending test_fileops';
 }
-print '071: parsed test_redc()';
+print '071: parsed test_fileops()';
 
 
 /*
@@ -7150,7 +7150,7 @@ define test_somenew()
 
 	a = isqrt(2e1000); s = "xyz";
 	print				'8217: a = isqrt(2e1000); s = "xyz";';
-	vrfy(hash(a,s) == 2378490456,	'8218: hash(a,s) == 2378490456');
+	vrfy(hash(a,s) == 2708885378,	'8218: hash(a,s) == 2708885378');
 	vrfy(hash("curds n whey") == 2376141927,
 			'8219: hash("curds n whey") == 2376141927');
 

lib_calc.c

@@ -89,19 +89,20 @@ int i_flag = FALSE;	/* TRUE => go interactive if permitted */
 /*
  * global values
  */
-char *calcpath;		/* $CALCPATH or default */
+char *calcpath = NULL;		/* $CALCPATH or default */
-char *calcrc;		/* $CALCRC or default */
+char *calcrc = NULL;		/* $CALCRC or default */
-char *calcbindings;	/* $CALCBINDINGS or default */
+char *calcbindings = NULL;	/* $CALCBINDINGS or default */
-char *home;		/* $HOME or default */
+char *home = NULL;		/* $HOME or default */
-char *pager;		/* $PAGER or default */
+char *pager = NULL;		/* $PAGER or default */
-char *shell;		/* $SHELL or default */
+char *shell = NULL;		/* $SHELL or default */
-int stdin_tty = FALSE;	/* TRUE if stdin is a tty */
+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 */
+BOOL abort_now = FALSE;		/* TRUE => go interactive now, if permitted */
 
-int no_env = FALSE;	/* TRUE (-e) => ignore env vars on startup */
+int no_env = FALSE;		/* TRUE (-e) => ignore env vars on startup */
-int errmax = ERRMAX;	/* if >= 0,  maximum value for errcount */
+int errmax = ERRMAX;		/* if >= 0,  maximum value for errcount */
 
 NUMBER *epsilon_default;	/* default allowed error for float calcs */
 

opcodes.c

@@ -3139,13 +3139,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 +3541,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 +3576,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++;
@@ -3703,6 +3713,14 @@ calculate(FUNC *fp, int argcount)
 		freevalue(stack--);
 	funcname = oldname;
 	funcline = oldline;
+	if (abort_now && stack == stackarray) {
+		if (!stdin_tty)
+			run_state = RUN_EXIT;
+		else if (run_state < RUN_PRE_TOP_LEVEL)
+			run_state = RUN_PRE_TOP_LEVEL;
+		freefunc(curfunc);
+		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:
+		case OP_QUIT: case OP_ABORT:
-			printf(" \"%s\"\n", findstring((long)(*pc))->s_str);
+			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);
@@ -167,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:
@@ -438,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
@@ -448,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) {
+	while (n-- > 0) {
-		val = fnv(*str++, val);
+		val = fnv(*ch++, val);
 	}
 	return val;
 }
@@ -497,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 */
+	LEN n;
-	int i;
+	HALF *hp;
+#if BASEB == 16
+	FULL f;
+#endif
 
 	/*
-	 * hash the sign and length
+	 * hash the sign
 	 */
-	if (zisneg(z)) {
+	val = fnv(z.sign, val + V_NUM);
-		val = fnv(-(z.len), val+V_NUM);
+
-	} else {
+	n = z.len;
-		val = fnv(z.len, val+V_NUM);
+	hp = z.v;
+
+#if BASEB == 16
+	while (n > 1) {
+		f = (FULL) *hp++;
+		f |= (FULL) *hp++ << BASEB;
+		val = fnv(f, val);
+		n -= 2;
 	}
-
+	if (n) {
-	/*
+		val = fnv(*hp, val);
-	 * 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);
-		}
 	}
+#else
+	while (n--  > 0) {
+		val = fnv(*hp, val);
+		++hp;
+	}
+#endif
 	return val;
 }
 

sample/many_random.c

@@ -33,18 +33,6 @@
  */
 
 
-#if defined(__sgi)
-# include "../longbits.h"
-# if defined(HAVE_B64)
-typedef USB64 k_sigset_t;
-# else
-typedef struct {
-	USB32 sigbits[2];
-} k_sigset_t;
-# endif
-#endif
-
-
 #include <sys/types.h>
 #include <stdio.h>
 #include "../calc.h"

sample/test_random.c

@@ -33,18 +33,6 @@
  */
 
 
-#if defined(__sgi)
-# include "../longbits.h"
-# if defined(HAVE_B64)
-typedef USB64 k_sigset_t;
-# else
-typedef struct {
-	USB32 sigbits[2];
-} k_sigset_t;
-# endif
-#endif
-
-
 #include <sys/types.h>
 #include <stdio.h>
 #include "../calc.h"

seed.c

@@ -230,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[1] = (val[3]<<16) + val[2];
-	hval.w32[0] = val[1]<<16 + val[0];
+	hval.w32[0] = (val[1]<<16) + val[0];
 
 #endif /* HAVE_B64 */
 

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.5"	/* test number or empty string if no patch */
+#define MINOR_PATCH	"8.8"	/* test number or empty string if no patch */
 
 /*
  * calc version constants