[gforth] / gforth / stuff.fs  

gforth: gforth/stuff.fs

Diff for /gforth/stuff.fs between version 1.26 and 1.44

version 1.26, Fri Jan 24 22:03:20 2003 UTC version 1.44, Mon Sep 12 08:50:19 2005 UTC
Line 1 
Line 1 
 \ miscelleneous words  \ 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.  \ This file is part of Gforth.
   
Line 51 
Line 51 
 \G @code{system} command.  \G @code{system} command.
   
 : system ( c-addr u -- ) \ gforth  : system ( c-addr u -- ) \ gforth
 \G Pass the string specified by @var{c-addr u} to the host operating system  \G Pass the string specified by @var{c-addr u} to the host operating
 \G for execution in a sub-shell.  \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 $? ;      (system) throw TO $? ;
   
 : sh ( "..." -- ) \ gforth  : sh ( "..." -- ) \ gforth
Line 98 
Line 102 
     ur compile-fliterals uw compile-literals      ur compile-fliterals uw compile-literals
     target compile, POSTPONE exit reveal ;      target compile, POSTPONE exit reveal ;
   
 : const-does> ( run-time: w*uw r*ur uw ur "name" -- )  : const-does> ( run-time: w*uw r*ur uw ur "name" -- ) \ gforth
     \G Defines @var{name} and returns.@sp 0      \G Defines @var{name} and returns.
       \G
     \G @var{name} execution: pushes @var{w*uw r*ur}, then performs the      \G @var{name} execution: pushes @var{w*uw r*ur}, then performs the
     \G code following the @code{const-does>}.      \G code following the @code{const-does>}.
     here >r 0 POSTPONE literal      here >r 0 POSTPONE literal
     POSTPONE (const-does>)      POSTPONE (const-does>)
     POSTPONE ;      POSTPONE ;
     noname : POSTPONE rdrop      noname : POSTPONE rdrop
     lastxt r> cell+ ! \ patch the literal      latestxt r> cell+ ! \ patch the literal
 ; immediate  ; immediate
   
 \ !! rewrite slurp-file using slurp-fid  \ !! 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      \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/o bin open-file throw >r
     r@ file-size throw abort" file too large"      r@ file-size throw abort" file too large"
Line 118 
Line 123 
     2dup r@ read-file throw over <> abort" could not read whole file"      2dup r@ read-file throw over <> abort" could not read whole file"
     r> close-file throw ;      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}      \G @var{addr u} is the content of the file @var{fid}
     0 0 begin ( awhole uwhole )      0 0 begin ( awhole uwhole )
         dup 1024 + dup >r extend-mem ( anew awhole uwhole R: unew )          dup 1024 + dup >r extend-mem ( anew awhole uwhole R: unew )
Line 134 
Line 139 
 : compile-literal ( n -- )  : compile-literal ( n -- )
     postpone literal ;      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  \G switch from postpone state to compile state
     \ this is only a marker; it is never really interpreted      \ this is only a marker; it is never really interpreted
     compile-only-error ; immediate      compile-only-error ; immediate
   
 : postponer ( c-addr u -- )  [ifdef] compiler1
   : postponer1 ( c-addr u -- ... xt )
     2dup find-name dup if ( c-addr u nt )      2dup find-name dup if ( c-addr u nt )
         nip nip name>comp          nip nip name>comp
         2dup [comp'] [[ d= if          2dup [comp'] [[ d= if
             2drop ['] compiler is parser              2drop ['] compiler1 is parser1
         else          else
             postpone,              ['] postpone,
         endif          endif
     else      else
         drop          drop
         2dup snumber? dup if          2dup 2>r snumber? dup if
             0> IF              0> IF
                 swap postpone literal postpone compile-literal                  ['] compile-compile-2literal
               ELSE
                   ['] compile-compile-literal
             THEN              THEN
             postpone Literal postpone compile-literal              2rdrop
             2drop  
         ELSE          ELSE
             drop no.extensions              drop 2r> no.extensions
         THEN          THEN
     then ;      then ;
   
 : ]] ( -- )  : ]] ( -- )
     \ switch into postpone state      \ switch into postpone state
     ['] postponer is parser state on ; immediate restrict      ['] postponer1 is parser1 state on ; immediate restrict
   
   [then]
   
 \ f.rdp  \ 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      \ move string at c-addr u1 right by u2 chars (without exceeding
     \ the original bound); fill the gap with cfill      \ 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>      dup 2swap /string cmove>
     r> r> r> fill ;      r> r> r> fill ;
   
 : f>buf-rdp { f: rf c-addr ur nd up -- } \ gforth  : f>buf-rdp-try { f: rf c-addr ur nd up um1 -- um2 }
 \G Convert @i{rf} into a string at @i{c-addr ur}.  The conversion      \ um1 is the mantissa length to try, um2 is the actual mantissa length
 \G rules and the meanings of @i{ur nd up} are the same as for      c-addr ur um1 /string '0 fill
 \G @code{f.rdp}.      rf c-addr um1 represent if { nexp fsign }
     rf c-addr ur represent if { nexp fsign }  
         nd nexp + up >=          nd nexp + up >=
         ur nd - 1- dup { beforep } fsign + nexp 0 max >= and if          ur nd - 1- dup { beforep } fsign + nexp 0 max >= and if
             \ fixed-point notation              \ fixed-point notation
             c-addr ur beforep nexp - dup { befored } '0 move-right              c-addr ur beforep nexp - dup { befored } '0 push-right
               befored 1+ ur >= if \ <=1 digit left, will be pushed out by '.'
                   rf fabs f2* 0.1e nd s>d d>f f** f> if \ round last digit
                       '1 c-addr befored + 1- c!
                   endif
               endif
             c-addr beforep 1- befored min dup { beforez } 0 max bl fill              c-addr beforep 1- befored min dup { beforez } 0 max bl fill
             fsign if              fsign if
                 '- c-addr beforez 1- 0 max + c!                  '- c-addr beforez 1- 0 max + c!
             endif              endif
             c-addr ur beforep /string 1 '. move-right              c-addr ur beforep /string 1 '. push-right
               nexp nd +
         else \ exponential notation          else \ exponential notation
             c-addr ur 1 /string 1 '. move-right              c-addr ur 1 /string 1 '. push-right
             fsign if              fsign if
                 c-addr ur 1 '- move-right                  c-addr ur 1 '- push-right
             endif              endif
             nexp 1- s>d tuck dabs <<# #s rot sign 'E hold #> { explen }              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                  drop c-addr ur '* fill
             else              else
                 c-addr ur + 0 explen negate /string move                  c-addr ur + 0 explen negate /string move
             endif              endif
             #>>              #>> mantlen
         endif          endif
     else \ inf or nan      else \ inf or nan
         if \ negative          if \ negative
             c-addr ur 1 '- move-right              c-addr ur 1 '- push-right
         endif          endif
         drop          drop ur
         \ !! align in some way?          \ !! align in some way?
     endif ;      endif
       1 max ur min ;
   
 : f>str-rdp ( rf ur +nd up -- c-addr ur ) \ gforth  : f>buf-rdp ( rf c-addr +nr +nd +np -- ) \ gforth
 \G Convert @i{rf} into a string at @i{c-addr ur}.  The conversion  \G Convert @i{rf} into a string at @i{c-addr nr}.  The conversion
 \G rules and the meanings of @i{ur +nd up} are the same as for  \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 @code{f.rdp}.  The result in in the pictured numeric output buffer
 \G and will be destroyed by anything destroying that 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      over holdbuf u< -&17 and throw
     2tuck 2>r f>buf-rdp 2r> ;      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 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 @i{nr}.  For fixed-point notation, the number of digits after the
 \G the minimum number of significant digits for fixed-point notation  \G decimal point is @i{+nd} and the minimum number of significant
 \G is @i{up}.  @code{Set-precision} has no effect on @code{f.rdp}.  \G digits is @i{np}.  @code{Set-precision} has no effect on
 \G Fixed-point notation is used if the number of siginicant digits  \G @code{f.rdp}.  Fixed-point notation is used if the number of
 \G would be larger than @i{up} and if the number of digits before the  \G siginicant digits would be at least @i{np} and if the number of
 \G decimal point would fit.  If fixed-point notation is not used,  \G digits before the decimal point would fit.  If fixed-point notation
 \G exponential notation is used, and if that does not fit, asterisks  \G is not used, exponential notation is used, and if that does not
 \G are printed.  We recommend using @i{ur}>=7 to avoid the risk of  \G fit, asterisks are printed.  We recommend using @i{nr}>=7 to avoid
 \G numbers not fitting at all.  We recommend @i{ur}>=@i{up}+5 to avoid  \G the risk of numbers not fitting at all.  We recommend
 \G cases where @code{f.rdp} switches to exponential notation because  \G @i{nr}>=@i{np}+5 to avoid cases where @code{f.rdp} switches to
 \G fixed-point notation would have too few significant digits, yet  \G exponential notation because fixed-point notation would have too
 \G exponential notation offers fewer significant digits.  We recomment  \G few significant digits, yet exponential notation offers fewer
 \G @i{ur}>=@i{nd}+2, if you want to have fixed-point notation for some  \G significant digits.  We recommend @i{nr}>=@i{nd}+2, if you want to
 \G numbers.  Currently, trailing digits are cut off.  \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 ;      f>str-rdp type ;
   
 0 [if]  0 [if]
Line 256 
Line 298 
         10e f*          10e f*
     loop ;      loop ;
 [then]  [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 ;
   

Generate output suitable for use with a patch program
Legend:
Removed from v.1.26  
changed lines
  Added in v.1.44
CVS Admin

Powered by ViewCVS 1.0-dev 		(Powered by ViewCVS)

ViewCVS and CVS Help