--- gforth/stuff.fs	2003/01/24 22:03:20	1.26
+++ gforth/stuff.fs	2005/06/28 06:49:41	1.43
@@ -1,6 +1,6 @@
 \ miscelleneous words
 
-\ Copyright (C) 1996,1997,1998,2000 Free Software Foundation, Inc.
+\ Copyright (C) 1996,1997,1998,2000,2003,2004 Free Software Foundation, Inc.
 
 \ This file is part of Gforth.
 
@@ -51,8 +51,12 @@ AUser CSP
 \G @code{system} command.
 
 : system ( c-addr u -- ) \ gforth
-\G Pass the string specified by @var{c-addr u} to the host operating system
-\G for execution in a sub-shell.
+\G Pass the string specified by @var{c-addr u} to the host operating
+\G system for execution in a sub-shell.  The value of the environment
+\G variable @code{GFORTHSYSTEMPREFIX} (or its default value) is
+\G prepended to the string (mainly to support using @code{command.com}
+\G as shell in Windows instead of whatever shell Cygwin uses by
+\G default; @pxref{Environment variables}).
     (system) throw TO $? ;
 
 : sh ( "..." -- ) \ gforth
@@ -98,19 +102,20 @@ AUser CSP
     ur compile-fliterals uw compile-literals
     target compile, POSTPONE exit reveal ;
 
-: const-does> ( run-time: w*uw r*ur uw ur "name" -- )
-    \G Defines @var{name} and returns.@sp 0
+: const-does> ( run-time: w*uw r*ur uw ur "name" -- ) \ gforth
+    \G Defines @var{name} and returns.
+    \G  
     \G @var{name} execution: pushes @var{w*uw r*ur}, then performs the
     \G code following the @code{const-does>}.
     here >r 0 POSTPONE literal
     POSTPONE (const-does>)
     POSTPONE ;
     noname : POSTPONE rdrop
-    lastxt r> cell+ ! \ patch the literal
+    latestxt r> cell+ ! \ patch the literal
 ; immediate
 
 \ !! rewrite slurp-file using slurp-fid
-: slurp-file ( c-addr1 u1 -- c-addr2 u2 )
+: slurp-file ( c-addr1 u1 -- c-addr2 u2 ) \ gforth
     \G @var{c-addr1 u1} is the filename, @var{c-addr2 u2} is the file's contents
     r/o bin open-file throw >r
     r@ file-size throw abort" file too large"
@@ -118,7 +123,7 @@ AUser CSP
     2dup r@ read-file throw over <> abort" could not read whole file"
     r> close-file throw ;
 
-: slurp-fid { fid -- addr u }
+: slurp-fid { fid -- addr u } \ gforth
     \G @var{addr u} is the content of the file @var{fid}
     0 0 begin ( awhole uwhole )
 	dup 1024 + dup >r extend-mem ( anew awhole uwhole R: unew )
@@ -134,105 +139,137 @@ AUser CSP
 : compile-literal ( n -- )
     postpone literal ;
 
+: compile-compile-literal ( n -- )
+    compile-literal postpone compile-literal ;
+
+: compile-2literal ( n1 n2 -- )
+    postpone 2literal ;
+
+: compile-compile-2literal ( n1 n2 -- )
+    compile-2literal postpone compile-2literal ;
+
 : [[ ( -- )
 \G switch from postpone state to compile state
     \ this is only a marker; it is never really interpreted
     compile-only-error ; immediate
 
-: postponer ( c-addr u -- )
+[ifdef] compiler1
+: postponer1 ( c-addr u -- ... xt )
     2dup find-name dup if ( c-addr u nt )
 	nip nip name>comp
 	2dup [comp'] [[ d= if
-	    2drop ['] compiler is parser
+	    2drop ['] compiler1 is parser1
 	else
-	    postpone,
+	    ['] postpone,
 	endif
     else
 	drop
-	2dup snumber? dup if
+	2dup 2>r snumber? dup if
 	    0> IF
-		swap postpone literal postpone compile-literal
+		['] compile-compile-2literal
+            ELSE
+                ['] compile-compile-literal
 	    THEN
-	    postpone Literal postpone compile-literal
-	    2drop
+	    2rdrop
 	ELSE
-	    drop no.extensions
+	    drop 2r> no.extensions
 	THEN
     then ;
 
 : ]] ( -- )
     \ switch into postpone state
-    ['] postponer is parser state on ; immediate restrict
+    ['] postponer1 is parser1 state on ; immediate restrict
+
+[then]
 
 \ f.rdp
 
-: move-right ( c-addr u1 u2 cfill -- )
+: push-right ( c-addr u1 u2 cfill -- )
     \ move string at c-addr u1 right by u2 chars (without exceeding
     \ the original bound); fill the gap with cfill
-    >r dup >r rot dup >r ( u1 u2 c-addr R: cfill u2 c-addr )
+    >r over min dup >r rot dup >r ( u1 u2 c-addr R: cfill u2 c-addr )
     dup 2swap /string cmove>
     r> r> r> fill ;
 
-: f>buf-rdp { f: rf c-addr ur nd up -- } \ gforth
-\G Convert @i{rf} into a string at @i{c-addr ur}.  The conversion
-\G rules and the meanings of @i{ur nd up} are the same as for
-\G @code{f.rdp}.
-    rf c-addr ur represent if { nexp fsign }
+: f>buf-rdp-try { f: rf c-addr ur nd up um1 -- um2 }
+    \ um1 is the mantissa length to try, um2 is the actual mantissa length
+    c-addr ur um1 /string '0 fill
+    rf c-addr um1 represent if { nexp fsign }
 	nd nexp + up >=
 	ur nd - 1- dup { beforep } fsign + nexp 0 max >= and if
 	    \ fixed-point notation
-	    c-addr ur beforep nexp - dup { befored } '0 move-right
+	    c-addr ur beforep nexp - dup { befored } '0 push-right
 	    c-addr beforep 1- befored min dup { beforez } 0 max bl fill
 	    fsign if
 		'- c-addr beforez 1- 0 max + c!
 	    endif
-	    c-addr ur beforep /string 1 '. move-right
+	    c-addr ur beforep /string 1 '. push-right
+	    nexp nd +
 	else \ exponential notation
-	    c-addr ur 1 /string 1 '. move-right
+	    c-addr ur 1 /string 1 '. push-right
 	    fsign if
-		c-addr ur 1 '- move-right
+		c-addr ur 1 '- push-right
 	    endif
 	    nexp 1- s>d tuck dabs <<# #s rot sign 'E hold #> { explen }
-	    explen 1+ fsign - ur > if \ exponent too large
+	    ur explen - 1- fsign + { mantlen }
+	    mantlen 0< if \ exponent too large
 		drop c-addr ur '* fill
 	    else
 		c-addr ur + 0 explen negate /string move
 	    endif
-	    #>>
+	    #>> mantlen
 	endif
     else \ inf or nan
 	if \ negative
-	    c-addr ur 1 '- move-right
+	    c-addr ur 1 '- push-right
 	endif
-	drop
+	drop ur
 	\ !! align in some way?
-    endif ;
+    endif
+    1 max ur min ;
 
-: f>str-rdp ( rf ur +nd up -- c-addr ur ) \ gforth
-\G Convert @i{rf} into a string at @i{c-addr ur}.  The conversion
-\G rules and the meanings of @i{ur +nd up} are the same as for
+: f>buf-rdp ( rf c-addr +nr +nd +np -- ) \ gforth
+\G Convert @i{rf} into a string at @i{c-addr nr}.  The conversion
+\G rules and the meanings of @i{nr nd np} are the same as for
+\G @code{f.rdp}.
+    \ first, get the mantissa length, then convert for real.  The
+    \ mantissa length is wrong in a few cases because of different
+    \ rounding; In most cases this does not matter, because the
+    \ mantissa is shorter than expected and the final digits are 0;
+    \ but in a few cases the mantissa gets longer.  Then it is
+    \ conceivable that you will see a result that is rounded too much.
+    \ However, I have not been able to construct an example where this
+    \ leads to an unexpected result.
+    swap 0 max swap 0 max
+    fdup 2over 2over 2 pick f>buf-rdp-try f>buf-rdp-try drop ;
+
+: f>str-rdp ( rf +nr +nd +np -- c-addr nr ) \ gforth
+\G Convert @i{rf} into a string at @i{c-addr nr}.  The conversion
+\G rules and the meanings of @i{nr +nd np} are the same as for
 \G @code{f.rdp}.  The result in in the pictured numeric output buffer
 \G and will be destroyed by anything destroying that buffer.
-    rot holdptr @ 1- 0 rot negate /string ( rf +nd up c-addr ur )
+    rot holdptr @ 1- 0 rot negate /string ( rf +nd np c-addr nr )
     over holdbuf u< -&17 and throw
     2tuck 2>r f>buf-rdp 2r> ;
 
-: f.rdp ( rf ur +nd up -- ) \ gforth
+: f.rdp ( rf +nr +nd +np -- ) \ gforth
 \G Print float @i{rf} formatted.  The total width of the output is
-\G @i{nr}, the number of digits after the decimal point is @i{+nd},
-\G the minimum number of significant digits for fixed-point notation
-\G is @i{up}.  @code{Set-precision} has no effect on @code{f.rdp}.
-\G Fixed-point notation is used if the number of siginicant digits
-\G would be larger than @i{up} and if the number of digits before the
-\G decimal point would fit.  If fixed-point notation is not used,
-\G exponential notation is used, and if that does not fit, asterisks
-\G are printed.  We recommend using @i{ur}>=7 to avoid the risk of
-\G numbers not fitting at all.  We recommend @i{ur}>=@i{up}+5 to avoid
-\G cases where @code{f.rdp} switches to exponential notation because
-\G fixed-point notation would have too few significant digits, yet
-\G exponential notation offers fewer significant digits.  We recomment
-\G @i{ur}>=@i{nd}+2, if you want to have fixed-point notation for some
-\G numbers.  Currently, trailing digits are cut off.
+\G @i{nr}.  For fixed-point notation, the number of digits after the
+\G decimal point is @i{+nd} and the minimum number of significant
+\G digits is @i{np}.  @code{Set-precision} has no effect on
+\G @code{f.rdp}.  Fixed-point notation is used if the number of
+\G siginicant digits would be at least @i{np} and if the number of
+\G digits before the decimal point would fit.  If fixed-point notation
+\G is not used, exponential notation is used, and if that does not
+\G fit, asterisks are printed.  We recommend using @i{nr}>=7 to avoid
+\G the risk of numbers not fitting at all.  We recommend
+\G @i{nr}>=@i{np}+5 to avoid cases where @code{f.rdp} switches to
+\G exponential notation because fixed-point notation would have too
+\G few significant digits, yet exponential notation offers fewer
+\G significant digits.  We recommend @i{nr}>=@i{nd}+2, if you want to
+\G have fixed-point notation for some numbers.  We recommend
+\G @i{np}>@i{nr}, if you want to have exponential notation for all
+\G numbers.
     f>str-rdp type ;
 
 0 [if]
@@ -256,3 +293,37 @@ AUser CSP
 	10e f*
     loop ;
 [then]
+
+: f.s ( -- ) \ gforth f-dot-s
+    \G Display the number of items on the floating-point stack,
+    \G followed by a list of the items; TOS is the right-most item.
+    ." <" fdepth 0 .r ." > " fdepth 0 max maxdepth-.s @ min dup 0 
+    ?DO  dup i - 1- floats fp@ + f@ 16 5 11 f.rdp space LOOP  drop ; 
+
+\ defer stuff
+
+[ifundef] defer@ : defer@ >body @ ; [then]
+
+:noname    ' defer@ ;
+:noname    postpone ['] postpone defer@ ;
+interpret/compile: action-of ( interpretation "name" -- xt; compilation "name" -- ; run-time -- xt ) \ gforth
+\G @i{Xt} is the XT that is currently assigned to @i{name}.
+
+' action-of
+comp' action-of drop
+interpret/compile: what's ( interpretation "name" -- xt; compilation "name" -- ; run-time -- xt ) \ gforth-obsolete
+\G Old name of @code{action-of}
+
+
+: typewhite ( addr n -- ) \ gforth
+\G Like type, but white space is printed instead of the characters.
+    \ bounds u+do
+    0 max bounds ?do
+	i c@ #tab = if \ check for tab
+	    #tab
+	else
+	    bl
+	then
+	emit
+    loop ;
+