library/platform/jvm/stream.factor

   1 ! :folding=indent:collapseFolds=1:
   2
   3 ! $Id$
   4 !
   5 ! Copyright (C) 2003, 2004 Slava Pestov.
   6 !
   7 ! Redistribution and use in source and binary forms, with or without
   8 ! modification, are permitted provided that the following conditions are met:
   9 !
  10 ! 1. Redistributions of source code must retain the above copyright notice,
  11 !    this list of conditions and the following disclaimer.
  12 !
  13 ! 2. Redistributions in binary form must reproduce the above copyright notice,
  14 !    this list of conditions and the following disclaimer in the documentation
  15 !    and/or other materials provided with the distribution.
  16 !
  17 ! THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  18 ! INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  19 ! FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  20 ! DEVELOPERS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 ! SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  22 ! PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  23 ! OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  24 ! WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  25 ! OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  26 ! ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 IN: streams
  29 USE: combinators
  30 USE: kernel
  31 USE: lists
  32 USE: logic
  33 USE: namespaces
  34 USE: regexp
  35 USE: stack
  36 USE: strings
  37
  38 : fcopy ( from to -- )
  39     ! Copy the contents of the byte-stream 'from' to the byte-stream 'to'.
  40     [ [ "in" get ] bind ] dip
  41     [ "out" get ] bind
  42     [ "java.io.InputStream" "java.io.OutputStream" ]
  43     "factor.FactorLib" "copy" jinvoke-static ;
  44
  45 ! These are in separate words so that they can be compiled.
  46 ! Do not call them directly.
  47
  48 : <byte-stream>/freadln ( -- string )
  49     "in" get
  50     [ "java.io.InputStream" ] "factor.FactorLib" "readLine"
  51     jinvoke-static ;
  52
  53 : <byte-stream>/fread# ( count -- string )
  54     "in" get
  55     [ "int" "java.io.InputStream" ]
  56     "factor.FactorLib" "readCount"
  57     jinvoke-static ;
  58
  59 : <byte-stream>/fwrite ( string -- )
  60     dup char? [
  61         "out" get
  62         [ "int" ] "java.io.OutputStream" "write" jinvoke
  63     ] [
  64         >bytes
  65         "out" get
  66         [ [ "byte" ] ] "java.io.OutputStream" "write" jinvoke
  67     ] ifte ;
  68
  69 : <byte-stream>/fflush ( -- )
  70     "out" get [ ] "java.io.OutputStream" "flush" jinvoke ;
  71
  72 : <byte-stream>/fclose ( -- )
  73     "in" get  [ [ ] "java.io.InputStream"  "close" jinvoke ] when*
  74     "out" get [ [ ] "java.io.OutputStream" "close" jinvoke ] when* ;
  75
  76 : <bin> ( in -- in )
  77     [ "java.io.InputStream" ] "java.io.BufferedInputStream" jnew ;
  78
  79 : <bout> ( out -- out )
  80     [ "java.io.OutputStream" ] "java.io.BufferedOutputStream" jnew ;
  81
  82 : <byte-stream> ( in out -- stream )
  83     #! Creates a new stream for reading from the
  84     #! java.io.InputStream in, and writing to the
  85     #! java.io.OutputStream out. The streams are wrapped in
  86     #! buffered streams.
  87     <stream> [
  88         <bout> "out" set
  89         <bin> "in" set
  90         ( -- string )
  91         [ <byte-stream>/freadln ] "freadln" set
  92         ( count -- string )
  93         [ <byte-stream>/fread#  ] "fread#" set
  94         ( string -- )
  95         [ <byte-stream>/fwrite  ] "fwrite" set
  96         ( -- )
  97         [ <byte-stream>/fflush  ] "fflush" set
  98         ( -- )
  99         [ <byte-stream>/fclose  ] "fclose" set
 100     ] extend ;
 101
 102 : <char-stream>/freadln ( -- string )
 103     "in" get [ ] "java.io.BufferedReader" "readLine"
 104     jinvoke ;
 105
 106 : <char-stream>/fread# ( -- string )
 107     "in" get
 108     [ "int" "java.io.Reader" ]
 109     "factor.FactorLib" "readCount"
 110     jinvoke-static ;
 111
 112 : <char-stream>/fwrite ( string -- )
 113     "out" get [ "java.lang.String" ] "java.io.Writer" "write"
 114     jinvoke ;
 115
 116 : <char-stream>/fflush ( -- )
 117     "out" get [ ] "java.io.Writer" "flush" jinvoke ;
 118
 119 : <char-stream>/fclose ( -- )
 120     "in" get  [ [ ] "java.io.Reader" "close" jinvoke ] when*
 121     "out" get [ [ ] "java.io.Writer" "close" jinvoke ] when* ;
 122
 123 : <char-stream> ( in out -- stream )
 124     #! Creates a new stream for reading from the
 125     #! java.io.BufferedReader in, and writing to the
 126     #! java.io.Reader out.
 127     <stream> [
 128         "out" set
 129         "in" set
 130         ( -- string )
 131         [ <char-stream>/freadln ] "freadln" set
 132         ( count -- string )
 133         [ <char-stream>/fread#  ] "fread#" set
 134         ( string -- )
 135         [ <char-stream>/fwrite  ] "fwrite" set
 136         ( -- )
 137         [ <char-stream>/fflush  ] "fflush" set
 138         ( -- )
 139         [ <char-stream>/fclose  ] "fclose" set
 140     ] extend ;
 141
 142 : <string-output-stream> ( size -- stream )
 143     #! Creates a new stream for writing to a string buffer.
 144     <stream> [
 145         <sbuf> "buf" set
 146         ( string -- )
 147         [ "buf" get sbuf-append ] "fwrite" set
 148     ] extend ;
 149
 150 : stream>str ( stream -- string )
 151     #! Returns the string written to the given string output
 152     #! stream.
 153     [ "buf" get ] bind >str ;
 154
 155 : <bwriter> ( writer -- bwriter )
 156     [ "java.io.Writer" ] "java.io.BufferedWriter" jnew ;
 157
 158 : <owriter> ( outputstream -- owriter )
 159     [ "java.io.OutputStream" ] "java.io.OutputStreamWriter" jnew ;
 160
 161 : <filecr> ( path -- stream )
 162     [ "java.lang.String" ] "java.io.FileReader" jnew <breader>
 163     f
 164     <char-stream> ;
 165
 166 : <filecw> ( path -- stream )
 167     [ "java.lang.String" ] "java.io.FileWriter" jnew <bwriter>
 168     f swap
 169     <char-stream> ;
 170
 171 : <filebr> ( path -- stream )
 172     [ "java.lang.String" ] "java.io.FileInputStream" jnew
 173     f
 174     <byte-stream> ;
 175
 176 : <filebw> ( path -- stream )
 177     [ "java.lang.String" ] "java.io.FileOutputStream" jnew
 178     f swap
 179     <byte-stream> ;
 180
 181 : <file> ( path -- file )
 182     dup "java.io.File" is not [
 183         [ "java.lang.String" ] "java.io.File" jnew
 184     ] when ;
 185
 186 : fdelete ( file -- ? )
 187     #! Delete a file.
 188     <file> [ ] "java.io.File" "delete" jinvoke ;
 189
 190 : <freader> ( file -- freader )
 191     [ "java.lang.String" ] "java.io.FileReader" jnew <breader> ;
 192
 193 : exists? ( file -- boolean )
 194     <file> [ ] "java.io.File" "exists" jinvoke ;
 195
 196 : directory? ( file -- boolean )
 197     <file> [ ] "java.io.File" "isDirectory" jinvoke ;
 198
 199 : directory ( file -- listing )
 200     <file> [ ] "java.io.File" "list" jinvoke array>list str-sort ;
 201
 202 : frename ( from to -- ? )
 203     ! Rename file 'from' to 'to'. These can be paths or
 204     ! java.io.File instances.
 205     <file> swap <file>
 206     [ "java.io.File" ] "java.io.File" "renameTo"
 207     jinvoke ;
 208
 209 : file-extension ( filename -- extension )
 210     ".*\\.(.*)" group1 ;
 211
 212 : <sreader> ( string -- reader )
 213     [ "java.lang.String" ] "java.io.StringReader" jnew ;
 214
 215 : close ( stream -- )
 216     dup "java.io.Reader" is [
 217         [ ] "java.io.Reader" "close" jinvoke
 218     ] [
 219         [ ] "java.io.Writer" "close" jinvoke
 220     ] ifte ;
 221
 222 : <server> ( port -- stream )
 223     #! Starts listening on localhost:port. Returns a stream that
 224     #! you can close with fclose. No other stream operations are
 225     #! supported.
 226     [ "int" ] "java.net.ServerSocket" jnew
 227     <stream> [
 228         "socket" set
 229
 230         ( -- )
 231         [
 232             "socket" get [ ] "java.net.ServerSocket" "close" jinvoke
 233         ] "fclose" set
 234     ] extend ;
 235
 236 : <socket-stream> ( socket -- stream )
 237     #! Wraps a socket inside a byte-stream.
 238     dup
 239     [ [ ] "java.net.Socket" "getInputStream"  jinvoke ]
 240     [ [ ] "java.net.Socket" "getOutputStream" jinvoke ]
 241     cleave
 242     <byte-stream> [
 243         "socket" set
 244
 245         ! We "extend" byte-stream's fclose.
 246         ( -- )
 247         "fclose" get [
 248             "socket" get [ ] "java.net.Socket" "close" jinvoke
 249         ] append "fclose" set
 250     ] extend ;
 251
 252 : <client> ( server port -- stream )
 253     #! Open a TCP/IP socket to a port on the given server.
 254     [ "java.lang.String" "int" ] "java.net.Socket" jnew
 255     <socket-stream> ;
 256
 257 : accept ( server -- client )
 258     #! Accept a connection from a server socket.
 259     [ "socket" get ] bind
 260     [ ] "java.net.ServerSocket" "accept" jinvoke <socket-stream> ;