--- gforth/prim	2003/08/22 08:08:45	1.141
+++ gforth/prim	2005/12/11 20:08:09	1.183
@@ -1,6 +1,6 @@
 \ Gforth primitives
 
-\ Copyright (C) 1995,1996,1997,1998,2000,2003 Free Software Foundation, Inc.
+\ Copyright (C) 1995,1996,1997,1998,2000,2003,2004 Free Software Foundation, Inc.
 
 \ This file is part of Gforth.
 
@@ -100,6 +100,8 @@
 \E s" struct F83Name *"	single data-stack type-prefix f83name
 \E s" struct Longname *" single data-stack type-prefix longname
 \E 
+\E data-stack   stack-prefix S:
+\E fp-stack     stack-prefix F:
 \E return-stack stack-prefix R:
 \E inst-stream  stack-prefix #
 \E 
@@ -136,6 +138,10 @@
 \ throw execute, cfa and NEXT1 out?
 \ macroize *ip, ip++, *ip++ (pipelining)?
 
+\ Stack caching setup
+
+ifdef(`STACK_CACHE_FILE', `include(STACK_CACHE_FILE)', `include(cache0.vmg)')
+
 \ these m4 macros would collide with identifiers
 undefine(`index')
 undefine(`shift')
@@ -148,36 +154,67 @@ undefine(`symbols')
 
 (docol)	( -- R:a_retaddr )	gforth-internal	paren_docol
 ""run-time routine for colon definitions""
+#ifdef NO_IP
+a_retaddr = next_code;
+INST_TAIL;
+goto **(Label *)PFA(CFA);
+#else /* !defined(NO_IP) */
 a_retaddr = (Cell *)IP;
 SET_IP((Xt *)PFA(CFA));
+#endif /* !defined(NO_IP) */
 
 (docon) ( -- w )	gforth-internal	paren_docon
 ""run-time routine for constants""
 w = *(Cell *)PFA(CFA);
+#ifdef NO_IP
+INST_TAIL;
+goto *next_code;
+#endif /* defined(NO_IP) */
 
 (dovar) ( -- a_body )	gforth-internal	paren_dovar
 ""run-time routine for variables and CREATEd words""
 a_body = PFA(CFA);
+#ifdef NO_IP
+INST_TAIL;
+goto *next_code;
+#endif /* defined(NO_IP) */
 
 (douser) ( -- a_user )	gforth-internal	paren_douser
 ""run-time routine for constants""
 a_user = (Cell *)(up+*(Cell *)PFA(CFA));
+#ifdef NO_IP
+INST_TAIL;
+goto *next_code;
+#endif /* defined(NO_IP) */
 
 (dodefer) ( -- )	gforth-internal	paren_dodefer
 ""run-time routine for deferred words""
+#ifndef NO_IP
 ip=IP; /* undo any ip updating that may have been performed by NEXT_P0 */
+#endif /* !defined(NO_IP) */
 SUPER_END; /* !! probably unnecessary and may lead to measurement errors */
-EXEC(*(Xt *)PFA(CFA));
+VM_JUMP(EXEC1(*(Xt *)PFA(CFA)));
 
 (dofield) ( n1 -- n2 )	gforth-internal	paren_field
 ""run-time routine for fields""
 n2 = n1 + *(Cell *)PFA(CFA);
+#ifdef NO_IP
+INST_TAIL;
+goto *next_code;
+#endif /* defined(NO_IP) */
 
 (dodoes) ( -- a_body R:a_retaddr )	gforth-internal	paren_dodoes
 ""run-time routine for @code{does>}-defined words""
+#ifdef NO_IP
+a_retaddr = next_code;
+a_body = PFA(CFA);
+INST_TAIL;
+goto **(Label *)DOES_CODE1(CFA);
+#else /* !defined(NO_IP) */
 a_retaddr = (Cell *)IP;
 a_body = PFA(CFA);
 SET_IP(DOES_CODE1(CFA));
+#endif /* !defined(NO_IP) */
 
 (does-handler) ( -- )	gforth-internal	paren_does_handler
 ""just a slot to have an encoding for the DOESJUMP, 
@@ -194,6 +231,7 @@ noop	( -- )		gforth
 call	( #a_callee -- R:a_retaddr )	new
 ""Call callee (a variant of docol with inline argument).""
 #ifdef NO_IP
+assert(0);
 INST_TAIL;
 JUMP(a_callee);
 #else
@@ -213,9 +251,8 @@ execute	( xt -- )		core
 #ifndef NO_IP
 ip=IP;
 #endif
-IF_spTOS(spTOS = sp[0]);
 SUPER_END;
-EXEC(xt);
+VM_JUMP(EXEC1(xt));
 
 perform	( a_addr -- )	gforth
 ""@code{@@ execute}.""
@@ -223,9 +260,8 @@ perform	( a_addr -- )	gforth
 #ifndef NO_IP
 ip=IP;
 #endif
-IF_spTOS(spTOS = sp[0]);
 SUPER_END;
-EXEC(*(Xt *)a_addr);
+VM_JUMP(EXEC1(*(Xt *)a_addr));
 :
  @ execute ;
 
@@ -248,7 +284,7 @@ lit-perform	( #a_addr -- )	new	lit_perfo
 ip=IP;
 #endif
 SUPER_END;
-EXEC(*(Xt *)a_addr);
+VM_JUMP(EXEC1(*(Xt *)a_addr));
 
 does-exec ( #a_cfa -- R:nest a_pfa )	new	does_exec
 #ifdef NO_IP
@@ -257,7 +293,6 @@ assert(0);
 #else
 a_pfa = PFA(a_cfa);
 nest = (Cell)IP;
-IF_spTOS(spTOS = sp[0]);
 #ifdef DEBUG
     {
       CFA_TO_NAME(a_cfa);
@@ -294,6 +329,8 @@ SET_IP((Xt *)a_target);
 
 \ condbranch(forthname,stackeffect,restline,code1,code2,forthcode)
 \ this is non-syntactical: code must open a brace that is closed by the macro
+\ condbranch(forthname,stackeffect,restline,code1,code2,forthcode)
+\ this is non-syntactical: code must open a brace that is closed by the macro
 define(condbranch,
 $1 ( `#'a_target $2 ) $3
 $4	#ifdef NO_IP
@@ -303,6 +340,37 @@ $5	#ifdef NO_IP
 JUMP(a_target);
 #else
 SET_IP((Xt *)a_target);
+#endif
+}
+$6
+
+\+glocals
+
+$1-lp+!`#' ( `#'a_target `#'nlocals $2 ) $3_lp_plus_store_number
+$4	#ifdef NO_IP
+INST_TAIL;
+#endif
+$5	lp += nlocals;
+#ifdef NO_IP
+JUMP(a_target);
+#else
+SET_IP((Xt *)a_target);
+#endif
+}
+
+\+
+)
+
+\ version that generates two jumps (not good for PR 15242 workaround)
+define(condbranch_twojump,
+$1 ( `#'a_target $2 ) $3
+$4	#ifdef NO_IP
+INST_TAIL;
+#endif
+$5	#ifdef NO_IP
+JUMP(a_target);
+#else
+SET_IP((Xt *)a_target);
 INST_TAIL; NEXT_P2;
 #endif
 }
@@ -341,37 +409,31 @@ condbranch(?branch,f --,f83	question_bra
 
 \+xconds
 
-?dup-?branch	( #a_target f -- f )	new	question_dupe_question_branch
+?dup-?branch	( #a_target f -- S:... )	new	question_dupe_question_branch
 ""The run-time procedure compiled by @code{?DUP-IF}.""
 if (f==0) {
-  sp++;
-  IF_spTOS(spTOS = sp[0]);
 #ifdef NO_IP
 INST_TAIL;
 JUMP(a_target);
 #else
 SET_IP((Xt *)a_target);
-  INST_TAIL; NEXT_P2;
 #endif
+} else {
+sp--;
+sp[0]=f;
 }
-SUPER_CONTINUE;
 
-?dup-0=-?branch ( #a_target f -- ) new	question_dupe_zero_equals_question_branch
+?dup-0=-?branch ( #a_target f -- S:... ) new	question_dupe_zero_equals_question_branch
 ""The run-time procedure compiled by @code{?DUP-0=-IF}.""
-/* the approach taken here of declaring the word as having the stack
-effect ( f -- ) and correcting for it in the branch-taken case costs a
-few cycles in that case, but is easy to convert to a CONDBRANCH
-invocation */
 if (f!=0) {
   sp--;
+  sp[0]=f;
 #ifdef NO_IP
   JUMP(a_target);
 #else
   SET_IP((Xt *)a_target);
-  NEXT;
 #endif
 }
-SUPER_CONTINUE;
 
 \+
 \fhas? skiploopprims 0= [IF]
@@ -397,8 +459,9 @@ condbranch((+loop),n R:nlimit R:n1 -- R:
 /* dependent upon two's complement arithmetic */
 Cell olddiff = n1-nlimit;
 n2=n1+n;	
-,if ((olddiff^(olddiff+n))>=0   /* the limit is not crossed */
-    || (olddiff^n)>=0          /* it is a wrap-around effect */) {
+,if (((olddiff^(olddiff+n))    /* the limit is not crossed */
+     &(olddiff^n))	       /* OR it is a wrap-around effect */
+    >=0) { /* & is used to avoid having two branches for gforth-native */
 ,:
  r> swap
  r> r> 2dup - >r
@@ -427,7 +490,7 @@ if (n<0) {
     newdiff = -newdiff;
 }
 n2=n1+n;
-,if (diff>=0 || newdiff<0) {
+,if (((~diff)|newdiff)<0) { /* use | to avoid two branches for gforth-native */
 ,)
 
 \+
@@ -451,10 +514,8 @@ if (nstart == nlimit) {
     JUMP(a_target);
 #else
     SET_IP((Xt *)a_target);
-    INST_TAIL; NEXT_P2;
 #endif
 }
-SUPER_CONTINUE;
 :
   2dup =
   IF   r> swap rot >r >r
@@ -474,10 +535,8 @@ if (nstart >= nlimit) {
     JUMP(a_target);
 #else
     SET_IP((Xt *)a_target);
-    INST_TAIL; NEXT_P2;
 #endif
 }
-SUPER_CONTINUE;
 :
  swap 2dup
  r> swap >r swap >r
@@ -497,10 +556,8 @@ if (ustart >= ulimit) {
 JUMP(a_target);
 #else
 SET_IP((Xt *)a_target);
-INST_TAIL; NEXT_P2;
 #endif
 }
-SUPER_CONTINUE;
 :
  swap 2dup
  r> swap >r swap >r
@@ -520,10 +577,8 @@ if (nstart <= nlimit) {
 JUMP(a_target);
 #else
 SET_IP((Xt *)a_target);
-INST_TAIL; NEXT_P2;
 #endif
 }
-SUPER_CONTINUE;
 :
  swap 2dup
  r> swap >r swap >r
@@ -543,10 +598,8 @@ if (ustart <= ulimit) {
 JUMP(a_target);
 #else
 SET_IP((Xt *)a_target);
-INST_TAIL; NEXT_P2;
 #endif
 }
-SUPER_CONTINUE;
 :
  swap 2dup
  r> swap >r swap >r
@@ -638,6 +691,10 @@ n = compare(c_addr1, u1, c_addr2, u2);
 :
  rot 2dup swap - >r min swap -text dup
  IF  rdrop  ELSE  drop r> sgn  THEN ;
+: -text ( c_addr1 u c_addr2 -- n )
+ swap bounds
+ ?DO  dup c@ I c@ = WHILE  1+  LOOP  drop 0
+ ELSE  c@ I c@ - unloop  THEN  sgn ;
 : sgn ( n -- -1/0/1 )
  dup 0= IF EXIT THEN  0< 2* 1+ ;
 
@@ -743,20 +800,67 @@ n = n1*n2;
 
 /	( n1 n2 -- n )		core	slash
 n = n1/n2;
+if(FLOORED_DIV && ((n1^n2) < 0) && (n1%n2 != 0)) n--;
 :
  /mod nip ;
 
 mod	( n1 n2 -- n )		core
 n = n1%n2;
+if(FLOORED_DIV && ((n1^n2) < 0) && n!=0) n += n2;
 :
  /mod drop ;
 
 /mod	( n1 n2 -- n3 n4 )		core		slash_mod
 n4 = n1/n2;
 n3 = n1%n2; /* !! is this correct? look into C standard! */
+if (FLOORED_DIV && ((n1^n2) < 0) && n3!=0) {
+  n4--;
+  n3+=n2;
+}
 :
  >r s>d r> fm/mod ;
 
+*/mod	( n1 n2 n3 -- n4 n5 )	core	star_slash_mod
+""n1*n2=n3*n5+n4, with the intermediate result (n1*n2) being double.""
+#ifdef BUGGY_LL_MUL
+DCell d = mmul(n1,n2);
+#else
+DCell d = (DCell)n1 * (DCell)n2;
+#endif
+#ifdef BUGGY_LL_DIV
+DCell r = fmdiv(d,n3);
+n4=DHI(r);
+n5=DLO(r);
+#else
+/* assumes that the processor uses either floored or symmetric division */
+n5 = d/n3;
+n4 = d%n3;
+if (FLOORED_DIV && ((DHI(d)^n3)<0) && n4!=0) {
+  n5--;
+  n4+=n3;
+}
+#endif
+:
+ >r m* r> fm/mod ;
+
+*/	( n1 n2 n3 -- n4 )	core	star_slash
+""n4=(n1*n2)/n3, with the intermediate result being double.""
+#ifdef BUGGY_LL_MUL
+DCell d = mmul(n1,n2);
+#else
+DCell d = (DCell)n1 * (DCell)n2;
+#endif
+#ifdef BUGGY_LL_DIV
+DCell r = fmdiv(d,n3);
+n4=DLO(r);
+#else
+/* assumes that the processor uses either floored or symmetric division */
+n4 = d/n3;
+if (FLOORED_DIV && ((DHI(d)^n3)<0) && (d%n3)!=0) n4--;
+#endif
+:
+ */mod nip ;
+
 2*	( n1 -- n2 )		core		two_star
 ""Shift left by 1; also works on unsigned numbers""
 n2 = 2*n1;
@@ -776,19 +880,35 @@ n2 = n1>>1;
 
 fm/mod	( d1 n1 -- n2 n3 )		core		f_m_slash_mod
 ""Floored division: @i{d1} = @i{n3}*@i{n1}+@i{n2}, @i{n1}>@i{n2}>=0 or 0>=@i{n2}>@i{n1}.""
-#ifdef BUGGY_LONG_LONG
+#ifdef BUGGY_LL_DIV
+#ifdef ASM_SM_SLASH_REM
+ASM_SM_SLASH_REM(d1.lo, d1.hi, n1, n2, n3);
+if (((DHI(d1)^n1)<0) && n2!=0) {
+  n3--;
+  n2+=n1;
+}
+#else /* !defined(ASM_SM_SLASH_REM) */
 DCell r = fmdiv(d1,n1);
-n2=r.hi;
-n3=r.lo;
-#else
+n2=DHI(r);
+n3=DLO(r);
+#endif /* !defined(ASM_SM_SLASH_REM) */
+#else
+#ifdef ASM_SM_SLASH_REM4
+ASM_SM_SLASH_REM4(d1, n1, n2, n3);
+if (((DHI(d1)^n1)<0) && n2!=0) {
+  n3--;
+  n2+=n1;
+}
+#else /* !defined(ASM_SM_SLASH_REM4) */
 /* assumes that the processor uses either floored or symmetric division */
 n3 = d1/n1;
 n2 = d1%n1;
 /* note that this 1%-3>0 is optimized by the compiler */
-if (1%-3>0 && (d1<0) != (n1<0) && n2!=0) {
+if (1%-3>0 && ((DHI(d1)^n1)<0) && n2!=0) {
   n3--;
   n2+=n1;
 }
+#endif /* !defined(ASM_SM_SLASH_REM4) */
 #endif
 :
  dup >r dup 0< IF  negate >r dnegate r>  THEN
@@ -798,19 +918,27 @@ if (1%-3>0 && (d1<0) != (n1<0) && n2!=0)
 
 sm/rem	( d1 n1 -- n2 n3 )		core		s_m_slash_rem
 ""Symmetric division: @i{d1} = @i{n3}*@i{n1}+@i{n2}, sign(@i{n2})=sign(@i{d1}) or 0.""
-#ifdef BUGGY_LONG_LONG
+#ifdef BUGGY_LL_DIV
+#ifdef ASM_SM_SLASH_REM
+ASM_SM_SLASH_REM(d1.lo, d1.hi, n1, n2, n3);
+#else /* !defined(ASM_SM_SLASH_REM) */
 DCell r = smdiv(d1,n1);
-n2=r.hi;
-n3=r.lo;
-#else
+n2=DHI(r);
+n3=DLO(r);
+#endif /* !defined(ASM_SM_SLASH_REM) */
+#else
+#ifdef ASM_SM_SLASH_REM4
+ASM_SM_SLASH_REM4(d1, n1, n2, n3);
+#else /* !defined(ASM_SM_SLASH_REM4) */
 /* assumes that the processor uses either floored or symmetric division */
 n3 = d1/n1;
 n2 = d1%n1;
 /* note that this 1%-3<0 is optimized by the compiler */
-if (1%-3<0 && (d1<0) != (n1<0) && n2!=0) {
+if (1%-3<0 && ((DHI(d1)^n1)<0) && n2!=0) {
   n3++;
   n2-=n1;
 }
+#endif /* !defined(ASM_SM_SLASH_REM4) */
 #endif
 :
  over >r dup >r abs -rot
@@ -819,7 +947,7 @@ if (1%-3<0 && (d1<0) != (n1<0) && n2!=0)
  r>        0< IF  swap negate swap  THEN ;
 
 m*	( n1 n2 -- d )		core	m_star
-#ifdef BUGGY_LONG_LONG
+#ifdef BUGGY_LL_MUL
 d = mmul(n1,n2);
 #else
 d = (DCell)n1 * (DCell)n2;
@@ -831,7 +959,7 @@ d = (DCell)n1 * (DCell)n2;
 
 um*	( u1 u2 -- ud )		core	u_m_star
 /* use u* as alias */
-#ifdef BUGGY_LONG_LONG
+#ifdef BUGGY_LL_MUL
 ud = ummul(u1,u2);
 #else
 ud = (UDCell)u1 * (UDCell)u2;
@@ -847,13 +975,21 @@ ud = (UDCell)u1 * (UDCell)u2;
 
 um/mod	( ud u1 -- u2 u3 )		core	u_m_slash_mod
 ""ud=u3*u1+u2, u1>u2>=0""
-#ifdef BUGGY_LONG_LONG
+#ifdef BUGGY_LL_DIV
+#ifdef ASM_UM_SLASH_MOD
+ASM_UM_SLASH_MOD(ud.lo, ud.hi, u1, u2, u3);
+#else /* !defined(ASM_UM_SLASH_MOD) */
 UDCell r = umdiv(ud,u1);
-u2=r.hi;
-u3=r.lo;
-#else
+u2=DHI(r);
+u3=DLO(r);
+#endif /* !defined(ASM_UM_SLASH_MOD) */
+#else
+#ifdef ASM_UM_SLASH_MOD4
+ASM_UM_SLASH_MOD4(ud, u1, u2, u3);
+#else /* !defined(ASM_UM_SLASH_MOD4) */
 u3 = ud/u1;
 u2 = ud%u1;
+#endif /* !defined(ASM_UM_SLASH_MOD4) */
 #endif
 :
    0 swap [ 8 cells 1 + ] literal 0
@@ -866,9 +1002,9 @@ u2 = ud%u1;
    and >r >r 2dup d+ swap r> + swap r> ;
 
 m+	( d1 n -- d2 )		double		m_plus
-#ifdef BUGGY_LONG_LONG
-d2.lo = d1.lo+n;
-d2.hi = d1.hi - (n<0) + (d2.lo<d1.lo);
+#ifdef BUGGY_LL_ADD
+DLO_IS(d2, DLO(d1)+n);
+DHI_IS(d2, DHI(d1) - (n<0) + (DLO(d2)<DLO(d1)));
 #else
 d2 = d1+n;
 #endif
@@ -876,9 +1012,9 @@ d2 = d1+n;
  s>d d+ ;
 
 d+	( d1 d2 -- d )		double	d_plus
-#ifdef BUGGY_LONG_LONG
-d.lo = d1.lo+d2.lo;
-d.hi = d1.hi + d2.hi + (d.lo<d1.lo);
+#ifdef BUGGY_LL_ADD
+DLO_IS(d, DLO(d1) + DLO(d2));
+DHI_IS(d, DHI(d1) + DHI(d2) + (d.lo<DLO(d1)));
 #else
 d = d1+d2;
 #endif
@@ -886,9 +1022,9 @@ d = d1+d2;
  rot + >r tuck + swap over u> r> swap - ;
 
 d-	( d1 d2 -- d )		double		d_minus
-#ifdef BUGGY_LONG_LONG
-d.lo = d1.lo - d2.lo;
-d.hi = d1.hi-d2.hi-(d1.lo<d2.lo);
+#ifdef BUGGY_LL_ADD
+DLO_IS(d, DLO(d1) - DLO(d2));
+DHI_IS(d, DHI(d1)-DHI(d2)-(DLO(d1)<DLO(d2)));
 #else
 d = d1-d2;
 #endif
@@ -897,7 +1033,7 @@ d = d1-d2;
 
 dnegate	( d1 -- d2 )		double	d_negate
 /* use dminus as alias */
-#ifdef BUGGY_LONG_LONG
+#ifdef BUGGY_LL_ADD
 d2 = dnegate(d1);
 #else
 d2 = -d1;
@@ -907,9 +1043,9 @@ d2 = -d1;
 
 d2*	( d1 -- d2 )		double		d_two_star
 ""Shift left by 1; also works on unsigned numbers""
-#ifdef BUGGY_LONG_LONG
-d2.lo = d1.lo<<1;
-d2.hi = (d1.hi<<1) | (d1.lo>>(CELL_BITS-1));
+#ifdef BUGGY_LL_SHIFT
+DLO_IS(d2, DLO(d1)<<1);
+DHI_IS(d2, (DHI(d1)<<1) | (DLO(d1)>>(CELL_BITS-1)));
 #else
 d2 = 2*d1;
 #endif
@@ -919,9 +1055,9 @@ d2 = 2*d1;
 d2/	( d1 -- d2 )		double		d_two_slash
 ""Arithmetic shift right by 1.  For signed numbers this is a floored
 division by 2.""
-#ifdef BUGGY_LONG_LONG
-d2.hi = d1.hi>>1;
-d2.lo= (d1.lo>>1) | (d1.hi<<(CELL_BITS-1));
+#ifdef BUGGY_LL_SHIFT
+DHI_IS(d2, DHI(d1)>>1);
+DLO_IS(d2, (DLO(d1)>>1) | (DHI(d1)<<(CELL_BITS-1)));
 #else
 d2 = d1>>1;
 #endif
@@ -947,12 +1083,20 @@ w2 = ~w1;
 
 rshift	( u1 n -- u2 )		core	r_shift
 ""Logical shift right by @i{n} bits.""
-  u2 = u1>>n;
+#ifdef BROKEN_SHIFT
+  u2 = rshift(u1, n);
+#else
+  u2 = u1 >> n;
+#endif
 :
     0 ?DO 2/ MAXI and LOOP ;
 
 lshift	( u1 n -- u2 )		core	l_shift
-  u2 = u1<<n;
+#ifdef BROKEN_SHIFT
+  u2 = lshift(u1, n);
+#else
+  u2 = u1 << n;
+#endif
 :
     0 ?DO 2* LOOP ;
 
@@ -1016,42 +1160,42 @@ comparisons(u, u1 u2, u_, u1, u2, gforth
 \ dcomparisons(prefix, args, prefix, arg1, arg2, wordsets...)
 define(dcomparisons,
 $1=	( $2 -- f )		$6	$3equals
-#ifdef BUGGY_LONG_LONG
+#ifdef BUGGY_LL_CMP
 f = FLAG($4.lo==$5.lo && $4.hi==$5.hi);
 #else
 f = FLAG($4==$5);
 #endif
 
 $1<>	( $2 -- f )		$7	$3not_equals
-#ifdef BUGGY_LONG_LONG
+#ifdef BUGGY_LL_CMP
 f = FLAG($4.lo!=$5.lo || $4.hi!=$5.hi);
 #else
 f = FLAG($4!=$5);
 #endif
 
 $1<	( $2 -- f )		$8	$3less_than
-#ifdef BUGGY_LONG_LONG
+#ifdef BUGGY_LL_CMP
 f = FLAG($4.hi==$5.hi ? $4.lo<$5.lo : $4.hi<$5.hi);
 #else
 f = FLAG($4<$5);
 #endif
 
 $1>	( $2 -- f )		$9	$3greater_than
-#ifdef BUGGY_LONG_LONG
+#ifdef BUGGY_LL_CMP
 f = FLAG($4.hi==$5.hi ? $4.lo>$5.lo : $4.hi>$5.hi);
 #else
 f = FLAG($4>$5);
 #endif
 
 $1<=	( $2 -- f )		gforth	$3less_or_equal
-#ifdef BUGGY_LONG_LONG
+#ifdef BUGGY_LL_CMP
 f = FLAG($4.hi==$5.hi ? $4.lo<=$5.lo : $4.hi<=$5.hi);
 #else
 f = FLAG($4<=$5);
 #endif
 
 $1>=	( $2 -- f )		gforth	$3greater_or_equal
-#ifdef BUGGY_LONG_LONG
+#ifdef BUGGY_LL_CMP
 f = FLAG($4.hi==$5.hi ? $4.lo>=$5.lo : $4.hi>=$5.hi);
 #else
 f = FLAG($4>=$5);
@@ -1090,12 +1234,11 @@ UP=up=(char *)a_addr;
  up ! ;
 Variable UP
 
-sp@	( -- a_addr )		gforth		sp_fetch
-a_addr = sp+1;
+sp@	( S:... -- a_addr )		gforth		sp_fetch
+a_addr = sp;
 
-sp!	( a_addr -- )		gforth		sp_store
+sp!	( a_addr -- S:... )		gforth		sp_store
 sp = a_addr;
-/* works with and without spTOS caching */
 
 rp@	( -- a_addr )		gforth		rp_fetch
 a_addr = rp;
@@ -1105,10 +1248,10 @@ rp = a_addr;
 
 \+floating
 
-fp@	( -- f_addr )	gforth	fp_fetch
+fp@	( f:... -- f_addr )	gforth	fp_fetch
 f_addr = fp;
 
-fp!	( f_addr -- )	gforth	fp_store
+fp!	( f_addr -- f:... )	gforth	fp_store
 fp = f_addr;
 
 \+
@@ -1181,21 +1324,18 @@ tuck	( w1 w2 -- w2 w1 w2 )	core-ext
 :
  swap over ;
 
-?dup	( w -- w )			core	question_dupe
+?dup	( w -- S:... w )	core	question_dupe
 ""Actually the stack effect is: @code{( w -- 0 | w w )}.  It performs a
 @code{dup} if w is nonzero.""
 if (w!=0) {
-  IF_spTOS(*sp-- = w;)
-#ifndef USE_TOS
   *--sp = w;
-#endif
 }
 :
  dup IF dup THEN ;
 
-pick	( u -- w )			core-ext
+pick	( S:... u -- S:... w )		core-ext
 ""Actually the stack effect is @code{ x0 ... xu u -- x0 ... xu x0 }.""
-w = sp[u+1];
+w = sp[u];
 :
  1+ cells sp@ + @ ;
 
@@ -1396,6 +1536,14 @@ longname2=listlfind(c_addr, u, longname1
     REPEAT  THEN  nip nip ;
 : (findl-samelen) ( u longname1 -- u longname2/0 )
     BEGIN  2dup cell+ @ lcount-mask and <> WHILE  @  dup 0= UNTIL  THEN ;
+: capscomp ( c_addr1 u c_addr2 -- n )
+ swap bounds
+ ?DO  dup c@ I c@ <>
+     IF  dup c@ toupper I c@ toupper =
+     ELSE  true  THEN  WHILE  1+  LOOP  drop 0
+ ELSE  c@ toupper I c@ toupper - unloop  THEN  sgn ;
+: sgn ( n -- -1/0/1 )
+ dup 0= IF EXIT THEN  0< 2* 1+ ;
 
 \+hash
 
@@ -1497,7 +1645,7 @@ n = key((FILE*)wfileid);
 n = key(stdin);
 #endif
 
-key?-file	( wfileid -- n )		facility	key_q_file
+key?-file	( wfileid -- n )	        gforth	key_q_file
 #ifdef HAS_FILE
 fflush(stdout);
 n = key_query((FILE*)wfileid);
@@ -1541,16 +1689,8 @@ SUPER_END;
 return (Label *)n;
 
 (system)	( c_addr u -- wretval wior )	gforth	paren_system
-#ifndef MSDOS
-int old_tp=terminal_prepped;
-deprep_terminal();
-#endif
-wretval=system(cstr(c_addr,u,1)); /* ~ expansion on first part of string? */
+wretval = gforth_system(c_addr, u);  
 wior = IOR(wretval==-1 || (wretval==127 && errno != 0));
-#ifndef MSDOS
-if (old_tp)
-  prep_terminal();
-#endif
 
 getenv	( c_addr1 u1 -- c_addr2 u2 )	gforth
 ""The string @i{c-addr1 u1} specifies an environment variable. The string @i{c-addr2 u2}
@@ -1642,20 +1782,17 @@ strsignal	( n -- c_addr u )	gforth
 c_addr = (Address)strsignal(n);
 u = strlen(c_addr);
 
-call-c	( w -- )	gforth	call_c
+call-c	( ... w -- ... )	gforth	call_c
 ""Call the C function pointed to by @i{w}. The C function has to
 access the stack itself. The stack pointers are exported in the global
 variables @code{SP} and @code{FP}.""
 /* This is a first attempt at support for calls to C. This may change in
    the future */
-IF_fpTOS(fp[0]=fpTOS);
 FP=fp;
 SP=sp;
 ((void (*)())w)();
 sp=SP;
 fp=FP;
-IF_spTOS(spTOS=sp[0]);
-IF_fpTOS(fpTOS=fp[0]);
 
 \+
 \+file
@@ -1796,6 +1933,21 @@ char * string = cstr(c_addr1, u1, 1);
 char * pattern = cstr(c_addr2, u2, 0);
 flag = FLAG(!fnmatch(pattern, string, 0));
 
+set-dir	( c_addr u -- wior )	gforth set_dir
+""Change the current directory to @i{c-addr, u}.
+Return an error if this is not possible""
+wior = IOR(chdir(tilde_cstr(c_addr, u, 1)));
+
+get-dir	( c_addr1 u1 -- c_addr2 u2 )	gforth get_dir
+""Store the current directory in the buffer specified by @{c-addr1, u1}.
+If the buffer size is not sufficient, return 0 0""
+c_addr2 = getcwd(c_addr1, u1);
+if(c_addr2 != NULL) {
+  u2 = strlen(c_addr2);
+} else {
+  u2 = 0;
+}
+
 \+
 
 newline	( -- c_addr u )	gforth
@@ -1838,11 +1990,7 @@ dsystem = timeval2us(&usage.ru_stime);
 struct timeval time1;
 gettimeofday(&time1,NULL);
 duser = timeval2us(&time1);
-#ifndef BUGGY_LONG_LONG
-dsystem = (DCell)0;
-#else
-dsystem=(DCell){0,0};
-#endif
+dsystem = DZERO;
 #endif
 
 \+
@@ -1854,14 +2002,21 @@ dsystem=(DCell){0,0};
 comparisons(f, r1 r2, f_, r1, r2, gforth, gforth, float, gforth)
 comparisons(f0, r, f_zero_, r, 0., float, gforth, float, gforth)
 
+s>f	( n -- r )		float	s_to_f
+r = n;
+
 d>f	( d -- r )		float	d_to_f
-#ifdef BUGGY_LONG_LONG
+#ifdef BUGGY_LL_D2F
 extern double ldexp(double x, int exp);
-if (d.hi<0) {
+if (DHI(d)<0) {
+#ifdef BUGGY_LL_ADD
   DCell d2=dnegate(d);
-  r = -(ldexp((Float)d2.hi,CELL_BITS) + (Float)d2.lo);
+#else
+  DCell d2=-d;
+#endif
+  r = -(ldexp((Float)DHI(d2),CELL_BITS) + (Float)DLO(d2));
 } else
-  r = ldexp((Float)d.hi,CELL_BITS) + (Float)d.lo;
+  r = ldexp((Float)DHI(d),CELL_BITS) + (Float)DLO(d);
 #else
 r = d;
 #endif
@@ -1870,6 +2025,9 @@ f>d	( r -- d )		float	f_to_d
 extern DCell double2ll(Float r);
 d = double2ll(r);
 
+f>s	( r -- n )		float	f_to_s
+n = (Cell)r;
+
 f!	( r f_addr -- )	float	f_store
 ""Store @i{r} into the float at address @i{f-addr}.""
 *f_addr = r;
@@ -1928,6 +2086,18 @@ f**	( r1 r2 -- r3 )	float-ext	f_star_sta
 ""@i{r3} is @i{r1} raised to the @i{r2}th power.""
 r3 = pow(r1,r2);
 
+fm*	( r1 n -- r2 )	gforth	fm_star
+r2 = r1*n;
+
+fm/	( r1 n -- r2 )	gforth	fm_slash
+r2 = r1/n;
+
+fm*/	( r1 n1 n2 -- r2 )	gforth	fm_star_slash
+r2 = (r1*n1)/n2;
+
+f**2	( r1 -- r2 )	gforth	fm_square
+r2 = r1*r1;
+
 fnegate	( r1 -- r2 )	float	f_negate
 r2 = - r1;
 
@@ -1986,10 +2156,13 @@ f2=FLAG(isdigit((unsigned)(sig[0]))!=0);
 siglen=strlen(sig);
 if (siglen>u) /* happens in glibc-2.1.3 if 999.. is rounded up */
   siglen=u;
+if (!f2) /* workaround Cygwin trailing 0s for Inf and Nan */
+  for (; sig[siglen-1]=='0'; siglen--);
+    ;
 memcpy(c_addr,sig,siglen);
 memset(c_addr+siglen,f2?'0':' ',u-siglen);
 
->float	( c_addr u -- flag )	float	to_float
+>float	( c_addr u -- f:... flag )	float	to_float
 ""Actual stack effect: ( c_addr u -- r t | f ).  Attempt to convert the
 character string @i{c-addr u} to internal floating-point
 representation. If the string represents a valid floating-point number
@@ -1999,9 +2172,8 @@ case and represents the floating-point n
 Float r;
 flag = to_float(c_addr, u, &r);
 if (flag) {
-  IF_fpTOS(fp[0] = fpTOS);
-  fp += -1;
-  fpTOS = r;
+  fp--;
+  fp[0]=r;
 }
 
 fabs	( r1 -- r2 )	float-ext	f_abs
@@ -2227,9 +2399,9 @@ f>l	( r -- )	gforth	f_to_l
 lp -= sizeof(Float);
 *(Float *)lp = r;
 
-fpick	( u -- r )		gforth
+fpick	( f:... u -- f:... r )		gforth
 ""Actually the stack effect is @code{ r0 ... ru u -- r0 ... ru r0 }.""
-r = fp[u+1]; /* +1, because update of fp happens before this fragment */
+r = fp[u];
 :
  floats fp@ + f@ ;
 
@@ -2267,6 +2439,29 @@ u3 = 0;
 #  endif
 #endif
 
+wcall	( ... u -- ... )	gforth
+FP=fp;
+sp=(Cell*)(SYSCALL(Cell*(*)(Cell *, void *))u)(sp, &FP);
+fp=FP;
+
+w@ ( a_addr -- u )	gforth wfetch
+u = *(UWyde*)(a_addr);
+
+sw@ ( a_addr -- u )	gforth swfetch
+u = *(Wyde*)(a_addr);
+
+w! ( u a_addr -- )	gforth wstore
+*(Wyde*)(a_addr) = u;
+
+l@ ( a_addr -- u )	gforth lfetch
+u = *(UTetrabyte*)(a_addr);
+
+sl@ ( a_addr -- u )	gforth slfetch
+u = *(Tetrabyte*)(a_addr);
+
+l! ( u a_addr -- )	gforth lstore
+*(Tetrabyte*)(a_addr) = u;
+
 \+FFCALL
 
 av-start-void	( c_addr -- )	gforth  av_start_void
@@ -2297,7 +2492,11 @@ av-double	( r -- )	gforth  av_double
 av_double(alist, r);
 
 av-longlong	( d -- )	gforth  av_longlong
+#ifdef BUGGY_LL_SIZE
+av_longlong(alist, DLO(d));
+#else
 av_longlong(alist, d);
+#endif
 
 av-ptr	( c_addr -- )	gforth  av_ptr
 av_ptr(alist, void*, c_addr);
@@ -2316,41 +2515,50 @@ lp += sizeof(Float);
 av_double(alist, r);
 
 av-longlong-r	( R:d -- )	gforth  av_longlong_r
+#ifdef BUGGY_LL_SIZE
+av_longlong(alist, DLO(d));
+#else
 av_longlong(alist, d);
+#endif
 
 av-ptr-r	( R:c_addr -- )	gforth  av_ptr_r
 av_ptr(alist, void*, c_addr);
 
-av-call-void	( -- )	gforth  av_call_void
+av-call-void	( ... -- ... )	gforth  av_call_void
 SAVE_REGS
 av_call(alist);
 REST_REGS
 
-av-call-int	( -- w )	gforth  av_call_int
+av-call-int	( ... -- ... w )	gforth  av_call_int
 SAVE_REGS
 av_call(alist);
 REST_REGS
 w = irv;
 
-av-call-float	( -- r )	gforth  av_call_float
+av-call-float	( ... -- ... r )	gforth  av_call_float
 SAVE_REGS
 av_call(alist);
 REST_REGS
 r = frv;
 
-av-call-double	( -- r )	gforth  av_call_double
+av-call-double	( ... -- ... r )	gforth  av_call_double
 SAVE_REGS
 av_call(alist);
 REST_REGS
 r = drv;
 
-av-call-longlong	( -- d )	gforth  av_call_longlong
+av-call-longlong	( ... -- ... d )	gforth  av_call_longlong
 SAVE_REGS
 av_call(alist);
 REST_REGS
+#ifdef BUGGY_LONG_LONG
+DLO_IS(d, llrv);
+DHI_IS(d, 0);
+#else
 d = llrv;
+#endif
 
-av-call-ptr	( -- c_addr )	gforth  av_call_ptr
+av-call-ptr	( ... -- ... c_addr )	gforth  av_call_ptr
 SAVE_REGS
 av_call(alist);
 REST_REGS
@@ -2381,7 +2589,12 @@ va-arg-int	( -- w )	gforth	va_arg_int
 w = va_arg_int(clist);
 
 va-arg-longlong	( -- d )	gforth	va_arg_longlong
+#ifdef BUGGY_LONG_LONG
+DLO_IS(d, va_arg_longlong(clist));
+DHI_IS(d, 0);
+#else
 d = va_arg_longlong(clist);
+#endif
 
 va-arg-ptr	( -- c_addr )	gforth	va_arg_ptr
 c_addr = (char *)va_arg_ptr(clist,char*);
@@ -2405,7 +2618,11 @@ va_return_ptr(clist, void *, c_addr);
 return 0;
 
 va-return-longlong ( d -- )	gforth va_return_longlong
+#ifdef BUGGY_LONG_LONG
+va_return_longlong(clist, d.lo);
+#else
 va_return_longlong(clist, d);
+#endif
 return 0;
 
 va-return-float ( r -- )	gforth va_return_float
@@ -2416,7 +2633,102 @@ va-return-double ( r -- )	gforth va_retu
 va_return_double(clist, r);
 return 0;
 
-\-
+\+
+
+\+LIBFFI
+
+ffi-type ( n -- a_type )	gforth ffi_type
+static void* ffi_types[] =
+    { &ffi_type_void,
+      &ffi_type_uint8, &ffi_type_sint8,
+      &ffi_type_uint16, &ffi_type_sint16,
+      &ffi_type_uint32, &ffi_type_sint32,
+      &ffi_type_uint64, &ffi_type_sint64,
+      &ffi_type_float, &ffi_type_double, &ffi_type_longdouble,
+      &ffi_type_pointer };
+a_type = ffi_types[n];
+
+ffi-size ( n1 -- n2 )	gforth ffi_size
+static int ffi_sizes[] =
+    { sizeof(ffi_cif), sizeof(ffi_closure) };
+n2 = ffi_sizes[n1];
+
+ffi-prep-cif ( a_atypes n a_rtype a_cif -- w )	gforth ffi_prep_cif
+w = ffi_prep_cif(a_cif, FFI_DEFAULT_ABI, n, a_rtype, a_atypes);
+
+ffi-call ( a_avalues a_rvalue a_ip a_cif -- )	gforth ffi_call
+SAVE_REGS
+ffi_call(a_cif, a_ip, a_rvalue, a_avalues);
+REST_REGS
+
+ffi-prep-closure ( a_ip a_cif a_closure -- w )	gforth ffi_prep_closure
+w = ffi_prep_closure(a_closure, a_cif, ffi_callback, a_ip);
+
+ffi-2@ ( a_addr -- d )	gforth ffi_2fetch
+#ifdef BUGGY_LONG_LONG
+DLO_IS(d, (Cell*)(*a_addr));
+DHI_IS(d, 0);
+#else
+d = *(DCell*)(a_addr);
+#endif
+
+ffi-2! ( d a_addr -- )	gforth ffi_2store
+#ifdef BUGGY_LONG_LONG
+*(Cell*)(a_addr) = DLO(d);
+#else
+*(DCell*)(a_addr) = d;
+#endif
+
+ffi-arg-int ( -- w )	gforth ffi_arg_int
+w = *(int *)(*clist++);
+
+ffi-arg-longlong ( -- d )	gforth ffi_arg_longlong
+#ifdef BUGGY_LONG_LONG
+DLO_IS(d, (Cell*)(*clist++));
+DHI_IS(d, 0);
+#else
+d = *(DCell*)(*clist++);
+#endif
+
+ffi-arg-ptr ( -- c_addr )	gforth ffi_arg_ptr
+c_addr = *(char **)(*clist++);
+
+ffi-arg-float ( -- r )	gforth ffi_arg_float
+r = *(float*)(*clist++);
+
+ffi-arg-double ( -- r )	gforth ffi_arg_double
+r = *(double*)(*clist++);
+
+ffi-ret-void ( -- )	gforth ffi_ret_void
+return 0;
+
+ffi-ret-int ( w -- )	gforth ffi_ret_int
+*(int*)(ritem) = w;
+return 0;
+
+ffi-ret-longlong ( d -- )	gforth ffi_ret_longlong
+#ifdef BUGGY_LONG_LONG
+*(Cell*)(ritem) = DLO(d);
+#else
+*(DCell*)(ritem) = d;
+#endif
+return 0;
+
+ffi-ret-ptr ( c_addr -- )	gforth ffi_ret_ptr
+*(char **)(ritem) = c_addr;
+return 0;
+
+ffi-ret-float ( r -- )	gforth ffi_ret_float
+*(float*)(ritem) = r;
+return 0;
+
+ffi-ret-double ( r -- )	gforth ffi_ret_double
+*(double*)(ritem) = r;
+return 0;
+
+\+
+
+\+OLDCALL
 
 define(`uploop',
        `pushdef(`$1', `$2')_uploop(`$1', `$2', `$3', `$4', `$5')`'popdef(`$1')')
@@ -2457,25 +2769,19 @@ fcall(20)
 \+
 \+
 
-wcall	( u -- )	gforth
-IF_fpTOS(fp[0]=fpTOS);
-FP=fp;
-sp=(Cell*)(SYSCALL(Cell*(*)(Cell *, void *))u)(sp, &FP);
-fp=FP;
-IF_spTOS(spTOS=sp[0];)
-IF_fpTOS(fpTOS=fp[0]);
+\g peephole
 
 \+peephole
 
-\g peephole
-
 compile-prim1 ( a_prim -- ) gforth compile_prim1
 ""compile prim (incl. immargs) at @var{a_prim}""
 compile_prim1(a_prim);
 
-finish-code ( -- ) gforth finish_code
+finish-code ( ... -- ... ) gforth finish_code
 ""Perform delayed steps in code generation (branch resolution, I-cache
 flushing).""
+/* The ... above are a workaround for a bug in gcc-2.95, which fails
+   to save spTOS (gforth-fast --enable-force-reg) */
 finish_code();
 
 forget-dyncode ( c_code -- f ) gforth-internal forget_dyncode
@@ -2511,10 +2817,7 @@ a_addr = groups;
 
 \g static_super
 
-\C #if !defined(GFORTH_DEBUGGING) && !defined(INDIRECT_THREADED) && !defined(DOUBLY_INDIRECT) && !defined(VM_PROFILING)
-
-include(peeprules.vmg)
-
-\C #endif
+ifdef(`STACK_CACHE_FILE',
+`include(peeprules.vmg)')
 
 \g end