factor/library/platform/jvm/stream.factor

! :folding=indent:collapseFolds=1:

! $Id$
!
! Copyright (C) 2003, 2004 Slava Pestov.
! 
! Redistribution and use in source and binary forms, with or without
! modification, are permitted provided that the following conditions are met:
! 
! 1. Redistributions of source code must retain the above copyright notice,
!    this list of conditions and the following disclaimer.
! 
! 2. Redistributions in binary form must reproduce the above copyright notice,
!    this list of conditions and the following disclaimer in the documentation
!    and/or other materials provided with the distribution.
! 
! THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
! INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
! FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
! DEVELOPERS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
! SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
! PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
! OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
! WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
! OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
! ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

IN: streams
USE: combinators
USE: errors
USE: kernel
USE: lists
USE: logic
USE: namespaces
USE: regexp
USE: stack
USE: strings

: fcopy ( from to -- )
    ! Copy the contents of the byte-stream 'from' to the byte-stream 'to'.
    [ [ "in" get ] bind ] dip
    [ "out" get ] bind
    [ "java.io.InputStream" "java.io.OutputStream" ]
    "factor.FactorLib" "copy" jinvoke-static ;

! These are in separate words so that they can be compiled.
! Do not call them directly.

: <byte-stream>/freadln ( -- string )
    "in" get
    [ "java.io.InputStream" ] "factor.FactorLib" "readLine"
    jinvoke-static ;

: <eof-exception> ( -- ex )
    [ ] "java.io.EOFException" jnew ;

: >char/eof ( ch -- ch )
    dup -1 = [ <eof-exception> throw ] [ >char ] ifte ;

: <byte-stream>/fread1 ( -- string )
    "in" get [ ] "java.io.InputStream" "read" jinvoke
    >char/eof ;

: <byte-stream>/fread# ( count -- string )
    "in" get
    [ "int" "java.io.InputStream" ]
    "factor.FactorLib" "readCount"
    jinvoke-static ;

: <byte-stream>/fwrite ( string -- )
    dup char? [
        "out" get
        [ "int" ] "java.io.OutputStream" "write" jinvoke
    ] [
        >bytes
        "out" get
        [ [ "byte" ] ] "java.io.OutputStream" "write" jinvoke
    ] ifte ;

: <byte-stream>/fflush ( -- )
    "out" get [ ] "java.io.OutputStream" "flush" jinvoke ;

: <byte-stream>/fclose ( -- )
    "in" get  [ [ ] "java.io.InputStream"  "close" jinvoke ] when* 
    "out" get [ [ ] "java.io.OutputStream" "close" jinvoke ] when* ;

: <bin> ( in -- in )
    [ "java.io.InputStream" ] "java.io.BufferedInputStream" jnew ;

: <bout> ( out -- out )
    [ "java.io.OutputStream" ] "java.io.BufferedOutputStream" jnew ;

: <byte-stream> ( in out -- stream )
    #! Creates a new stream for reading from the
    #! java.io.InputStream in, and writing to the
    #! java.io.OutputStream out. The streams are wrapped in
    #! buffered streams.
    <stream> [
        <bout> "out" set
        <bin> "in" set
        ( -- string )
        [ <byte-stream>/freadln ] "freadln" set
        ( count -- string )
        [ <byte-stream>/fread1  ] "fread1" set
        ( count -- string )
        [ <byte-stream>/fread#  ] "fread#" set
        ( string -- )
        [ <byte-stream>/fwrite  ] "fwrite" set
        ( -- )
        [ <byte-stream>/fflush  ] "fflush" set
        ( -- )
        [ <byte-stream>/fclose  ] "fclose" set
    ] extend ;

: <char-stream>/freadln ( -- string )
    "in" get [ ] "java.io.BufferedReader" "readLine"
    jinvoke ;

: <char-stream>/fread1 ( -- string )
    "in" get [ ] "java.io.Reader" "read" jinvoke
    >char/eof ;

: <char-stream>/fread# ( -- string )
    "in" get
    [ "int" "java.io.Reader" ]
    "factor.FactorLib" "readCount"
    jinvoke-static ;

: <char-stream>/fwrite ( string -- )
    "out" get [ "java.lang.String" ] "java.io.Writer" "write"
    jinvoke ;

: <char-stream>/fflush ( -- )
    "out" get [ ] "java.io.Writer" "flush" jinvoke ;

: <char-stream>/fclose ( -- )
    "in" get  [ [ ] "java.io.Reader" "close" jinvoke ] when* 
    "out" get [ [ ] "java.io.Writer" "close" jinvoke ] when* ;

: <char-stream> ( in out -- stream )
    #! Creates a new stream for reading from the
    #! java.io.BufferedReader in, and writing to the
    #! java.io.Reader out.
    <stream> [
        "out" set
        "in" set
        ( -- string )
        [ <char-stream>/freadln ] "freadln" set
        ( -- string )
        [ <char-stream>/fread1  ] "fread1" set
        ( count -- string )
        [ <char-stream>/fread#  ] "fread#" set
        ( string -- )
        [ <char-stream>/fwrite  ] "fwrite" set
        ( -- )
        [ <char-stream>/fflush  ] "fflush" set
        ( -- )
        [ <char-stream>/fclose  ] "fclose" set
    ] extend ;

: <bwriter> ( writer -- bwriter )
    [ "java.io.Writer" ] "java.io.BufferedWriter" jnew ;

: <owriter> ( outputstream -- owriter )
    [ "java.io.OutputStream" ] "java.io.OutputStreamWriter" jnew ;

: <filecr> ( path -- stream )
    [ "java.lang.String" ] "java.io.FileReader" jnew <breader>
    f
    <char-stream> ;

: <filecw> ( path -- stream )
    [ "java.lang.String" ] "java.io.FileWriter" jnew <bwriter>
    f swap
    <char-stream> ;

: <filebr> ( path -- stream )
    [ "java.lang.String" ] "java.io.FileInputStream" jnew
    f
    <byte-stream> ;

: <filebw> ( path -- stream )
    [ "java.lang.String" ] "java.io.FileOutputStream" jnew
    f swap
    <byte-stream> ;

: <file> ( path -- file )
    dup "java.io.File" is not [
        [ "java.lang.String" ] "java.io.File" jnew
    ] when ;

: fdelete ( file -- ? )
    #! Delete a file.
    <file> [ ] "java.io.File" "delete" jinvoke ;

: <freader> ( file -- freader )
    [ "java.lang.String" ] "java.io.FileReader" jnew <breader> ;

: exists? ( file -- boolean )
    <file> [ ] "java.io.File" "exists" jinvoke ;

: directory? ( file -- boolean )
    <file> [ ] "java.io.File" "isDirectory" jinvoke ;

: directory ( file -- listing )
    <file> [ ] "java.io.File" "list" jinvoke array>list str-sort ;

: frename ( from to -- ? )
    ! Rename file 'from' to 'to'. These can be paths or
    ! java.io.File instances.
    <file> swap <file>
    [ "java.io.File" ] "java.io.File" "renameTo"
    jinvoke ;

: file-extension ( filename -- extension )
    ".*\\.(.*)" group1 ;

: <sreader> ( string -- reader )
    [ "java.lang.String" ] "java.io.StringReader" jnew ;

: close ( stream -- )
    dup "java.io.Reader" is [
        [ ] "java.io.Reader" "close" jinvoke
    ] [
        [ ] "java.io.Writer" "close" jinvoke
    ] ifte ;

: <server> ( port -- stream )
    #! Starts listening on localhost:port. Returns a stream that
    #! you can close with fclose, and accept connections from
    #! with accept. No other stream operations are supported.
    [ "int" ] "java.net.ServerSocket" jnew
    <stream> [
        "socket" set

        ( -- )
        [
            "socket" get [ ] "java.net.ServerSocket" "close" jinvoke
        ] "fclose" set
    ] extend ;

: socket-closed? ( socket -- ? )
    [ ] "java.net.Socket" "isClosed" jinvoke ;

: close-socket ( socket -- )
    [ ] "java.net.Socket" "close" jinvoke ;

: ?close-socket ( socket -- )
    dup socket-closed? [ drop ] [ close-socket ] ifte ;

: <socket-stream> ( socket -- stream )
    #! Wraps a socket inside a byte-stream.
    dup
    [ [ ] "java.net.Socket" "getInputStream"  jinvoke ]
    [ [ ] "java.net.Socket" "getOutputStream" jinvoke ]
    cleave
    <byte-stream> [
        dup >str "client" set "socket" set

        ! We "extend" byte-stream's fclose.
        ( -- )
        "fclose" get [
            "socket" get ?close-socket
        ] append "fclose" set
    ] extend ;

: <client> ( server port -- stream )
    #! Open a TCP/IP socket to a port on the given server.
    [ "java.lang.String" "int" ] "java.net.Socket" jnew
    <socket-stream> ;

: accept ( server -- client )
    #! Accept a connection from a server socket.
    [ "socket" get ] bind
    [ ] "java.net.ServerSocket" "accept" jinvoke <socket-stream> ;