steve
/
factor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'master' of factorcode.org:/git/factor

db4
Eduardo Cavazos 2008-05-05 21:56:36 -05:00
parent 3883c30639 598ba7dedb
commit 404bf07ad5
148 changed files with 2930 additions and 718 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/alien/alien-docs.factor
View File

@ -265,7 +265,7 @@ ARTICLE: "embedding-restrictions" "Embedding API restrictions"
ARTICLE: "embedding-factor" "What embedding looks like from Factor"
"Factor code will run inside an embedded instance in the same way it would run in a stand-alone instance."
$nl
"One exception is the global " { $link stdio } " stream, which is by default not bound to the terminal where the process is running, to avoid conflicting with any I/O the host process might perform. To initialize the terminal stream, " { $link init-stdio } " must be called explicitly."
"One exception is that the global " { $link input-stream } " and " { $link output-stream } " streams are not bound by default, to avoid conflicting with any I/O the host process might perform. The " { $link init-stdio } " words must be called explicitly to initialize terminal streams."
$nl
"There is a word which can detect when Factor is embedded:"
{ $subsection embedded? }

2
core/bootstrap/image/image.factor
View File

@ -475,7 +475,7 @@ M: quotation '
"Writing image to " write
architecture get boot-image-name resource-path
[ write "..." print flush ]
[ binary <file-writer> [ (write-image) ] with-stream ] bi ;
[ binary [ (write-image) ] with-file-writer ] bi ;
PRIVATE>

2
core/bootstrap/stage2.factor
View File

@ -87,7 +87,7 @@ f error-continuation set-global
parse-command-line
run-user-init
"run" get run
stdio get [ stream-flush ] when*
output-stream get [ stream-flush ] when*
] [ print-error 1 exit ] recover
] set-boot-quot

10
core/compiler/errors/errors-docs.factor
View File

@ -21,19 +21,19 @@ HELP: compiler-error
HELP: compiler-error.
{ $values { "error" "an error" } { "word" word } }
{ $description "Prints a compiler error to the " { $link stdio } " stream." } ;
{ $description "Prints a compiler error to " { $link output-stream } "." } ;
HELP: compiler-errors.
{ $values { "type" symbol } }
{ $description "Prints compiler errors to the " { $link stdio } " stream. The type parameter is one of " { $link +error+ } ", " { $link +warning+ } ", or " { $link +linkage+ } "." } ;
{ $description "Prints compiler errors to " { $link output-stream } ". The type parameter is one of " { $link +error+ } ", " { $link +warning+ } ", or " { $link +linkage+ } "." } ;
HELP: :errors
{ $description "Prints all serious compiler errors from the most recent compile to the " { $link stdio } " stream." } ;
{ $description "Prints all serious compiler errors from the most recent compile to " { $link output-stream } "." } ;
HELP: :warnings
{ $description "Prints all ignorable compiler warnings from the most recent compile to the " { $link stdio } " stream." } ;
{ $description "Prints all ignorable compiler warnings from the most recent compile to " { $link output-stream } "." } ;
HELP: :linkage
{ $description "Prints all C library interface linkage errors from the most recent compile to the " { $link stdio } " stream." } ;
{ $description "Prints all C library interface linkage errors from the most recent compile to " { $link output-stream } "." } ;
{ :errors :warnings } related-words

2
core/continuations/continuations-docs.factor
View File

@ -34,7 +34,7 @@ $nl
{ $code
"<external-resource> ... do stuff ... dispose"
}
"The reason being that if " { $snippet "do stuff" } " throws an error, the resource will not be disposed of. The most important case where this can occur is with I/O streams, and the correct solution is to always use " { $link with-stream } "; see " { $link "stdio" } " for details." ;
"The reason being that if " { $snippet "do stuff" } " throws an error, the resource will not be disposed of. The most important case where this can occur is with I/O streams, and the correct solution is to always use " { $link with-input-stream } " and " { $link with-output-stream } "; see " { $link "stdio" } " for details." ;
ARTICLE: "errors" "Error handling"
"Support for handling exceptional situations such as bad user input, implementation bugs, and input/output errors is provided by a set of words built using continuations."

6
core/debugger/debugger-docs.factor
View File

@ -64,7 +64,7 @@ HELP: :3
HELP: error.
{ $values { "error" "an error" } }
{ $contract "Print an error to the " { $link stdio } " stream. You can define methods on this generic word to print human-readable messages for custom errors." }
{ $contract "Print an error to " { $link output-stream } ". You can define methods on this generic word to print human-readable messages for custom errors." }
{ $notes "Code should call " { $link print-error } " instead, which handles the case where the printing of the error itself throws an error." } ;
HELP: error-help
@ -75,11 +75,11 @@ HELP: error-help
HELP: print-error
{ $values { "error" "an error" } }
{ $description "Print an error to the " { $link stdio } " stream." }
{ $description "Print an error to " { $link output-stream } "." }
{ $notes "This word is called by the listener and other tools which report caught errors to the user." } ;
HELP: restarts.
{ $description "Print a list of restarts for the most recently thrown error to the " { $link stdio } " stream." } ;
{ $description "Print a list of restarts for the most recently thrown error to " { $link output-stream } "." } ;
HELP: error-hook
{ $var-description "A quotation with stack effect " { $snippet "( error -- )" } " which is used by " { $link try } " to report the error to the user." }

26
core/debugger/debugger.factor
View File

@ -1,13 +1,13 @@
! Copyright (C) 2004, 2008 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
USING: arrays definitions generic hashtables inspector io kernel
math namespaces prettyprint sequences assocs sequences.private
strings io.styles vectors words system splitting math.parser
classes.tuple continuations continuations.private combinators
generic.math io.streams.duplex classes.builtin classes
compiler.units generic.standard vocabs threads threads.private
init kernel.private libc io.encodings mirrors accessors
math.order ;
math namespaces prettyprint prettyprint.config sequences assocs
sequences.private strings io.styles vectors words system
splitting math.parser classes.tuple continuations
continuations.private combinators generic.math
classes.builtin classes compiler.units generic.standard vocabs
threads threads.private init kernel.private libc io.encodings
mirrors accessors math.order ;
IN: debugger
GENERIC: error. ( error -- )
@ -209,9 +209,6 @@ M: no-next-method summary
M: inconsistent-next-method summary
drop "Executing call-next-method with inconsistent parameters" ;
M: stream-closed-twice summary
drop "Attempt to perform I/O on closed stream" ;
M: check-method summary
drop "Invalid parameters for create-method" ;
@ -241,6 +238,15 @@ M: condition error-help error>> error-help ;
M: assert summary drop "Assertion failed" ;
M: assert error.
"Assertion failed" print
standard-table-style [
15 length-limit set
5 line-limit set
[ expect>> [ [ "Expect:" write ] with-cell pprint-cell ] with-row ]
[ got>> [ [ "Got:" write ] with-cell pprint-cell ] with-row ] bi
] tabular-output ;
M: immutable summary drop "Sequence is immutable" ;
M: redefine-error error.

2
core/generic/standard/engines/tuple/tuple.factor
View File

@ -127,8 +127,6 @@ M: echelon-dispatch-engine engine>quot
1 slot { tuple-layout } declare
5 slot ; inline
: unclip-last [ 1 head* ] [ peek ] bi ;
M: tuple-dispatch-engine engine>quot
[
picker %

2
core/inference/inference-docs.factor
View File

@ -135,7 +135,7 @@ HELP: infer
HELP: infer.
{ $values { "quot" "a quotation" } }
{ $description "Attempts to infer the quotation's stack effect, and prints this data to the " { $link stdio } " stream." }
{ $description "Attempts to infer the quotation's stack effect, and prints this data to " { $link output-stream } "." }
{ $errors "Throws an " { $link inference-error } " if stack effect inference fails." } ;
{ infer infer. } related-words

2
core/inspector/inspector-docs.factor
View File

@ -108,4 +108,4 @@ HELP: me
HELP: inspector-hook
{ $var-description "A quotation with stack effect " { $snippet "( obj -- )" } ", called by the inspector to display an overview of an object."
$nl
"The default implementation calls " { $link describe } " which outputs on the " { $link stdio } " stream, but the graphical listener sets this variable so that calling " { $link inspect } " in the UI opens the graphical inspector." } ;
"The default implementation calls " { $link describe } " which outputs on " { $link output-stream } ", but the graphical listener sets this variable so that calling " { $link inspect } " in the UI opens the graphical inspector." } ;

2
core/io/backend/backend-docs.factor
View File

@ -9,4 +9,4 @@ HELP: init-io
{ $contract "Initializes the I/O system. Called on startup." } ;
HELP: init-stdio
{ $contract "Initializes the global " { $link stdio } " stream. Called on startup." } ;
{ $contract "Initializes the global " { $link input-stream } " and " { $link output-stream } ". Called on startup." } ;

6
core/io/backend/backend.factor
View File

@ -11,8 +11,10 @@ HOOK: init-io io-backend ( -- )
HOOK: (init-stdio) io-backend ( -- stdin stdout stderr )
: init-stdio ( -- )
(init-stdio) utf8 <encoder> stderr set-global
utf8 <encoder-duplex> stdio set-global ;
(init-stdio)
[ utf8 <decoder> input-stream set-global ]
[ utf8 <encoder> output-stream set-global ]
[ utf8 <encoder> error-stream set-global ] tri* ;
HOOK: io-multiplex io-backend ( ms -- )

13
core/io/encodings/encodings-docs.factor
View File

@ -12,8 +12,7 @@ ARTICLE: "io.encodings" "I/O encodings"
ARTICLE: "encodings-constructors" "Manually constructing an encoded stream"
"The following words can be used to construct encoded streams. Note that they are usually not used directly, but rather by the stream constructors themselves. Most stream constructors take an encoding descriptor as a parameter and internally call these constructors."
{ $subsection <encoder> }
{ $subsection <decoder> }
{ $subsection <encoder-duplex> } ;
{ $subsection <decoder> } ;
HELP: <encoder>
{ $values { "stream" "an output stream" }
@ -29,16 +28,6 @@ HELP: <decoder>
{ $description "Wraps the given stream in a new stream using the given encoding for all input. The encoding descriptor can either be a class or an instance of something conforming to the " { $link "encodings-protocol" } "." }
$low-level-note ;
HELP: <encoder-duplex>
{ $values { "stream-in" "an input stream" }
{ "stream-out" "an output stream" }
{ "encoding" "an encoding descriptor" }
{ "duplex" "an encoded duplex stream" } }
{ $description "Wraps the given streams in an encoder or decoder stream, and puts them together in a duplex stream for input and output. If either input stream is already encoded, that encoding is stripped off before it is reencoded. The encoding descriptor must conform to the " { $link "encodings-protocol" } "." }
$low-level-note ;
{ <encoder> <decoder> <encoder-duplex> } related-words
ARTICLE: "encodings-descriptors" "Encoding descriptors"
"An encoding descriptor is something which can be used for input or output streams to encode or decode files. It must conform to the " { $link "encodings-protocol" } ". Encodings which you can use are defined in the following vocabularies:"
{ $subsection "io.encodings.binary" }

2
core/io/encodings/encodings-tests.factor
View File

@ -10,7 +10,7 @@ IN: io.streams.encodings.tests
unit-test
: lines-test ( stream -- line1 line2 )
[ readln readln ] with-stream ;
[ readln readln ] with-input-stream ;
[
"This is a line."

7
core/io/encodings/encodings.factor
View File

@ -2,8 +2,8 @@
! See http://factorcode.org/license.txt for BSD license.
USING: math kernel sequences sbufs vectors namespaces growable
strings io classes continuations combinators io.styles
io.streams.plain splitting io.streams.duplex byte-arrays
sequences.private accessors ;
io.streams.plain splitting byte-arrays sequences.private
accessors ;
IN: io.encodings
! The encoding descriptor protocol
@ -131,6 +131,3 @@ INSTANCE: encoder plain-writer
over decoder? [ >r decoder-stream r> ] when <decoder> ;
PRIVATE>
: <encoder-duplex> ( stream-in stream-out encoding -- duplex )
tuck reencode >r redecode r> <duplex-stream> ;

6
core/io/files/files-docs.factor
View File

@ -205,17 +205,17 @@ HELP: <file-appender>
HELP: with-file-reader
{ $values { "path" "a pathname string" } { "encoding" "an encoding descriptor" } { "quot" "a quotation" } }
{ $description "Opens a file for reading and calls the quotation using " { $link with-stream } "." }
{ $description "Opens a file for reading and calls the quotation using " { $link with-input-stream } "." }
{ $errors "Throws an error if the file is unreadable." } ;
HELP: with-file-writer
{ $values { "path" "a pathname string" } { "encoding" "an encoding descriptor" } { "quot" "a quotation" } }
{ $description "Opens a file for writing using the given encoding and calls the quotation using " { $link with-stream } "." }
{ $description "Opens a file for writing using the given encoding and calls the quotation using " { $link with-output-stream } "." }
{ $errors "Throws an error if the file cannot be opened for writing." } ;
HELP: with-file-appender
{ $values { "path" "a pathname string" } { "encoding" "an encoding descriptor" } { "quot" "a quotation" } }
{ $description "Opens a file for appending using the given encoding and calls the quotation using " { $link with-stream } "." }
{ $description "Opens a file for appending using the given encoding and calls the quotation using " { $link with-output-stream } "." }
{ $errors "Throws an error if the file cannot be opened for writing." } ;
HELP: set-file-lines

6
core/io/files/files.factor
View File

@ -25,13 +25,13 @@ HOOK: (file-appender) io-backend ( path -- stream )
<file-reader> lines ;
: with-file-reader ( path encoding quot -- )
>r <file-reader> r> with-stream ; inline
>r <file-reader> r> with-input-stream ; inline
: file-contents ( path encoding -- str )
<file-reader> contents ;
: with-file-writer ( path encoding quot -- )
>r <file-writer> r> with-stream ; inline
>r <file-writer> r> with-output-stream ; inline
: set-file-lines ( seq path encoding -- )
[ [ print ] each ] with-file-writer ;
@ -40,7 +40,7 @@ HOOK: (file-appender) io-backend ( path -- stream )
[ write ] with-file-writer ;
: with-file-appender ( path encoding quot -- )
>r <file-appender> r> with-stream ; inline
>r <file-appender> r> with-output-stream ; inline
! Pathnames
: path-separator? ( ch -- ? ) os windows? "/\\" "/" ? member? ;

127
core/io/io-docs.factor
View File

@ -5,7 +5,7 @@ IN: io
ARTICLE: "stream-protocol" "Stream protocol"
"The stream protocol consists of a large number of generic words, many of which are optional."
$nl
"Stream protocol words are rarely called directly, since code which only works with one stream at a time should be written use " { $link "stdio" } " instead, wrapping I/O operations such as " { $link read } " and " { $link write } " in a " { $link with-stream } ". This leads more simpler, more reusable and more robust code."
"Stream protocol words are rarely called directly, since code which only works with one stream at a time should be written use " { $link "stdio" } " instead, wrapping I/O operations such as " { $link read } " and " { $link write } " in " { $link with-input-stream } " and " { $link with-output-stream } "."
$nl
"All streams must implement the " { $link dispose } " word in addition to the stream protocol."
$nl
@ -26,24 +26,24 @@ $nl
{ $subsection stream-write-table }
{ $see-also "io.timeouts" } ;
ARTICLE: "stdio" "The default stream"
"Most I/O code only operates on one stream at a time. The " { $emphasis "default stream" } " is an implicit parameter used by many I/O words designed for this particular use-case. Using this idiom improves code in three ways:"
ARTICLE: "stdio" "Default input and output streams"
"Most I/O code only operates on one stream at a time. The " { $link input-stream } " and " { $link output-stream } " variables are implicit parameters used by many I/O words. Using this idiom improves code in three ways:"
{ $list
{ "Code becomes simpler because there is no need to keep a stream around on the stack." }
{ "Code becomes more robust because " { $link with-stream } " automatically closes the stream if there is an error." }
{ "Code becomes more reusable because it can be written to not worry about which stream is being used, and instead the caller can use " { $link with-stream } " to specify the source or destination for I/O operations." }
{ "Code becomes more robust because " { $link with-input-stream } " and " { $link with-output-stream } " automatically close the streams if there is an error." }
{ "Code becomes more reusable because it can be written to not worry about which stream is being used, and instead the caller can use " { $link with-input-stream } " or " { $link with-output-stream } " to specify the source or destination for I/O operations." }
}
"For example, here is a program which reads the first line of a file, converts it to an integer, then reads that many characters, and splits them into groups of 16:"
{ $code
"USING: continuations kernel io io.files math.parser splitting ;"
"\"data.txt\" <file-reader>"
"\"data.txt\" utf8 <file-reader>"
"dup stream-readln number>string over stream-read 16 group"
"swap dispose"
}
"This code has two problems: it has some unnecessary stack shuffling, and if either " { $link stream-readln } " or " { $link stream-read } " throws an I/O error, the stream is not closed because " { $link dispose } " is never reached. So we can add a call to " { $link with-disposal } " to ensure the stream is always closed:"
{ $code
"USING: continuations kernel io io.files math.parser splitting ;"
"\"data.txt\" <file-reader> ["
"\"data.txt\" utf8 <file-reader> ["
" dup stream-readln number>string over stream-read"
" 16 group"
"] with-disposal"
@ -51,17 +51,34 @@ ARTICLE: "stdio" "The default stream"
"This code is robust however it is more complex than it needs to be since. This is where the default stream words come in; using them, the above can be rewritten as follows:"
{ $code
"USING: continuations kernel io io.files math.parser splitting ;"
"\"data.txt\" <file-reader> ["
"\"data.txt\" utf8 <file-reader> ["
" readln number>string read 16 group"
"] with-stream"
"] with-input-stream"
}
"The default stream is stored in a dynamically-scoped variable:"
{ $subsection stdio }
"Unless rebound in a child namespace, this variable will be set to a console stream for interacting with the user."
"An even better implementation that takes advantage of a utility word:"
{ $code
"USING: continuations kernel io io.files math.parser splitting ;"
"\"data.txt\" utf8 ["
" readln number>string read 16 group"
"] with-file-reader"
}
"The default input stream is stored in a dynamically-scoped variable:"
{ $subsection input-stream }
"Unless rebound in a child namespace, this variable will be set to a console stream for reading input from the user."
$nl
"Words reading from the default input stream:"
{ $subsection read1 }
{ $subsection read }
{ $subsection read-until }
{ $subsection readln }
"A pair of combinators for rebinding the " { $link input-stream } " variable:"
{ $subsection with-input-stream }
{ $subsection with-input-stream* }
"The default output stream is stored in a dynamically-scoped variable:"
{ $subsection output-stream }
"Unless rebound in a child namespace, this variable will be set to a console stream for showing output to the user."
$nl
"Words writing to the default input stream:"
{ $subsection flush }
{ $subsection write1 }
{ $subsection write }
@ -78,9 +95,12 @@ ARTICLE: "stdio" "The default stream"
{ $subsection with-row }
{ $subsection with-cell }
{ $subsection write-cell }
"A pair of combinators support rebinding the " { $link stdio } " variable:"
{ $subsection with-stream }
{ $subsection with-stream* } ;
"A pair of combinators for rebinding the " { $link output-stream } " variable:"
{ $subsection with-output-stream }
{ $subsection with-output-stream* }
"A pair of combinators for rebinding both default streams at once:"
{ $subsection with-streams }
{ $subsection with-streams* } ;
ARTICLE: "stream-utils" "Stream utilities"
"There are a few useful stream-related words which are not generic, but merely built up from the stream protocol."
@ -204,62 +224,65 @@ HELP: stream-copy
{ $description "Copies the contents of one stream into another, closing both streams when done." }
$io-error ;
HELP: stdio
{ $var-description "Holds a stream, used for various implicit stream operations. Rebound using " { $link with-stream } " and " { $link with-stream* } "." } ;
HELP: input-stream
{ $var-description "Holds an input stream for various implicit stream operations. Rebound using " { $link with-input-stream } " and " { $link with-input-stream* } "." } ;
HELP: output-stream
{ $var-description "Holds an output stream for various implicit stream operations. Rebound using " { $link with-output-stream } " and " { $link with-output-stream* } "." } ;
HELP: readln
{ $values { "str/f" "a string or " { $link f } } }
{ $description "Reads a line of input from the " { $link stdio } " stream. Outputs " { $link f } " on stream exhaustion." }
{ $description "Reads a line of input from " { $link input-stream } ". Outputs " { $link f } " on stream exhaustion." }
$io-error ;
HELP: read1
{ $values { "ch/f" "a character or " { $link f } } }
{ $description "Reads a character of input from the " { $link stdio } " stream. Outputs " { $link f } " on stream exhaustion." }
{ $description "Reads a character of input from " { $link input-stream } ". Outputs " { $link f } " on stream exhaustion." }
$io-error ;
HELP: read
{ $values { "n" "a non-negative integer" } { "str/f" "a string or " { $link f } } }
{ $description "Reads " { $snippet "n" } " characters of input from the " { $link stdio } " stream. Outputs a truncated string or " { $link f } " on stream exhaustion." }
{ $description "Reads " { $snippet "n" } " characters of input from " { $link input-stream } ". Outputs a truncated string or " { $link f } " on stream exhaustion." }
$io-error ;
HELP: read-until
{ $values { "seps" string } { "str/f" "a string or " { $link f } } { "sep/f" "a character or " { $link f } } }
{ $contract "Reads characters from the " { $link stdio } " stream. until the first occurrence of a separator character, or stream exhaustion. In the former case, the separator character is pushed on the stack, and is not part of the output string. In the latter case, the entire stream contents are output, along with " { $link f } "." }
{ $contract "Reads characters from " { $link input-stream } ". until the first occurrence of a separator character, or stream exhaustion. In the former case, the separator character is pushed on the stack, and is not part of the output string. In the latter case, the entire stream contents are output, along with " { $link f } "." }
$io-error ;
HELP: write1
{ $values { "ch" "a character" } }
{ $contract "Writes a character of output to the " { $link stdio } " stream. If the stream does buffering, output may not be performed immediately; use " { $link flush } " to force output." }
{ $contract "Writes a character of output to " { $link output-stream } ". If the stream does buffering, output may not be performed immediately; use " { $link flush } " to force output." }
$io-error ;
HELP: write
{ $values { "str" string } }
{ $description "Writes a string of output to the " { $link stdio } " stream. If the stream does buffering, output may not be performed immediately; use " { $link flush } " to force output." }
{ $description "Writes a string of output to " { $link output-stream } ". If the stream does buffering, output may not be performed immediately; use " { $link flush } " to force output." }
$io-error ;
HELP: flush
{ $description "Waits for any pending output to the " { $link stdio } " stream to complete." }
{ $description "Waits for any pending output on " { $link output-stream } " to complete." }
$io-error ;
HELP: nl
{ $description "Writes a line terminator to the " { $link stdio } " stream. If the stream does buffering, output may not be performed immediately; use " { $link flush } " to force output." }
{ $description "Writes a line terminator to " { $link output-stream } ". If the stream does buffering, output may not be performed immediately; use " { $link flush } " to force output." }
$io-error ;
HELP: format
{ $values { "str" string } { "style" "a hashtable" } }
{ $description "Writes formatted text to the " { $link stdio } " stream. If the stream does buffering, output may not be performed immediately; use " { $link flush } " to force output." }
{ $description "Writes formatted text to " { $link output-stream } ". If the stream does buffering, output may not be performed immediately; use " { $link flush } " to force output." }
{ $notes "Details are in the documentation for " { $link stream-format } "." }
$io-error ;
HELP: with-nesting
{ $values { "style" "a hashtable" } { "quot" "a quotation" } }
{ $description "Calls the quotation in a new dynamic scope with the " { $link stdio } " stream rebound to a nested paragraph stream, with formatting information applied." }
{ $values { "style" "a hashtable" } { "quot" quotation } }
{ $description "Calls the quotation in a new dynamic scope with " { $link output-stream } " rebound to a nested paragraph stream, with formatting information applied." }
{ $notes "Details are in the documentation for " { $link make-block-stream } "." }
$io-error ;
HELP: tabular-output
{ $values { "style" "a hashtable" } { "quot" quotation } }
{ $description "Calls a quotation which emits a series of equal-length table rows using " { $link with-row } ". The results are laid out in a tabular fashion on the " { $link stdio } " stream."
{ $description "Calls a quotation which emits a series of equal-length table rows using " { $link with-row } ". The results are laid out in a tabular fashion on " { $link output-stream } "."
$nl
"The " { $snippet "style" } " hashtable holds table style information. See " { $link "table-styles" } "." }
{ $examples
@ -279,7 +302,7 @@ $io-error ;
HELP: with-cell
{ $values { "quot" quotation } }
{ $description "Calls a quotation in a new scope with the " { $link stdio } " stream rebound. Output performed by the quotation is displayed in a table cell. This word can only be called inside the quotation given to " { $link with-row } "." }
{ $description "Calls a quotation in a new scope with " { $link output-stream } " rebound. Output performed by the quotation is displayed in a table cell. This word can only be called inside the quotation given to " { $link with-row } "." }
$io-error ;
HELP: write-cell
@ -288,34 +311,54 @@ HELP: write-cell
$io-error ;
HELP: with-style
{ $values { "style" "a hashtable" } { "quot" "a quotation" } }
{ $values { "style" "a hashtable" } { "quot" quotation } }
{ $description "Calls the quotation in a new dynamic scope where calls to " { $link write } ", " { $link format } " and other stream output words automatically inherit style settings from " { $snippet "style" } "." }
{ $notes "Details are in the documentation for " { $link make-span-stream } "." }
$io-error ;
HELP: print
{ $values { "string" string } }
{ $description "Writes a newline-terminated string to the " { $link stdio } " stream." }
{ $description "Writes a newline-terminated string to " { $link output-stream } "." }
$io-error ;
HELP: with-stream
{ $values { "stream" "an input or output stream" } { "quot" "a quotation" } }
{ $description "Calls the quotation in a new dynamic scope, with the " { $link stdio } " variable rebound to " { $snippet "stream" } ". The stream is closed if the quotation returns or throws an error." } ;
HELP: with-input-stream
{ $values { "stream" "an input stream" } { "quot" quotation } }
{ $description "Calls the quotation in a new dynamic scope, with " { $link input-stream } " rebound to " { $snippet "stream" } ". The stream is closed if the quotation returns or throws an error." } ;
{ with-stream with-stream* } related-words
HELP: with-output-stream
{ $values { "stream" "an output stream" } { "quot" quotation } }
{ $description "Calls the quotation in a new dynamic scope, with " { $link output-stream } " rebound to " { $snippet "stream" } ". The stream is closed if the quotation returns or throws an error." } ;
HELP: with-stream*
{ $values { "stream" "an input or output stream" } { "quot" "a quotation" } }
{ $description "Calls the quotation in a new dynamic scope, with the " { $link stdio } " variable rebound to " { $snippet "stream" } "." }
{ $notes "This word does not close the stream. Compare with " { $link with-stream } "." } ;
HELP: with-streams
{ $values { "input" "an input stream" } { "output" "an output stream" } { "quot" quotation } }
{ $description "Calls the quotation in a new dynamic scope, with " { $link input-stream } " rebound to " { $snippet "input" } " and " { $link output-stream } " rebound to " { $snippet "output" } ". The stream is closed if the quotation returns or throws an error." } ;
HELP: with-streams*
{ $values { "input" "an input stream" } { "output" "an output stream" } { "quot" quotation } }
{ $description "Calls the quotation in a new dynamic scope, with " { $link input-stream } " rebound to " { $snippet "input" } " and " { $link output-stream } " rebound to " { $snippet "output" } "." }
{ $notes "This word does not close the stream. Compare with " { $link with-streams } "." } ;
{ with-input-stream with-input-stream* } related-words
{ with-output-stream with-output-stream* } related-words
HELP: with-input-stream*
{ $values { "stream" "an input stream" } { "quot" quotation } }
{ $description "Calls the quotation in a new dynamic scope, with " { $link input-stream } " rebound to " { $snippet "stream" } "." }
{ $notes "This word does not close the stream. Compare with " { $link with-input-stream } "." } ;
HELP: with-output-stream*
{ $values { "stream" "an output stream" } { "quot" quotation } }
{ $description "Calls the quotation in a new dynamic scope, with " { $link output-stream } " rebound to " { $snippet "stream" } "." }
{ $notes "This word does not close the stream. Compare with " { $link with-output-stream } "." } ;
HELP: bl
{ $description "Outputs a space character (" { $snippet "\" \"" } ")." }
{ $description "Outputs a space character (" { $snippet "\" \"" } ") to " { $link output-stream } "." }
$io-error ;
HELP: write-object
{ $values { "str" string } { "obj" "an object" } }
{ $description "Writes a string to the " { $link stdio } " stream, associating it with the object. If formatted output is supported, the string will become a clickable presentation of the object, otherwise this word behaves like a call to " { $link write } "." }
{ $description "Writes a string to " { $link output-stream } ", associating it with the object. If formatted output is supported, the string will become a clickable presentation of the object, otherwise this word behaves like a call to " { $link write } "." }
$io-error ;
HELP: lines

15
core/io/io-tests.factor
View File

@ -15,14 +15,14 @@ IN: io.tests
"This is a line.\rThis is another line.\r"
] [
"core/io/test/mac-os-eol.txt" <resource-reader>
[ 500 read ] with-stream
[ 500 read ] with-input-stream
] unit-test
[
255
] [
"core/io/test/binary.txt" <resource-reader>
[ read1 ] with-stream >fixnum
[ read1 ] with-input-stream >fixnum
] unit-test
! Make sure we use correct to_c_string form when writing
@ -40,7 +40,7 @@ IN: io.tests
"J" read-until 2array ,
"i" read-until 2array ,
"X" read-until 2array ,
] with-stream
] with-input-stream
] { } make
] unit-test
@ -49,12 +49,3 @@ IN: io.tests
10 [ 65536 read drop ] times
] with-file-reader
] unit-test
! [ "" ] [ 0 read ] unit-test
! [ ] [ "123" write 9000 CHAR: x <string> write flush ] unit-test
! [
! "/core/io/test/binary.txt" <resource-reader>
! [ 0.2 read ] with-stream
! ] must-fail

64
core/io/io.factor
View File

@ -30,39 +30,52 @@ GENERIC: stream-write-table ( table-cells style stream -- )
[ 2dup (stream-copy) ] [ dispose dispose ] [ ]
cleanup ;
! Default stream
SYMBOL: stdio
! Default streams
SYMBOL: input-stream
SYMBOL: output-stream
SYMBOL: error-stream
! Default error stream
SYMBOL: stderr
: readln ( -- str/f ) input-stream get stream-readln ;
: read1 ( -- ch/f ) input-stream get stream-read1 ;
: read ( n -- str/f ) input-stream get stream-read ;
: read-until ( seps -- str/f sep/f ) input-stream get stream-read-until ;
: readln ( -- str/f ) stdio get stream-readln ;
: read1 ( -- ch/f ) stdio get stream-read1 ;
: read ( n -- str/f ) stdio get stream-read ;
: read-until ( seps -- str/f sep/f ) stdio get stream-read-until ;
: write1 ( ch -- ) output-stream get stream-write1 ;
: write ( str -- ) output-stream get stream-write ;
: flush ( -- ) output-stream get stream-flush ;
: write1 ( ch -- ) stdio get stream-write1 ;
: write ( str -- ) stdio get stream-write ;
: flush ( -- ) stdio get stream-flush ;
: nl ( -- ) output-stream get stream-nl ;
: format ( str style -- ) output-stream get stream-format ;
: nl ( -- ) stdio get stream-nl ;
: format ( str style -- ) stdio get stream-format ;
: with-input-stream* ( stream quot -- )
input-stream swap with-variable ; inline
: with-stream* ( stream quot -- )
stdio swap with-variable ; inline
: with-input-stream ( stream quot -- )
[ with-input-stream* ] curry with-disposal ; inline
: with-stream ( stream quot -- )
[ with-stream* ] curry with-disposal ; inline
: with-output-stream* ( stream quot -- )
output-stream swap with-variable ; inline
: with-output-stream ( stream quot -- )
[ with-output-stream* ] curry with-disposal ; inline
: with-streams* ( input output quot -- )
[ output-stream set input-stream set ] prepose with-scope ; inline
: with-streams ( input output quot -- )
[ [ with-streams* ] 3curry ]
[ [ drop dispose dispose ] 3curry ] 3bi
[ ] cleanup ; inline
: tabular-output ( style quot -- )
swap >r { } make r> stdio get stream-write-table ; inline
swap >r { } make r> output-stream get stream-write-table ; inline
: with-row ( quot -- )
{ } make , ; inline
: with-cell ( quot -- )
H{ } stdio get make-cell-stream
[ swap with-stream ] keep , ; inline
H{ } output-stream get make-cell-stream
[ swap with-output-stream ] keep , ; inline
: write-cell ( str -- )
[ write ] with-cell ; inline
@ -71,13 +84,14 @@ SYMBOL: stderr
swap dup assoc-empty? [
drop call
] [
stdio get make-span-stream swap with-stream
output-stream get make-span-stream swap with-output-stream
] if ; inline
: with-nesting ( style quot -- )
>r stdio get make-block-stream r> with-stream ; inline
>r output-stream get make-block-stream
r> with-output-stream ; inline
: print ( string -- ) stdio get stream-print ;
: print ( string -- ) output-stream get stream-print ;
: bl ( -- ) " " write ;
@ -85,9 +99,9 @@ SYMBOL: stderr
presented associate format ;
: lines ( stream -- seq )
[ [ readln dup ] [ ] [ drop ] unfold ] with-stream ;
[ [ readln dup ] [ ] [ drop ] unfold ] with-input-stream ;
: contents ( stream -- str )
[
[ 65536 read dup ] [ ] [ drop ] unfold concat f like
] with-stream ;
] with-input-stream ;

4
core/io/streams/byte-array/byte-array-docs.factor
View File

@ -25,10 +25,10 @@ HELP: <byte-writer>
HELP: with-byte-reader
{ $values { "encoding" "an encoding descriptor" }
{ "quot" quotation } { "byte-array" byte-array } }
{ $description "Calls the quotation in a new dynamic scope with " { $link stdio } " rebound to an input stream for reading from a byte array using an encoding." } ;
{ $description "Calls the quotation in a new dynamic scope with " { $link input-stream } " rebound to an input stream for reading from a byte array using an encoding." } ;
HELP: with-byte-writer
{ $values { "encoding" "an encoding descriptor" }
{ "quot" quotation }
{ "byte-array" byte-array } }
{ $description "Calls the quotation in a new dynamic scope with " { $link stdio } " rebound to an output stream writing data to a byte array using an encoding." } ;
{ $description "Calls the quotation in a new dynamic scope with " { $link output-stream } " rebound to an output stream writing data to a byte array using an encoding." } ;

8
core/io/streams/byte-array/byte-array.factor
View File

@ -1,16 +1,16 @@
USING: byte-arrays byte-vectors kernel io.encodings io.streams.string
sequences io namespaces io.encodings.private ;
sequences io namespaces io.encodings.private accessors ;
IN: io.streams.byte-array
: <byte-writer> ( encoding -- stream )
512 <byte-vector> swap <encoder> ;
: with-byte-writer ( encoding quot -- byte-array )
>r <byte-writer> r> [ stdio get ] compose with-stream*
dup encoder? [ encoder-stream ] when >byte-array ; inline
>r <byte-writer> r> [ output-stream get ] compose with-output-stream*
dup encoder? [ stream>> ] when >byte-array ; inline
: <byte-reader> ( byte-array encoding -- stream )
>r >byte-vector dup reverse-here r> <decoder> ;
: with-byte-reader ( byte-array encoding quot -- )
>r <byte-reader> r> with-stream ; inline
>r <byte-reader> r> with-input-stream* ; inline

2
core/io/streams/c/c.factor
View File

@ -2,7 +2,7 @@
! See http://factorcode.org/license.txt for BSD license.
USING: kernel kernel.private namespaces io io.encodings
sequences math generic threads.private classes io.backend
io.streams.duplex io.files continuations byte-arrays ;
io.files continuations byte-arrays ;
IN: io.streams.c
TUPLE: c-writer handle ;

19
core/io/streams/duplex/duplex-docs.factor
View File

@ -1,19 +0,0 @@
USING: help.markup help.syntax io continuations ;
IN: io.streams.duplex
ARTICLE: "io.streams.duplex" "Duplex streams"
"Duplex streams combine an input stream and an output stream into a bidirectional stream."
{ $subsection duplex-stream }
{ $subsection <duplex-stream> } ;
ABOUT: "io.streams.duplex"
HELP: duplex-stream
{ $class-description "A bidirectional stream wrapping an input and output stream." } ;
HELP: <duplex-stream>
{ $values { "in" "an input stream" } { "out" "an output stream" } { "stream" " a duplex stream" } }
{ $description "Creates a duplex stream. Writing to a duplex stream will write to " { $snippet "out" } ", and reading from a duplex stream will read from " { $snippet "in" } ". Closing a duplex stream closes both the input and output streams." } ;
HELP: stream-closed-twice
{ $error-description "This error is thrown when performing an I/O operation on a " { $link duplex-stream } " which has been closed with " { $link dispose } "." } ;

4
core/io/streams/string/string-docs.factor
View File

@ -17,7 +17,7 @@ HELP: <string-writer>
HELP: with-string-writer
{ $values { "quot" quotation } { "str" string } }
{ $description "Calls the quotation in a new dynamic scope with " { $link stdio } " rebound to a new string writer. The accumulated string is output when the quotation returns." } ;
{ $description "Calls the quotation in a new dynamic scope with " { $link output-stream } " rebound to a new string writer. The accumulated string is output when the quotation returns." } ;
HELP: <string-reader>
{ $values { "str" string } { "stream" "an input stream" } }
@ -26,4 +26,4 @@ HELP: <string-reader>
HELP: with-string-reader
{ $values { "str" string } { "quot" quotation } }
{ $description "Calls the quotation in a new dynamic scope with " { $link stdio } " rebound to an input stream reading " { $snippet "str" } " from beginning to end." } ;
{ $description "Calls the quotation in a new dynamic scope with " { $link input-stream } " rebound to an input stream reading " { $snippet "str" } " from beginning to end." } ;

2
core/io/streams/string/string-tests.factor
View File

@ -35,7 +35,7 @@ unit-test
"J" read-until 2array ,
"i" read-until 2array ,
"X" read-until 2array ,
] with-stream
] with-input-stream
] { } make
] unit-test

9
core/io/streams/string/string.factor
View File

@ -15,7 +15,7 @@ M: growable stream-flush drop ;
512 <sbuf> ;
: with-string-writer ( quot -- str )
<string-writer> swap [ stdio get ] compose with-stream*
<string-writer> swap [ output-stream get ] compose with-output-stream*
>string ; inline
M: growable stream-read1 dup empty? [ drop f ] [ pop ] if ;
@ -56,7 +56,7 @@ M: null decode-char drop stream-read1 ;
>sbuf dup reverse-here null <decoder> ;
: with-string-reader ( str quot -- )
>r <string-reader> r> with-stream ; inline
>r <string-reader> r> with-input-stream ; inline
INSTANCE: growable plain-writer
@ -67,15 +67,14 @@ INSTANCE: growable plain-writer
] unless ;
: map-last ( seq quot -- seq )
swap dup length <reversed>
[ zero? rot [ call ] keep swap ] 2map nip ; inline
>r dup length <reversed> [ zero? ] r> compose 2map ; inline
: format-table ( table -- seq )
flip [ format-column ] map-last
flip [ " " join ] map ;
M: plain-writer stream-write-table
[ drop format-table [ print ] each ] with-stream* ;
[ drop format-table [ print ] each ] with-output-stream* ;
M: plain-writer make-cell-stream 2drop <string-writer> ;

8
core/listener/listener-docs.factor
View File

@ -32,14 +32,14 @@ HELP: listener-hook
HELP: read-quot
{ $values { "quot/f" "a parsed quotation, or " { $link f } " indicating end of file" } }
{ $description "Reads a Factor expression which possibly spans more than one line from " { $link stdio } " stream. Additional lines of input are read while the parser stack height is greater than one. Since structural parsing words push partial quotations on the stack, this will keep on reading input until all delimited parsing words are terminated." } ;
{ $description "Reads a Factor expression which possibly spans more than one line from " { $link input-stream } ". Additional lines of input are read while the parser stack height is greater than one. Since structural parsing words push partial quotations on the stack, this will keep on reading input until all delimited parsing words are terminated." } ;
HELP: listen
{ $description "Prompts for an expression on the " { $link stdio } " stream and evaluates it. On end of file, " { $link quit-flag } " is set to terminate the listener loop." }
{ $errors "If the expression input by the user throws an error, the error is printed to the " { $link stdio } " stream and the word returns normally." } ;
{ $description "Prompts for an expression on " { $link input-stream } " and evaluates it. On end of file, " { $link quit-flag } " is set to terminate the listener loop." }
{ $errors "If the expression input by the user throws an error, the error is printed to " { $link output-stream } " and the word returns normally." } ;
HELP: listener
{ $description "Prompts for expressions on the " { $link stdio } " stream and evaluates them until end of file is reached." } ;
{ $description "Prompts for expressions on " { $link input-stream } " and evaluates them until end of file is reached." } ;
HELP: bye
{ $description "Exits the current listener." }

9
core/listener/listener.factor
View File

@ -2,8 +2,8 @@
! See http://factorcode.org/license.txt for BSD license.
USING: arrays hashtables io kernel math math.parser memory
namespaces parser sequences strings io.styles
io.streams.duplex vectors words generic system combinators
continuations debugger definitions compiler.units accessors ;
vectors words generic system combinators continuations debugger
definitions compiler.units accessors ;
IN: listener
SYMBOL: quit-flag
@ -35,10 +35,7 @@ GENERIC: stream-read-quot ( stream -- quot/f )
M: object stream-read-quot
V{ } clone read-quot-loop ;
M: duplex-stream stream-read-quot
duplex-stream-in stream-read-quot ;
: read-quot ( -- quot/f ) stdio get stream-read-quot ;
: read-quot ( -- quot/f ) input-stream get stream-read-quot ;
: bye ( -- ) quit-flag on ;

6
core/math/parser/parser-tests.factor
View File

@ -98,3 +98,9 @@ unit-test
[ 1 1 >base ] must-fail
[ 1 0 >base ] must-fail
[ 1 -1 >base ] must-fail
[ "0.0/0.0" ] [ 0.0 0.0 / number>string ] unit-test
[ "1.0/0.0" ] [ 1.0 0.0 / number>string ] unit-test
[ "-1.0/0.0" ] [ -1.0 0.0 / number>string ] unit-test

2
core/math/parser/parser.factor
View File

@ -140,9 +140,9 @@ M: ratio >base
M: float >base
drop {
{ [ dup fp-nan? ] [ drop "0.0/0.0" ] }
{ [ dup 1.0/0.0 = ] [ drop "1.0/0.0" ] }
{ [ dup -1.0/0.0 = ] [ drop "-1.0/0.0" ] }
{ [ dup fp-nan? ] [ drop "0.0/0.0" ] }
[ float>string fix-float ]
} cond ;

21
core/parser/parser-docs.factor
View File

@ -5,7 +5,7 @@ quotations namespaces compiler.units assocs ;
IN: parser
ARTICLE: "vocabulary-search-shadow" "Shadowing word names"
"If adding a vocabulary to the search path results in a word in another vocabulary becoming inaccessible due to the new vocabulary defining a word with the same name, a message is printed to the " { $link stdio } " stream. Except when debugging suspected name clashes, these messages can be ignored."
"If adding a vocabulary to the search path results in a word in another vocabulary becoming inaccessible due to the new vocabulary defining a word with the same name, we say that the old word has been " { $emphasis "shadowed" } "."
$nl
"Here is an example where shadowing occurs:"
{ $code
@ -13,18 +13,18 @@ $nl
"USING: sequences io ;"
""
": append"
" \"foe::append calls sequences::append\" print append ;"
" \"foe::append calls sequences:append\" print append ;"
""
"IN: fee"
""
": append"
" \"fee::append calls fee::append\" print append ;"
" \"fee::append calls fee:append\" print append ;"
""
"IN: fox"
"USE: foe"
""
": append"
" \"fox::append calls foe::append\" print append ;"
" \"fox::append calls foe:append\" print append ;"
""
"\"1234\" \"5678\" append print"
""
@ -33,12 +33,13 @@ $nl
}
"When placed in a source file and run, the above code produces the following output:"
{ $code
"foe::append calls sequences::append"
"foe:append calls sequences:append"
"12345678"
"fee::append calls foe::append"
"foe::append calls sequences::append"
"fee:append calls foe:append"
"foe:append calls sequences:append"
"12345678"
} ;
}
"The " { $vocab-link "qualified" } " vocabulary contains some tools for helping with shadowing." ;
ARTICLE: "vocabulary-search-errors" "Word lookup errors"
"If the parser cannot not find a word in the current vocabulary search path, it attempts to look for the word in all loaded vocabularies. Then, one of three things happen:"
@ -215,7 +216,7 @@ HELP: save-location
{ $description "Saves the location of a definition and associates this definition with the current source file." } ;
HELP: parser-notes
{ $var-description "A boolean controlling whether the parser will print various notes and warnings. Switched on by default. If a source file is being run for its effect on the " { $link stdio } " stream, this variable should be switched off, to prevent parser notes from polluting the output." } ;
{ $var-description "A boolean controlling whether the parser will print various notes and warnings. Switched on by default. If a source file is being run for its effect on " { $link output-stream } ", this variable should be switched off, to prevent parser notes from polluting the output." } ;
HELP: parser-notes?
{ $values { "?" "a boolean" } }
@ -506,7 +507,7 @@ HELP: bootstrap-file
HELP: eval>string
{ $values { "str" string } { "output" string } }
{ $description "Evaluates the Factor code in " { $snippet "str" } " with the " { $link stdio } " stream rebound to a string output stream, then outputs the resulting string." } ;
{ $description "Evaluates the Factor code in " { $snippet "str" } " with " { $link output-stream } " rebound to a string output stream, then outputs the resulting string." } ;
HELP: staging-violation
{ $values { "word" word } }

12
core/prettyprint/prettyprint-docs.factor
View File

@ -135,7 +135,7 @@ ARTICLE: "prettyprint" "The prettyprinter"
$nl
"Prettyprinter words are found in the " { $vocab-link "prettyprint" } " vocabulary."
$nl
"The key words to print an object to the " { $link stdio } " stream; the first two emit a trailing newline, the second two do not:"
"The key words to print an object to " { $link output-stream } "; the first two emit a trailing newline, the second two do not:"
{ $subsection . }
{ $subsection short. }
{ $subsection pprint }
@ -161,17 +161,17 @@ ABOUT: "prettyprint"
HELP: with-pprint
{ $values { "obj" object } { "quot" quotation } }
{ $description "Sets up the prettyprinter and calls the quotation in a new scope. The quotation should add sections to the top-level block. When the quotation returns, the top-level block is printed to the " { $link stdio } " stream." } ;
{ $description "Sets up the prettyprinter and calls the quotation in a new scope. The quotation should add sections to the top-level block. When the quotation returns, the top-level block is printed to " { $link output-stream } "." } ;
HELP: pprint
{ $values { "obj" object } }
{ $description "Prettyprints an object to the " { $link stdio } " stream. Output is influenced by many variables; see " { $link "prettyprint-variables" } "." } ;
{ $description "Prettyprints an object to " { $link output-stream } ". Output is influenced by many variables; see " { $link "prettyprint-variables" } "." } ;
{ pprint pprint* with-pprint } related-words
HELP: .
{ $values { "obj" object } }
{ $description "Prettyprints an object to the " { $link stdio } " stream with a trailing line break. Output is influenced by many variables; see " { $link "prettyprint-variables" } "." } ;
{ $description "Prettyprints an object to " { $link output-stream } " with a trailing line break. Output is influenced by many variables; see " { $link "prettyprint-variables" } "." } ;
HELP: unparse
{ $values { "obj" object } { "str" "Factor source string" } }
@ -179,11 +179,11 @@ HELP: unparse
HELP: pprint-short
{ $values { "obj" object } }
{ $description "Prettyprints an object to the " { $link stdio } " stream. This word rebinds printer control variables to enforce ``shorter'' output. See " { $link "prettyprint-variables" } "." } ;
{ $description "Prettyprints an object to " { $link output-stream } ". This word rebinds printer control variables to enforce ``shorter'' output. See " { $link "prettyprint-variables" } "." } ;
HELP: short.
{ $values { "obj" object } }
{ $description "Prettyprints an object to the " { $link stdio } " stream with a trailing line break. This word rebinds printer control variables to enforce ``shorter'' output." } ;
{ $description "Prettyprints an object to " { $link output-stream } " with a trailing line break. This word rebinds printer control variables to enforce ``shorter'' output." } ;
HELP: .b
{ $values { "n" "an integer" } }

2
core/prettyprint/sections/sections-docs.factor
View File

@ -15,7 +15,7 @@ HELP: line-limit?
HELP: do-indent
{ $description "Outputs the current indent nesting to the " { $link stdio } " stream." } ;
{ $description "Outputs the current indent nesting to " { $link output-stream } "." } ;
HELP: fresh-line
{ $values { "n" "the current column position" } }

6
core/sequences/sequences.factor
View File

@ -670,9 +670,15 @@ PRIVATE>
: unclip ( seq -- rest first )
[ rest ] [ first ] bi ;
: unclip-last ( seq -- butfirst last )
[ 1 head* ] [ peek ] bi ;
: unclip-slice ( seq -- rest first )
[ rest-slice ] [ first ] bi ;
: unclip-last-slice ( seq -- butfirst last )
[ 1 head-slice* ] [ peek ] bi ;
: <flat-slice> ( seq -- slice )
dup slice? [ { } like ] when 0 over length rot <slice> ;
inline

70
core/splitting/splitting.factor
View File

@ -1,42 +1,72 @@
! Copyright (C) 2005, 2007 Slava Pestov.
! Copyright (C) 2005, 2008 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
USING: kernel math namespaces strings arrays vectors sequences
sets math.order ;
sets math.order accessors ;
IN: splitting
TUPLE: groups seq n sliced? ;
TUPLE: abstract-groups seq n ;
: check-groups 0 <= [ "Invalid group count" throw ] when ;
: check-groups dup 0 <= [ "Invalid group count" throw ] when ; inline
: construct-groups ( seq n class -- groups )
>r check-groups r> boa ; inline
GENERIC: group@ ( n groups -- from to seq )
M: abstract-groups nth group@ subseq ;
M: abstract-groups set-nth group@ <slice> 0 swap copy ;
M: abstract-groups like drop { } like ;
INSTANCE: abstract-groups sequence
TUPLE: groups < abstract-groups ;
: <groups> ( seq n -- groups )
dup check-groups f groups boa ; inline
: <sliced-groups> ( seq n -- groups )
<groups> t over set-groups-sliced? ;
groups construct-groups ; inline
M: groups length
dup groups-seq length swap groups-n [ + 1- ] keep /i ;
[ seq>> length ] [ n>> ] bi [ + 1- ] keep /i ;
M: groups set-length
[ groups-n * ] keep groups-seq set-length ;
[ n>> * ] [ seq>> ] bi set-length ;
: group@ ( n groups -- from to seq )
[ groups-n [ * dup ] keep + ] keep
groups-seq [ length min ] keep ;
M: groups group@
[ n>> [ * dup ] keep + ] [ seq>> ] bi [ length min ] keep ;
M: groups nth
[ group@ ] keep
groups-sliced? [ <slice> ] [ subseq ] if ;
TUPLE: sliced-groups < groups ;
M: groups set-nth
group@ <slice> 0 swap copy ;
: <sliced-groups> ( seq n -- groups )
sliced-groups construct-groups ; inline
M: groups like drop { } like ;
M: sliced-groups nth group@ <slice> ;
INSTANCE: groups sequence
TUPLE: clumps < abstract-groups ;
: <clumps> ( seq n -- groups )
clumps construct-groups ; inline
M: clumps length
[ seq>> length ] [ n>> ] bi - 1+ ;
M: clumps set-length
[ n>> + 1- ] [ seq>> ] bi set-length ;
M: clumps group@
[ n>> over + ] [ seq>> ] bi ;
TUPLE: sliced-clumps < groups ;
: <sliced-clumps> ( seq n -- groups )
sliced-clumps construct-groups ; inline
M: sliced-clumps nth group@ <slice> ;
: group ( seq n -- array ) <groups> { } like ;
: clump ( seq n -- array ) <clumps> { } like ;
: ?head ( seq begin -- newseq ? )
2dup head? [ length tail t ] [ drop f ] if ;

9
core/threads/threads-docs.factor
View File

@ -116,10 +116,13 @@ $nl
"Other threads may interrupt the sleep by calling " { $link interrupt } "." } ;
HELP: sleep
{ $values { "ms" "a non-negative integer" } }
{ $description "Suspends the current thread for " { $snippet "ms" } " milliseconds."
{ $values { "dt" "a duration" } }
{ $description "Suspends the current thread for the given duration."
$nl
"Other threads may interrupt the sleep by calling " { $link interrupt } "." } ;
"Other threads may interrupt the sleep by calling " { $link interrupt } "." }
{ $examples
{ $code "USING: threads calendar ;" "10 seconds sleep" }
} ;
HELP: interrupt
{ $values { "thread" thread } }

4
core/threads/threads.factor
View File

@ -93,7 +93,7 @@ PRIVATE>
<PRIVATE
: schedule-sleep ( thread ms -- )
: schedule-sleep ( thread dt -- )
>r check-registered dup r> sleep-queue heap-push*
>>sleep-entry drop ;
@ -153,7 +153,7 @@ M: integer sleep-until
M: f sleep-until
drop [ drop ] "interrupt" suspend drop ;
GENERIC: sleep ( ms -- )
GENERIC: sleep ( dt -- )
M: real sleep
millis + >integer sleep-until ;

6
extra/asn1/asn1-tests.factor
View File

@ -1,16 +1,16 @@
USING: asn1 asn1.ldap io io.streams.string tools.test ;
[ 6 ] [
"\u000002\u000001\u000006" <string-reader> [ asn-syntax read-ber ] with-stream
"\u000002\u000001\u000006" <string-reader> [ asn-syntax read-ber ] with-input-stream
] unit-test
[ "testing" ] [
"\u000004\u000007testing" <string-reader> [ asn-syntax read-ber ] with-stream
"\u000004\u000007testing" <string-reader> [ asn-syntax read-ber ] with-input-stream
] unit-test
[ { 1 { 3 "Administrator" "ad_is_bogus" } } ] [
"0$\u000002\u000001\u000001`\u00001f\u000002\u000001\u000003\u000004\rAdministrator\u000080\u00000bad_is_bogus"
<string-reader> [ asn-syntax read-ber ] with-stream
<string-reader> [ asn-syntax read-ber ] with-input-stream
] unit-test
[

4
extra/asn1/asn1.factor
View File

@ -98,7 +98,7 @@ DEFER: read-ber
SYMBOL: end
: (read-array) ( stream -- )
: (read-array) ( -- )
elements get element-id [
elements get element-syntax read-ber
dup end = [ drop ] [ , (read-array) ] if
@ -106,7 +106,7 @@ SYMBOL: end
: read-array ( -- array ) [ (read-array) ] { } make ;
: set-case ( -- )
: set-case ( -- object )
elements get element-newobj
elements get element-objtype {
{ "boolean" [ "\0" = not ] }

12
extra/benchmark/reverse-complement/reverse-complement.factor
View File

@ -32,13 +32,11 @@ HINTS: do-line vector string ;
readln [ do-line (reverse-complement) ] [ show-seq ] if* ;
: reverse-complement ( infile outfile -- )
ascii <file-writer> [
swap ascii <file-reader> [
swap <duplex-stream> [
500000 <vector> (reverse-complement)
] with-stream
] with-disposal
] with-disposal ;
ascii [
ascii [
500000 <vector> (reverse-complement)
] with-file-reader
] with-file-writer ;
: reverse-complement-in
"reverse-complement-in.txt" temp-file ;

12
extra/benchmark/sockets/sockets.factor
View File

@ -1,6 +1,6 @@
USING: io.sockets io kernel math threads io.encodings.ascii
debugger tools.time prettyprint concurrency.count-downs
namespaces arrays continuations ;
io.streams.duplex debugger tools.time prettyprint
concurrency.count-downs namespaces arrays continuations ;
IN: benchmark.sockets
SYMBOL: counter
@ -30,17 +30,17 @@ SYMBOL: counter
] ignore-errors ;
: simple-client ( -- )
server-addr ascii <client> [
server-addr ascii [
CHAR: b write1 flush
number-of-requests
[ CHAR: a dup write1 flush read1 assert= ] times
counter get count-down
] with-stream ;
] with-client ;
: stop-server ( -- )
server-addr ascii <client> [
server-addr ascii [
CHAR: x write1
] with-stream ;
] with-client ;
: clients ( n -- )
dup pprint " clients: " write [

4
extra/builder/util/util.factor
View File

@ -16,7 +16,7 @@ IN: builder.util
: minutes>ms ( min -- ms ) 60 * 1000 * ;
: file>string ( file -- string ) utf8 [ stdio get contents ] with-file-reader ;
: file>string ( file -- string ) utf8 file-contents ;
! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@ -107,5 +107,5 @@ USE: prettyprint
! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
: git-id ( -- id )
{ "git" "show" } utf8 <process-stream> [ readln ] with-stream
{ "git" "show" } utf8 <process-reader> [ readln ] with-input-stream
" " split second ;

2
extra/checksums/md5/md5.factor
View File

@ -180,4 +180,4 @@ SINGLETON: md5
INSTANCE: md5 checksum
M: md5 checksum-stream ( stream -- byte-array )
drop [ initialize-md5 stream>md5 get-md5 ] with-stream ;
drop [ initialize-md5 stream>md5 get-md5 ] with-input-stream ;

2
extra/checksums/sha1/sha1.factor
View File

@ -111,7 +111,7 @@ SINGLETON: sha1
INSTANCE: sha1 checksum
M: sha1 checksum-stream ( stream -- sha1 )
drop [ initialize-sha1 stream>sha1 get-sha1 ] with-stream ;
drop [ initialize-sha1 stream>sha1 get-sha1 ] with-input-stream ;
: sha1-interleave ( string -- seq )
[ zero? ] left-trim

7
extra/concurrency/distributed/distributed.factor
View File

@ -3,7 +3,7 @@
USING: serialize sequences concurrency.messaging threads io
io.server qualified arrays namespaces kernel io.encodings.binary
accessors ;
QUALIFIED: io.sockets
FROM: io.sockets => host-name <inet> with-client ;
IN: concurrency.distributed
SYMBOL: local-node
@ -23,7 +23,7 @@ SYMBOL: local-node
: start-node ( port -- )
[ internet-server ]
[ io.sockets:host-name swap io.sockets:<inet> ] bi
[ host-name swap <inet> ] bi
(start-node) ;
TUPLE: remote-process id node ;
@ -31,8 +31,7 @@ TUPLE: remote-process id node ;
C: <remote-process> remote-process
: send-remote-message ( message node -- )
binary io.sockets:<client>
[ serialize ] with-stream ;
binary [ serialize ] with-client ;
M: remote-process send ( message thread -- )
[ id>> 2array ] [ node>> ] bi

2
extra/contributors/contributors.factor
View File

@ -7,7 +7,7 @@ IN: contributors
: changelog ( -- authors )
image parent-directory [
"git-log --pretty=format:%an" <process-stream> lines
"git-log --pretty=format:%an" <process-reader> lines
] with-directory ;
: patch-counts ( authors -- assoc )

6
extra/cpu/8080/test/test.factor
View File

@ -1,5 +1,5 @@
USING: kernel cpu.8080 cpu.8080.emulator math math io
tools.time combinators sequences io.files ;
tools.time combinators sequences io.files io.encodings.ascii ;
IN: cpu.8080.test
: step ( cpu -- )
@ -29,7 +29,7 @@ IN: cpu.8080.test
: >ppm ( cpu filename -- cpu )
#! Dump the current screen image to a ppm image file with the given name.
<file-writer> [
ascii [
"P3" print
"256 224" print
"1" print
@ -45,7 +45,7 @@ IN: cpu.8080.test
] each-8bit drop
] each drop nl
] each
] with-stream ;
] with-file-writer ;
: time-test ( -- )
test-cpu [ 1000000 run-n drop ] time ;

4
extra/crypto/hmac/hmac.factor
View File

@ -30,7 +30,7 @@ MEMO: opad ( -- seq ) 64 HEX: 5c <array> ;
ipad seq-bitxor ;
: stream>sha1-hmac ( K stream -- hmac )
[ init-hmac sha1-hmac ] with-stream ;
[ init-hmac sha1-hmac ] with-input-stream ;
: file>sha1-hmac ( K path -- hmac )
binary <file-reader> stream>sha1-hmac ;
@ -39,7 +39,7 @@ MEMO: opad ( -- seq ) 64 HEX: 5c <array> ;
binary <byte-reader> stream>sha1-hmac ;
: stream>md5-hmac ( K stream -- hmac )
[ init-hmac md5-hmac ] with-stream ;
[ init-hmac md5-hmac ] with-input-stream ;
: file>md5-hmac ( K path -- hmac )
binary <file-reader> stream>md5-hmac ;

4
extra/csv/csv.factor
View File

@ -61,11 +61,11 @@ VAR: delimiter
: csv-row ( stream -- row )
init-vars
[ row nip ] with-stream ;
[ row nip ] with-input-stream ;
: csv ( stream -- rows )
init-vars
[ [ (csv) ] { } make ] with-stream ;
[ [ (csv) ] { } make ] with-input-stream ;
: with-delimiter ( char quot -- )
delimiter swap with-variable ; inline

8
extra/delegate/protocols/protocols.factor
View File

@ -1,7 +1,7 @@
! Copyright (C) 2007 Daniel Ehrenberg
! See http://factorcode.org/license.txt for BSD license.
USING: delegate sequences.private sequences assocs prettyprint.sections
io definitions kernel continuations ;
io definitions kernel continuations listener ;
IN: delegate.protocols
PROTOCOL: sequence-protocol
@ -12,8 +12,10 @@ PROTOCOL: assoc-protocol
at* assoc-size >alist set-at assoc-clone-like { assoc-find 1 }
delete-at clear-assoc new-assoc assoc-like ;
PROTOCOL: stream-protocol
stream-read1 stream-read stream-read-until dispose
PROTOCOL: input-stream-protocol
stream-read1 stream-read stream-read-until stream-read-quot ;
PROTOCOL: output-stream-protocol
stream-flush stream-write1 stream-write stream-format
stream-nl make-span-stream make-block-stream stream-readln
make-cell-stream stream-write-table ;

8
extra/destructors/destructors.factor
View File

@ -1,7 +1,7 @@
! Copyright (C) 2007 Doug Coleman.
! See http://factorcode.org/license.txt for BSD license.
USING: continuations io.backend libc kernel namespaces
sequences system vectors ;
USING: continuations io.backend io.nonblocking libc kernel
namespaces sequences system vectors ;
IN: destructors
SYMBOL: error-destructors
@ -59,10 +59,8 @@ TUPLE: handle-destructor alien ;
C: <handle-destructor> handle-destructor
HOOK: destruct-handle io-backend ( obj -- )
M: handle-destructor dispose ( obj -- )
handle-destructor-alien destruct-handle ;
handle-destructor-alien close-handle ;
: close-always ( handle -- )
<handle-destructor> add-always-destructor ;

4
extra/editors/jedit/jedit.factor
View File

@ -25,11 +25,11 @@ IN: editors.jedit
] with-byte-writer ;
: send-jedit-request ( request -- )
jedit-server-info "localhost" rot <inet> binary <client> [
jedit-server-info "localhost" rot <inet> binary [
4 >be write
dup length 2 >be write
write
] with-stream ;
] with-client ;
: jedit-location ( file line -- )
number>string "+line:" prepend 2array

2
extra/fry/fry-docs.factor
View File

@ -87,7 +87,7 @@ $nl
} ;
ARTICLE: "fry.limitations" "Fried quotation limitations"
"As with " { $link "locals" } ", fried quotations cannot contain " { $link >r } " and " { $link r> } ". Unlike " { $link "locals" } ", using " { $link dip } " is not a suitable workaround since unlike closure conversion, fry conversion is not recursive, and so the quotation passed to " { $link dip } " cannot contain fry specifiers." ;
"As with " { $vocab-link "locals" } ", fried quotations cannot contain " { $link >r } " and " { $link r> } "." ;
ARTICLE: "fry" "Fried quotations"
"A " { $emphasis "fried quotation" } " differs from a literal quotation in that when it is evaluated, instead of just pushing itself on the stack, it consumes zero or more stack values and inserts them into the quotation."

4
extra/fry/fry-tests.factor
View File

@ -48,3 +48,7 @@ sequences ;
[ { 1 2 3 } ] [
3 1 '[ , [ , + ] map ] call
] unit-test
[ { 1 { 2 { 3 } } } ] [
1 2 3 '[ , [ , [ , 1array ] call 2array ] call 2array ] call
] unit-test

2
extra/fry/fry.factor
View File

@ -54,7 +54,7 @@ DEFER: (shallow-fry)
[ { , namespaces:, @ } member? ] filter length
\ , <repetition> %
]
[ deep-fry % ] bi
[ fry % ] bi
] [ namespaces:, ] if
] each
] [ ] make deep-fry ;

0
core/io/streams/duplex/authors.txt → extra/geo-ip/authors.txt
View File

46
extra/geo-ip/geo-ip.factor Normal file
View File

@ -0,0 +1,46 @@
USING: kernel sequences io.files io.launcher io.encodings.ascii
io.streams.string http.client sequences.lib combinators
math.parser math.vectors math.intervals interval-maps memoize
csv accessors assocs strings math splitting ;
IN: geo-ip
: db-path "IpToCountry.csv" temp-file ;
: db-url "http://software77.net/cgi-bin/ip-country/geo-ip.pl?action=download" ;
: download-db ( -- path )
db-path dup exists? [
db-url over ".gz" append download-to
{ "gunzip" } over ".gz" append (normalize-path) suffix try-process
] unless ;
TUPLE: ip-entry from to registry assigned city cntry country ;
: parse-ip-entry ( row -- ip-entry )
7 firstn {
[ string>number ]
[ string>number ]
[ ]
[ ]
[ ]
[ ]
[ ]
} spread ip-entry boa ;
MEMO: ip-db ( -- seq )
download-db ascii file-lines
[ "#" head? not ] filter "\n" join <string-reader> csv
[ parse-ip-entry ] map ;
MEMO: ip-intervals ( -- interval-map )
ip-db [ [ [ from>> ] [ to>> ] bi [a,b] ] keep ] { } map>assoc
<interval-map> ;
GENERIC: lookup-ip ( ip -- ip-entry )
M: string lookup-ip
"." split [ string>number ] map
{ HEX: 1000000 HEX: 10000 HEX: 100 1 } v.
lookup-ip ;
M: integer lookup-ip ip-intervals interval-at ;

1
extra/geo-ip/summary.txt Normal file
View File

@ -0,0 +1 @@
IP address geolocation using database from http://software77.net/cgi-bin/ip-country/

1
extra/geo-ip/tags.txt Normal file
View File

@ -0,0 +1 @@
enterprise

4
extra/gesture-logger/gesture-logger.factor
View File

@ -15,13 +15,13 @@ TUPLE: gesture-logger stream ;
M: gesture-logger handle-gesture*
drop
dup T{ button-down } = [ over request-focus ] when
swap gesture-logger-stream [ . ] with-stream*
swap gesture-logger-stream [ . ] with-output-stream*
t ;
M: gesture-logger user-input*
gesture-logger-stream [
"User input: " write print
] with-stream* t ;
] with-output-stream* t ;
: gesture-logger ( -- )
[

4
extra/help/cookbook/cookbook.factor
View File

@ -205,8 +205,8 @@ ARTICLE: "cookbook-io" "Input and output cookbook"
}
"Send some bytes to a remote host:"
{ $code
"\"myhost\" 1033 <inet> <client>"
"[ { 12 17 102 } >string write ] with-stream"
"\"myhost\" 1033 <inet>"
"[ { 12 17 102 } >string write ] with-client"
}
{ $references
{ }

14
extra/help/handbook/handbook.factor
View File

@ -31,7 +31,7 @@ $nl
{ { $snippet "set-" { $emphasis "foo" } } { "sets " { $snippet "foo" } " to a new value" } { $links set-length } }
{ { $snippet { $emphasis "foo" } "-" { $emphasis "bar" } } { "(tuple accessors) outputs the value of the " { $snippet "bar" } " slot of the " { $snippet "foo" } " at the top of the stack" } { } }
{ { $snippet "set-" { $emphasis "foo" } "-" { $emphasis "bar" } } { "(tuple mutators) sets the value of the " { $snippet "bar" } " slot of the " { $snippet "foo" } " at the top of the stack" } { } }
{ { $snippet "with-" { $emphasis "foo" } } { "performs some kind of initialization and cleanup related to " { $snippet "foo" } ", usually in a new dynamic scope" } { $links with-scope with-stream } }
{ { $snippet "with-" { $emphasis "foo" } } { "performs some kind of initialization and cleanup related to " { $snippet "foo" } ", usually in a new dynamic scope" } { $links with-scope with-input-stream with-output-stream } }
{ { $snippet "$" { $emphasis "foo" } } { "help markup" } { $links $heading $emphasis } }
}
{ $heading "Stack effect conventions" }
@ -193,17 +193,19 @@ ARTICLE: "io" "Input and output"
"Utilities:"
{ $subsection "stream-binary" }
{ $subsection "styles" }
{ $heading "Files" }
{ $subsection "io.files" }
{ $subsection "io.mmap" }
{ $subsection "io.monitors" }
{ $heading "Encodings" }
{ $subsection "encodings-introduction" }
{ $subsection "io.encodings" }
{ $subsection "io.encodings.string" }
{ $heading "Other features" }
{ $heading "Files" }
{ $subsection "io.files" }
{ $subsection "io.mmap" }
{ $subsection "io.monitors" }
{ $heading "Communications" }
{ $subsection "network-streams" }
{ $subsection "io.launcher" }
{ $subsection "io.pipes" }
{ $heading "Other features" }
{ $subsection "io.timeouts" }
{ $subsection "checksums" } ;

8
extra/help/help-docs.factor
View File

@ -126,7 +126,7 @@ HELP: $title
HELP: help
{ $values { "topic" "an article name or a word" } }
{ $description
"Displays a help article or documentation associated to a word on the " { $link stdio } " stream."
"Displays a help article or documentation associated to a word on " { $link output-stream } "."
} ;
HELP: about
@ -151,7 +151,7 @@ HELP: $index
HELP: ($index)
{ $values { "articles" "a sequence of help articles" } }
{ $description "Writes a list of " { $link $subsection } " elements to the " { $link stdio } " stream." } ;
{ $description "Writes a list of " { $link $subsection } " elements to " { $link output-stream } "." } ;
HELP: xref-help
{ $description "Update help cross-referencing. Usually this is done automatically." } ;
@ -168,11 +168,11 @@ HELP: $predicate
HELP: print-element
{ $values { "element" "a markup element" } }
{ $description "Prints a markup element to the " { $link stdio } " stream." } ;
{ $description "Prints a markup element to " { $link output-stream } "." } ;
HELP: print-content
{ $values { "element" "a markup element" } }
{ $description "Prints a top-level markup element to the " { $link stdio } " stream." } ;
{ $description "Prints a top-level markup element to " { $link output-stream } "." } ;
HELP: simple-element
{ $class-description "Class of simple elements, which are just arrays of elements." } ;

2
extra/help/tutorial/tutorial.factor
View File

@ -135,7 +135,7 @@ $nl
{ $code "[ Letter? ] filter >lower" }
"This code starts with a string on the stack, removes non-alphabetical characters, and converts the result to lower case, leaving a new string on the stack. We put this code in a new word, and add the new word to " { $snippet "palindrome.factor" } ":"
{ $code ": normalize ( str -- newstr ) [ Letter? ] filter >lower ;" }
"You will need to add " { $vocab-link "unicode.categories" } " to the vocabulary search path, so that " { $link Letter? } " can be used in the source file."
"You will need to add " { $vocab-link "unicode.case" } " and " { $vocab-link "unicode.categories" } " to the vocabulary search path, so that " { $link Letter? } " can be used in the source file."
$nl
"We modify " { $snippet "palindrome?" } " to first apply " { $snippet "normalize" } " to its input:"
{ $code ": palindrome? ( str -- ? ) normalize dup reverse = ;" }

2
extra/html/html-tests.factor
View File

@ -24,7 +24,7 @@ IN: html.tests
] unit-test
[ "<" ] [
[ "<" H{ } stdio get format-html-span ] make-html-string
[ "<" H{ } output-stream get format-html-span ] make-html-string
] unit-test
TUPLE: funky town ;

12
extra/html/html.factor
View File

@ -44,7 +44,7 @@ TUPLE: html-sub-stream style stream ;
rot html-sub-stream-stream ;
: delegate-write ( string -- )
stdio get delegate stream-write ;
output-stream get delegate stream-write ;
: object-link-tag ( style quot -- )
presented pick at [
@ -101,7 +101,7 @@ TUPLE: html-sub-stream style stream ;
: format-html-span ( string style stream -- )
[
[ [ drop delegate-write ] span-tag ] object-link-tag
] with-stream* ;
] with-output-stream* ;
TUPLE: html-span-stream ;
@ -134,7 +134,7 @@ M: html-span-stream dispose
: format-html-div ( string style stream -- )
[
[ [ delegate-write ] div-tag ] object-link-tag
] with-stream* ;
] with-output-stream* ;
TUPLE: html-block-stream ;
@ -184,17 +184,17 @@ M: html-stream stream-write-table ( grid style stream -- )
</td>
] with each </tr>
] with each </table>
] with-stream* ;
] with-output-stream* ;
M: html-stream make-cell-stream ( style stream -- stream' )
(html-sub-stream) ;
M: html-stream stream-nl ( stream -- )
dup test-last-div? [ drop ] [ [ <br/> ] with-stream* ] if ;
dup test-last-div? [ drop ] [ [ <br/> ] with-output-stream* ] if ;
! Utilities
: with-html-stream ( quot -- )
stdio get <html-stream> swap with-stream* ; inline
output-stream get <html-stream> swap with-output-stream* ; inline
: xhtml-preamble
"<?xml version=\"1.0\"?>" write-html

99
extra/http/client/client.factor
View File

@ -3,7 +3,8 @@
USING: assocs http kernel math math.parser namespaces sequences
io io.sockets io.streams.string io.files io.timeouts strings
splitting calendar continuations accessors vectors math.order
io.encodings.8-bit io.encodings.binary fry debugger inspector ;
io.encodings.8-bit io.encodings.binary io.streams.duplex
fry debugger inspector ;
IN: http.client
: max-redirects 10 ;
@ -26,73 +27,56 @@ DEFER: http-request
: store-path ( request path -- request )
"?" split1 >r >>path r> dup [ query>assoc ] when >>query ;
: request-with-url ( url request -- request )
swap parse-url >r >r store-path r> >>host r> >>port ;
! This is all pretty complex because it needs to handle
! HTTP redirects, which might be absolute or relative
: absolute-redirect ( url -- request )
request get request-with-url ;
: relative-redirect ( path -- request )
request get swap store-path ;
: request-with-url ( request url -- request )
parse-url >r >r store-path r> >>host r> >>port ;
SYMBOL: redirects
: absolute-url? ( url -- ? )
[ "http://" head? ] [ "https://" head? ] bi or ;
: do-redirect ( response -- response stream )
dup response-code 300 399 between? [
stdio get dispose
: do-redirect ( response data -- response data )
over code>> 300 399 between? [
drop
redirects inc
redirects get max-redirects < [
header>> "location" swap at
dup absolute-url? [
absolute-redirect
] [
relative-redirect
] if "GET" >>method http-request
request get
swap "location" header dup absolute-url?
[ request-with-url ] [ store-path ] if
"GET" >>method http-request
] [
too-many-redirects
] if
] [
stdio get
] if ;
: close-on-error ( stream quot -- )
'[ , with-stream* ] [ ] pick '[ , dispose ] cleanup ; inline
] when ;
PRIVATE>
: http-request ( request -- response stream )
dup request [
dup request-addr latin1 <client>
1 minutes over set-timeout
[
write-request flush
read-response
do-redirect
] close-on-error
] with-variable ;
: read-chunks ( -- )
read-crlf ";" split1 drop hex> dup { f 0 } member?
[ drop ] [ read % read-crlf "" assert= read-chunks ] if ;
: do-chunked-encoding ( response stream -- response stream/string )
over "transfer-encoding" header "chunked" = [
[ [ read-chunks ] "" make ] with-stream
] when ;
: read-response-body ( response -- response data )
dup "transfer-encoding" header "chunked" =
[ [ read-chunks ] "" make ] [ input-stream get contents ] if ;
: http-request ( request -- response data )
dup request [
dup request-addr latin1 [
1 minutes timeouts
write-request
read-response
read-response-body
] with-client
do-redirect
] with-variable ;
: <get-request> ( url -- request )
<request> request-with-url "GET" >>method ;
<request>
swap request-with-url
"GET" >>method ;
: string-or-contents ( stream/string -- string )
dup string? [ contents ] unless ;
: http-get-stream ( url -- response stream/string )
<get-request> http-request do-chunked-encoding ;
: http-get* ( url -- response data )
<get-request> http-request ;
: success? ( code -- ? ) 200 = ;
@ -112,29 +96,24 @@ M: download-failed error.
over code>> success? [ nip ] [ download-failed ] if ;
: http-get ( url -- string )
http-get-stream string-or-contents check-response ;
http-get* check-response ;
: download-name ( url -- name )
file-name "?" split1 drop "/" ?tail drop ;
: download-to ( url file -- )
#! Downloads the contents of a URL to a file.
swap http-get-stream check-response
dup string? [
latin1 [ write ] with-file-writer
] [
[ swap latin1 <file-writer> stream-copy ] with-disposal
] if ;
>r http-get r> latin1 [ write ] with-file-writer ;
: download ( url -- )
dup download-name download-to ;
: <post-request> ( content-type content url -- request )
<request>
request-with-url
"POST" >>method
swap >>post-data
swap >>post-data-type ;
"POST" >>method
swap request-with-url
swap >>post-data
swap >>post-data-type ;
: http-post ( content-type content url -- response string )
<post-request> http-request do-chunked-encoding string-or-contents ;
: http-post ( content-type content url -- response data )
<post-request> http-request ;

5
extra/http/http-tests.factor
View File

@ -31,6 +31,7 @@ IN: http.tests
[ H{ { "a" { "b" "c" } } } ] [ "a=b&a=c" query>assoc ] unit-test
[ "a=3" ] [ { { "a" 3 } } assoc>query ] unit-test
: lf>crlf "\n" split "\r\n" join ;
STRING: read-request-test-1
@ -183,12 +184,12 @@ test-db [
! Try with a slightly malformed request
[ t ] [
"localhost" 1237 <inet> ascii <client> [
"localhost" 1237 <inet> ascii [
"GET nested HTTP/1.0\r\n" write flush
"\r\n" write flush
read-crlf drop
read-header
] with-stream "location" swap at "/" head?
] with-client "location" swap at "/" head?
] unit-test
[ "http://localhost:1237/redirect-loop" http-get ]

2
extra/http/http.factor
View File

@ -472,7 +472,7 @@ M: string write-response-body* write ;
M: callable write-response-body* call ;
M: object write-response-body* stdio get stream-copy ;
M: object write-response-body* output-stream get stream-copy ;
: write-response-body ( response -- response )
dup body>> write-response-body* ;

6
extra/http/server/auth/admin/admin.factor
View File

@ -82,10 +82,8 @@ IN: http.server.auth.admin
same-password-twice
user new "username" value >>username select-tuple [
user-exists? on
validation-failed
] when
user new "username" value >>username select-tuple
[ user-exists ] when
"username" value <user>
"realname" value >>realname

8
extra/http/server/cgi/cgi.factor
View File

@ -1,7 +1,7 @@
! Copyright (C) 2007, 2008 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
USING: namespaces kernel assocs io.files combinators
arrays io.launcher io http.server.static http.server
USING: namespaces kernel assocs io.files io.streams.duplex
combinators arrays io.launcher io http.server.static http.server
http accessors sequences strings math.parser fry ;
IN: http.server.cgi
@ -51,9 +51,9 @@ IN: http.server.cgi
200 >>code
"CGI output follows" >>message
swap '[
, stdio get swap <cgi-process> <process-stream> [
, output-stream get swap <cgi-process> <process-stream> [
post? [ request get post-data>> write flush ] when
stdio get swap (stream-copy)
input-stream get swap (stream-copy)
] with-stream
] >>body ;

4
extra/http/server/server.factor
View File

@ -260,15 +260,13 @@ SYMBOL: exit-continuation
bi
] recover ;
: default-timeout 1 minutes stdio get set-timeout ;
: ?refresh-all ( -- )
development-mode get-global
[ global [ refresh-all ] bind ] when ;
: handle-client ( -- )
[
default-timeout
1 minutes timeouts
?refresh-all
read-request
do-request

2
extra/http/server/static/static.factor
View File

@ -36,7 +36,7 @@ TUPLE: file-responder root hook special allow-listings ;
[ size>> "content-length" set-header ]
[ modified>> "last-modified" set-header ] bi
]
[ '[ , binary <file-reader> stdio get stream-copy ] >>body ] bi
[ '[ , binary <file-reader> output-stream get stream-copy ] >>body ] bi
] <file-responder> ;
: serve-static ( filename mime-type -- response )

1
extra/interval-maps/authors.txt Executable file
View File

@ -0,0 +1 @@
Daniel Ehrenberg

29
extra/interval-maps/interval-maps-docs.factor Executable file
View File

@ -0,0 +1,29 @@
USING: help.markup help.syntax ;
IN: interval-maps
HELP: interval-at*
{ $values { "key" "an object" } { "map" "an interval map" } { "value" "the value for the key, or f" } { "?" "whether the key is present" } }
{ $description "Looks up a key in an interval map, returning the corresponding value if the item is in an interval in the map, and a boolean flag. The operation takes O(log n) time." } ;
HELP: interval-at
{ $values { "key" "an object" } { "map" "an interval map" } { "value" "the value for the key, or f" } }
{ $description "Looks up a key in an interval map, returning the value of the corresponding interval, or f if the interval is not present in the map." } ;
HELP: interval-key?
{ $values { "key" "an object" } { "map" "an interval map" } { "?" "a boolean" } }
{ $description "Tests whether an object is in an interval in the interval map, returning t if the object is present." } ;
HELP: <interval-map>
{ $values { "specification" "an assoc" } { "map" "an interval map" } }
{ $description "From a specification, produce an interval tree. The specification is an assoc where the keys are intervals, or pairs of numbers to represent intervals, or individual numbers to represent singleton intervals. The values are the values int he interval map. Construction time is O(n log n)." } ;
ARTICLE: "interval-maps" "Interval maps"
"Interval maps are a mechanism, similar to assocs, where a set of closed intervals of keys are associated with values. As such, interval maps do not conform to the assoc protocol, because intervals of floats, for example, can be used, and it is impossible to get a list of keys in between."
"The following operations are used to query interval maps:"
{ $subsection interval-at* }
{ $subsection interval-at }
{ $subsection interval-key? }
"Use the following to construct interval maps"
{ $subsection <interval-map> } ;
ABOUT: "interval-maps"

13
extra/interval-maps/interval-maps-tests.factor Executable file
View File

@ -0,0 +1,13 @@
USING: kernel namespaces interval-maps tools.test ;
IN: interval-maps.test
SYMBOL: test
[ ] [ { { { 4 8 } 3 } { 1 2 } } <interval-map> test set ] unit-test
[ 3 ] [ 5 test get interval-at ] unit-test
[ 3 ] [ 8 test get interval-at ] unit-test
[ 3 ] [ 4 test get interval-at ] unit-test
[ f ] [ 9 test get interval-at ] unit-test
[ 2 ] [ 1 test get interval-at ] unit-test
[ f ] [ 2 test get interval-at ] unit-test
[ f ] [ 0 test get interval-at ] unit-test

41
extra/interval-maps/interval-maps.factor Executable file
View File

@ -0,0 +1,41 @@
USING: kernel sequences arrays math.intervals accessors
math.order sorting math assocs ;
IN: interval-maps
TUPLE: interval-map array ;
<PRIVATE
TUPLE: interval-node interval value ;
: fixup-value ( value ? -- value/f ? )
[ drop f f ] unless* ;
: find-interval ( key interval-map -- i )
[ interval>> from>> first <=> ] binsearch ;
GENERIC: >interval ( object -- interval )
M: number >interval [a,a] ;
M: sequence >interval first2 [a,b] ;
M: interval >interval ;
: all-intervals ( sequence -- intervals )
[ >r >interval r> ] assoc-map ;
: ensure-disjoint ( intervals -- intervals )
dup keys [ interval-intersect not ] monotonic?
[ "Intervals are not disjoint" throw ] unless ;
PRIVATE>
: interval-at* ( key map -- value ? )
array>> [ find-interval ] 2keep swapd nth
[ nip value>> ] [ interval>> interval-contains? ] 2bi
fixup-value ;
: interval-at ( key map -- value ) interval-at* drop ;
: interval-key? ( key map -- ? ) interval-at* nip ;
: <interval-map> ( specification -- map )
all-intervals ensure-disjoint
[ [ first to>> ] compare ] sort
[ interval-node boa ] { } assoc>map
interval-map boa ;

1
extra/interval-maps/summary.txt Executable file
View File

@ -0,0 +1 @@
Interval maps for disjoint closed ranges

1
extra/interval-maps/tags.txt Executable file
View File

@ -0,0 +1 @@
collections

30
extra/io/launcher/launcher-docs.factor
View File

@ -1,7 +1,7 @@
! Copyright (C) 2007, 2008 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
USING: help.markup help.syntax quotations kernel io math
calendar ;
USING: help.markup help.syntax quotations kernel io io.files
math calendar ;
IN: io.launcher
ARTICLE: "io.launcher.command" "Specifying a command"
@ -26,10 +26,10 @@ $nl
"To specify redirection, set the " { $snippet "stdin" } ", " { $snippet "stdout" } " and " { $snippet "stderr" } " slots of a " { $link process } " to one of the following values:"
{ $list
{ { $link f } " - default value; the stream is either inherited from the current process, or is a " { $link <process-stream> } " pipe" }
{ { $link +inherit+ } " - the stream is inherited from the current process, overriding a " { $link <process-stream> } " pipe" }
{ { $link +closed+ } " - the stream is closed; reads will return end of file and writes will fails" }
{ { $link +stdout+ } " - a special value for the " { $snippet "stderr" } " slot only, indicating that the standard output and standard error streams should be merged" }
{ "a path name - the stream is sent to the given file, which must exist for input and is created automatically on output" }
{ "an " { $link appender } " wrapping a path name - output is sent to the end given file, as with " { $link <file-appender> } }
{ "a file stream or a socket - the stream is connected to the given Factor stream, which cannot be used again from within Factor and must be closed after the process has been started" }
} ;
@ -47,12 +47,16 @@ ARTICLE: "io.launcher.priority" "Setting process priority"
HELP: +closed+
{ $description "Possible value for the " { $snippet "stdin" } ", " { $snippet "stdout" } ", and " { $snippet "stderr" } " slots of a " { $link process } "." } ;
HELP: +inherit+
{ $description "Possible value for the " { $snippet "stdin" } ", " { $snippet "stdout" } ", and " { $snippet "stderr" } " slots of a " { $link process } "." } ;
HELP: +stdout+
{ $description "Possible value for the " { $snippet "stderr" } " slot of a " { $link process } "." } ;
HELP: appender
{ $class-description "An object representing a file to append to. Instances are created with " { $link <appender> } "." } ;
HELP: <appender>
{ $values { "path" "a pathname string" } { "appender" appender } }
{ $description "Creates an object which may be stored in the " { $snippet "stdout" } " or " { $snippet "stderr" } " slot of a " { $link process } " instance." } ;
HELP: +prepend-environment+
{ $description "Possible value of " { $snippet "environment-mode" } " slot of a " { $link process } "."
$nl
@ -138,13 +142,6 @@ HELP: <process-stream>
{ "stream" "a bidirectional stream" } }
{ $description "Launches a process and redirects its input and output via a pair of pipes which may be read and written as a stream of the given encoding." } ;
HELP: with-process-stream
{ $values
{ "desc" "a launch descriptor" }
{ "quot" quotation }
{ "status" "an exit code" } }
{ $description "Calls " { $snippet "quot" } " in a dynamic scope where " { $link stdio } " is rebound to a process stream. After the quotation returns, waits for the process to end and outputs the exit code." } ;
HELP: wait-for-process
{ $values { "process" process } { "status" integer } }
{ $description "If the process is still running, waits for it to exit, otherwise outputs the exit code immediately. Can be called multiple times on the same process." } ;
@ -175,8 +172,9 @@ ARTICLE: "io.launcher.launch" "Launching processes"
{ $subsection try-process }
{ $subsection run-detached }
"Redirecting standard input and output to a pipe:"
{ $subsection <process-stream> }
{ $subsection with-process-stream } ;
{ $subsection <process-reader> }
{ $subsection <process-writer> }
{ $subsection <process-stream> } ;
ARTICLE: "io.launcher.examples" "Launcher examples"
"Starting a command and waiting for it to finish:"
@ -212,7 +210,7 @@ ARTICLE: "io.launcher.examples" "Launcher examples"
" <process>"
" swap >>stderr"
" \"report\" >>command"
" ascii <process-stream> lines sort reverse [ print ] each"
" ascii <process-reader> lines sort reverse [ print ] each"
"] with-disposal"
} ;

2
extra/io/launcher/launcher-tests.factor
View File

@ -2,3 +2,5 @@ IN: io.launcher.tests
USING: tools.test io.launcher ;
\ <process-stream> must-infer
\ <process-reader> must-infer
\ <process-writer> must-infer

91
extra/io/launcher/launcher.factor
View File

@ -1,9 +1,10 @@
! Copyright (C) 2008 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
USING: io io.backend io.timeouts system kernel namespaces
strings hashtables sequences assocs combinators vocabs.loader
init threads continuations math io.encodings io.streams.duplex
io.nonblocking accessors concurrency.flags ;
USING: io io.backend io.timeouts io.pipes system kernel
namespaces strings hashtables sequences assocs combinators
vocabs.loader init threads continuations math io.encodings
io.streams.duplex io.nonblocking io.streams.duplex accessors
concurrency.flags destructors ;
IN: io.launcher
TUPLE: process < identity-tuple
@ -26,9 +27,12 @@ handle status
killed ;
SYMBOL: +closed+
SYMBOL: +inherit+
SYMBOL: +stdout+
TUPLE: appender path ;
: <appender> ( path -- appender ) appender boa ;
SYMBOL: +prepend-environment+
SYMBOL: +replace-environment+
SYMBOL: +append-environment+
@ -145,20 +149,67 @@ M: process set-timeout set-process-timeout ;
M: process timed-out kill-process ;
HOOK: (process-stream) io-backend ( process -- handle in out )
M: object pipeline-element-quot
[
>process
swap >>stdout
swap >>stdin
run-detached
] curry ;
: <process-stream*> ( desc encoding -- stream process )
>r >process dup dup (process-stream) <reader&writer>
r> <encoder-duplex> -roll
process-started ;
M: process wait-for-pipeline-element wait-for-process ;
: <process-reader*> ( process encoding -- process stream )
[
>r (pipe) {
[ add-error-destructor ]
[
swap >process
[ swap out>> or ] change-stdout
run-detached
]
[ out>> close-handle ]
[ in>> <reader> ]
} cleave r> <decoder>
] with-destructors ;
: <process-reader> ( desc encoding -- stream )
<process-reader*> nip ; inline
: <process-writer*> ( process encoding -- process stream )
[
>r (pipe) {
[ add-error-destructor ]
[
swap >process
[ swap in>> or ] change-stdout
run-detached
]
[ in>> close-handle ]
[ out>> <writer> ]
} cleave r> <encoder>
] with-destructors ;
: <process-writer> ( desc encoding -- stream )
<process-writer*> nip ; inline
: <process-stream*> ( process encoding -- process stream )
[
>r (pipe) (pipe) {
[ [ add-error-destructor ] bi@ ]
[
rot >process
[ swap out>> or ] change-stdout
[ swap in>> or ] change-stdin
run-detached
]
[ [ in>> close-handle ] [ out>> close-handle ] bi* ]
[ [ in>> <reader> ] [ out>> <writer> ] bi* ]
} 2cleave r> <encoder-duplex>
] with-destructors ;
: <process-stream> ( desc encoding -- stream )
<process-stream*> drop ; inline
: with-process-stream ( desc quot -- status )
swap <process-stream*> >r
[ swap with-stream ] keep
r> wait-for-process ; inline
<process-stream*> nip ; inline
: notify-exit ( process status -- )
>>status
@ -168,9 +219,9 @@ HOOK: (process-stream) io-backend ( process -- handle in out )
GENERIC: underlying-handle ( stream -- handle )
M: port underlying-handle port-handle ;
M: port underlying-handle handle>> ;
M: duplex-stream underlying-handle
dup duplex-stream-in underlying-handle
swap duplex-stream-out underlying-handle tuck =
[ "Invalid duplex stream" throw ] when ;
[ in>> underlying-handle ]
[ out>> underlying-handle ] bi
[ = [ "Invalid duplex stream" throw ] when ] keep ;

6
extra/io/nonblocking/nonblocking.factor
View File

@ -1,9 +1,9 @@
! Copyright (C) 2005, 2008 Slava Pestov, Doug Coleman
! See http://factorcode.org/license.txt for BSD license.
USING: math kernel io sequences io.buffers io.timeouts generic
byte-vectors system io.streams.duplex io.encodings math.order
io.backend continuations debugger classes byte-arrays namespaces
splitting dlists assocs io.encodings.binary inspector accessors ;
byte-vectors system io.encodings math.order io.backend
continuations debugger classes byte-arrays namespaces splitting
dlists assocs io.encodings.binary inspector accessors ;
IN: io.nonblocking
SYMBOL: default-buffer-size

47
extra/io/pipes/pipes-docs.factor Normal file
View File

@ -0,0 +1,47 @@
USING: help.markup help.syntax continuations io ;
IN: io.pipes
HELP: pipe
{ $class-description "A low-level pipe. Instances are created by calling " { $link (pipe) } " and closed by calling " { $link dispose } "." } ;
HELP: (pipe)
{ $values { "pipe" pipe } }
{ $description "Opens a new pipe. This is a low-level word; the " { $link <pipe> } " and " { $link run-pipeline } " words can be used in most cases instead." } ;
HELP: <pipe>
{ $values { "encoding" "an encoding specifier" } { "stream" "a bidirectional stream" } }
{ $description "Opens a new pipe and wraps it in a stream. Data written from the stream can be read back from the same stream instance." }
{ $notes "Pipe streams must be disposed by calling " { $link dispose } " or " { $link with-disposal } " to avoid resource leaks." } ;
HELP: run-pipeline
{ $values { "seq" "a sequence of pipeline components" } { "results" "a sequence of pipeline results" } }
{ $description
"Creates a pipe between each pipeline component, with the output of each component becoming the input of the next."
$nl
"The first component reads input from " { $link input-stream } " and the last component writes output to " { $link output-stream } "."
$nl
"Each component runs in its own thread, and the word returns when all components finish executing. Each component outputs a result value."
$nl
"Pipeline components must be one of the following:"
{ $list
{ "A quotation. The quotation is called with both " { $link input-stream } " and " { $link output-stream } " rebound, except for the first and last pipeline components, and it must output a single value." }
{ "A process launch descriptor. See " { $link "io.launcher.descriptors" } "." }
}
}
{ $examples
"Print the lines of a log file which contain the string ``error'', sort them and filter out duplicates, using Unix shell commands only:"
{ $code "{ \"cat log.txt\" \"grep error\" \"sort\" \"uniq\" } run-pipeline" }
} ;
ARTICLE: "io.pipes" "Pipes"
"A " { $emphasis "pipe" } " is a unidirectional channel for transfer of bytes. Data written to one end of the pipe can be read from the other. Pipes can be used to pass data between processes; they can also be used within a single process to implement communication between coroutines."
$nl
"Low-level pipes:"
{ $subsection pipe }
{ $subsection (pipe) }
"High-level pipe streams:"
{ $subsection <pipe> }
"Pipelines of coroutines and processes:"
{ $subsection run-pipeline } ;
ABOUT: "io.pipes"

26
extra/io/pipes/pipes-tests.factor Normal file
View File

@ -0,0 +1,26 @@
USING: io io.pipes io.streams.string io.encodings.utf8
io.streams.duplex io.encodings namespaces continuations
tools.test kernel ;
IN: io.pipes.tests
[ "Hello" ] [
utf8 <pipe> [
"Hello" print flush
readln
] with-stream
] unit-test
[ { } ] [ { } run-pipeline ] unit-test
[ { f } ] [ { [ f ] } run-pipeline ] unit-test
[ { "Hello" } ] [
"Hello" [
{ [ input-stream [ utf8 <decoder> ] change readln ] } with-pipeline
] with-string-reader
] unit-test
[ { f "Hello" } ] [
{
[ output-stream [ utf8 <encoder> ] change "Hello" print flush f ]
[ input-stream [ utf8 <decoder> ] change readln ]
} run-pipeline
] unit-test

56
extra/io/pipes/pipes.factor Normal file
View File

@ -0,0 +1,56 @@
! Copyright (C) 2008 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
USING: io.encodings io.backend io.nonblocking io.streams.duplex
io splitting sequences sequences.lib namespaces kernel
destructors math concurrency.combinators accessors
arrays continuations quotations ;
IN: io.pipes
TUPLE: pipe in out ;
M: pipe dispose ( pipe -- )
[ in>> close-handle ] [ out>> close-handle ] bi ;
HOOK: (pipe) io-backend ( -- pipe )
: <pipe> ( encoding -- stream )
[
>r (pipe)
[ add-error-destructor ]
[ in>> <reader> ]
[ out>> <writer> ]
tri
r> <encoder-duplex>
] with-destructors ;
: with-fds ( input-fd output-fd quot -- )
>r >r [ <reader> dup add-always-destructor ] [ input-stream get ] if* r> r> [
>r [ <writer> dup add-always-destructor ] [ output-stream get ] if* r>
with-output-stream*
] 2curry with-input-stream* ; inline
: <pipes> ( n -- pipes )
[ (pipe) dup add-always-destructor ] replicate
f f pipe boa [ prefix ] [ suffix ] bi
2 <clumps> ;
: with-pipe-fds ( seq -- results )
[
[ length dup zero? [ drop { } ] [ 1- <pipes> ] if ] keep
[ >r [ first in>> ] [ second out>> ] bi r> 2curry ] 2map
[ call ] parallel-map
] with-destructors ;
GENERIC: pipeline-element-quot ( obj -- quot )
M: callable pipeline-element-quot
[ with-fds ] curry ;
GENERIC: wait-for-pipeline-element ( obj -- result )
M: object wait-for-pipeline-element ;
: run-pipeline ( seq -- results )
[ pipeline-element-quot ] map
with-pipe-fds
[ wait-for-pipeline-element ] map ;

4
extra/io/server/server-docs.factor
View File

@ -3,8 +3,8 @@ IN: io.server
HELP: with-server
{ $values { "seq" "a sequence of address specifiers" } { "service" "a string or " { $link f } } { "encoding" "an encoding to use for client connections" } { "quot" "a quotation" } }
{ $description "Starts a TCP/IP server. The quotation is called in a new thread for each client connection, with the client connection being the " { $link stdio } " stream. Client connections are logged to the " { $link stdio } " stream at the time the server was started." } ;
{ $description "Starts a TCP/IP server. The quotation is called in a new thread for each client connection, with the client connection being both the " { $link input-stream } " and " { $link output-stream } "." } ;
HELP: with-datagrams
{ $values { "seq" "a sequence of address specifiers" } { "service" "a string or " { $link f } } { "quot" "a quotation" } }
{ $description "Starts a UDP/IP server. The quotation is called for each datagram packet received. Datagram packets are logged to the " { $link stdio } " stream at the time the server was started." } ;
{ $description "Starts a UDP/IP server. The quotation is called for each datagram packet received." } ;

6
extra/io/server/server.factor
View File

@ -1,8 +1,8 @@
! Copyright (C) 2003, 2008 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
USING: io io.sockets io.files logging continuations kernel
math math.parser namespaces parser sequences strings
prettyprint debugger quotations calendar
USING: io io.sockets io.files io.streams.duplex logging
continuations kernel math math.parser namespaces parser
sequences strings prettyprint debugger quotations calendar
threads concurrency.combinators assocs ;
IN: io.server

1
extra/io/sockets/sockets-docs.factor
View File

@ -14,6 +14,7 @@ ARTICLE: "network-addressing" "Address specifiers"
ARTICLE: "network-connection" "Connection-oriented networking"
"Network connections can be established with this word:"
{ $subsection <client> }
{ $subsection with-client }
"Connection-oriented network servers are implemented by first opening a server socket, then waiting for connections:"
{ $subsection <server> }
{ $subsection accept }

6
extra/io/sockets/sockets.factor
View File

@ -1,7 +1,8 @@
! Copyright (C) 2007, 2008 Slava Pestov, Daniel Ehrenberg.
! See http://factorcode.org/license.txt for BSD license.
USING: generic kernel io.backend namespaces continuations
sequences arrays io.encodings io.nonblocking accessors ;
sequences arrays io.encodings io.nonblocking io.streams.duplex
accessors ;
IN: io.sockets
TUPLE: local path ;
@ -30,6 +31,9 @@ M: object (client) ((client)) ;
: <client> ( addrspec encoding -- stream )
>r (client) r> <encoder-duplex> ;
: with-client ( addrspec encoding quot -- )
>r <client> r> with-stream ; inline
HOOK: (server) io-backend ( addrspec -- handle )
: <server> ( addrspec encoding -- server )

1
extra/io/streams/duplex/authors.txt Normal file
View File

@ -0,0 +1 @@
Slava Pestov

39
extra/io/streams/duplex/duplex-docs.factor Executable file
View File

@ -0,0 +1,39 @@
USING: help.markup help.syntax io continuations quotations ;
IN: io.streams.duplex
ARTICLE: "io.streams.duplex" "Duplex streams"
"Duplex streams combine an input stream and an output stream into a bidirectional stream."
{ $subsection duplex-stream }
{ $subsection <duplex-stream> }
"A pair of combinators for rebinding both default streams at once:"
{ $subsection with-stream }
{ $subsection with-stream* } ;
ABOUT: "io.streams.duplex"
HELP: duplex-stream
{ $class-description "A bidirectional stream wrapping an input and output stream." } ;
HELP: <duplex-stream>
{ $values { "in" "an input stream" } { "out" "an output stream" } { "stream" " a duplex stream" } }
{ $description "Creates a duplex stream. Writing to a duplex stream will write to " { $snippet "out" } ", and reading from a duplex stream will read from " { $snippet "in" } ". Closing a duplex stream closes both the input and output streams." } ;
HELP: stream-closed-twice
{ $error-description "This error is thrown when performing an I/O operation on a " { $link duplex-stream } " which has been closed with " { $link dispose } "." } ;
HELP: with-stream
{ $values { "stream" duplex-stream } { "quot" quotation } }
{ $description "Calls the quotation in a new dynamic scope, with both " { $link input-stream } " and " { $link output-stream } " rebound to " { $snippet "stream" } ". The stream is closed if the quotation returns or throws an error." } ;
HELP: with-stream*
{ $values { "stream" duplex-stream } { "quot" quotation } }
{ $description "Calls the quotation in a new dynamic scope, with both " { $link input-stream } " and " { $link output-stream } " rebound to " { $snippet "stream" } "." }
{ $notes "This word does not close the stream. Compare with " { $link with-stream } "." } ;
HELP: <encoder-duplex>
{ $values { "stream-in" "an input stream" }
{ "stream-out" "an output stream" }
{ "encoding" "an encoding descriptor" }
{ "duplex" "an encoded duplex stream" } }
{ $description "Wraps the given streams in an encoder or decoder stream, and puts them together in a duplex stream for input and output. If either input stream is already encoded, that encoding is stripped off before it is reencoded. The encoding descriptor must conform to the " { $link "encodings-protocol" } "." }
$low-level-note ;

0
core/io/streams/duplex/duplex-tests.factor → extra/io/streams/duplex/duplex-tests.factor
View File

59
core/io/streams/duplex/duplex.factor → extra/io/streams/duplex/duplex.factor
View File

@ -1,6 +1,8 @@
! Copyright (C) 2005, 2008 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
USING: kernel continuations io accessors ;
USING: kernel continuations io io.encodings io.encodings.private
io.timeouts debugger inspector listener accessors delegate
delegate.protocols ;
IN: io.streams.duplex
! We ensure that the stream can only be closed once, to preserve
@ -13,6 +15,9 @@ TUPLE: duplex-stream in out closed ;
ERROR: stream-closed-twice ;
M: stream-closed-twice summary
drop "Attempt to perform I/O on closed stream" ;
<PRIVATE
: check-closed ( stream -- stream )
@ -24,47 +29,12 @@ ERROR: stream-closed-twice ;
PRIVATE>
M: duplex-stream stream-flush
out stream-flush ;
CONSULT: input-stream-protocol duplex-stream in ;
M: duplex-stream stream-readln
in stream-readln ;
CONSULT: output-stream-protocol duplex-stream out ;
M: duplex-stream stream-read1
in stream-read1 ;
M: duplex-stream stream-read-until
in stream-read-until ;
M: duplex-stream stream-read-partial
in stream-read-partial ;
M: duplex-stream stream-read
in stream-read ;
M: duplex-stream stream-write1
out stream-write1 ;
M: duplex-stream stream-write
out stream-write ;
M: duplex-stream stream-nl
out stream-nl ;
M: duplex-stream stream-format
out stream-format ;
M: duplex-stream make-span-stream
out make-span-stream ;
M: duplex-stream make-block-stream
out make-block-stream ;
M: duplex-stream make-cell-stream
out make-cell-stream ;
M: duplex-stream stream-write-table
out stream-write-table ;
M: duplex-stream set-timeout
[ in set-timeout ] [ out set-timeout ] 2bi ;
M: duplex-stream dispose
#! The output stream is closed first, in case both streams
@ -75,3 +45,12 @@ M: duplex-stream dispose
[ dup out>> dispose ]
[ dup in>> dispose ] [ ] cleanup
] unless drop ;
: <encoder-duplex> ( stream-in stream-out encoding -- duplex )
tuck reencode >r redecode r> <duplex-stream> ;
: with-stream* ( stream quot -- )
>r [ in>> ] [ out>> ] bi r> with-streams* ; inline
: with-stream ( stream quot -- )
>r [ in>> ] [ out>> ] bi r> with-streams ; inline

0
core/io/streams/duplex/summary.txt → extra/io/streams/duplex/summary.txt
View File

43
extra/io/streams/null/null.factor
View File

@ -1,25 +1,38 @@
! Copyright (C) 2007 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
IN: io.streams.null
USING: kernel io io.timeouts continuations ;
USING: kernel io io.timeouts io.streams.duplex continuations ;
TUPLE: null-stream ;
M: null-stream dispose drop ;
M: null-stream set-timeout 2drop ;
M: null-stream stream-readln drop f ;
M: null-stream stream-read1 drop f ;
M: null-stream stream-read-until 2drop f f ;
M: null-stream stream-read 2drop f ;
M: null-stream stream-write1 2drop ;
M: null-stream stream-write 2drop ;
M: null-stream stream-nl drop ;
M: null-stream stream-flush drop ;
M: null-stream stream-format 3drop ;
M: null-stream make-span-stream nip ;
M: null-stream make-block-stream nip ;
M: null-stream make-cell-stream nip ;
M: null-stream stream-write-table 3drop ;
TUPLE: null-reader < null-stream ;
M: null-reader stream-readln drop f ;
M: null-reader stream-read1 drop f ;
M: null-reader stream-read-until 2drop f f ;
M: null-reader stream-read 2drop f ;
TUPLE: null-writer < null-stream ;
M: null-writer stream-write1 2drop ;
M: null-writer stream-write 2drop ;
M: null-writer stream-nl drop ;
M: null-writer stream-flush drop ;
M: null-writer stream-format 3drop ;
M: null-writer make-span-stream nip ;
M: null-writer make-block-stream nip ;
M: null-writer make-cell-stream nip ;
M: null-writer stream-write-table 3drop ;
: with-null-reader ( quot -- )
T{ null-reader } swap with-input-stream* ; inline
: with-null-writer ( quot -- )
T{ null-writer } swap with-output-stream* ; inline
: with-null-stream ( quot -- )
T{ null-stream } swap with-stream* ; inline
T{ duplex-stream f T{ null-reader } T{ null-writer } }
swap with-stream* ; inline

16
extra/io/timeouts/timeouts.factor
View File

@ -1,20 +1,16 @@
! Copyright (C) 2008 Slava Pestov, Doug Coleman
! See http://factorcode.org/license.txt for BSD license.
USING: kernel calendar alarms io.streams.duplex io.encodings ;
USING: kernel calendar alarms io io.encodings accessors
namespaces ;
IN: io.timeouts
! Won't need this with new slot accessors
GENERIC: timeout ( obj -- dt/f )
GENERIC: set-timeout ( dt/f obj -- )
M: duplex-stream set-timeout
2dup
duplex-stream-in set-timeout
duplex-stream-out set-timeout ;
M: decoder set-timeout stream>> set-timeout ;
M: decoder set-timeout decoder-stream set-timeout ;
M: encoder set-timeout encoder-stream set-timeout ;
M: encoder set-timeout stream>> set-timeout ;
GENERIC: timed-out ( obj -- )
@ -29,3 +25,7 @@ M: object timed-out drop ;
] [
2drop call
] if ; inline
: timeouts ( dt -- )
[ input-stream get set-timeout ]
[ output-stream get set-timeout ] bi ;

11
extra/io/unix/backend/backend.factor
View File

@ -1,10 +1,10 @@
! Copyright (C) 2004, 2008 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
USING: alien generic assocs kernel kernel.private math
io.nonblocking sequences strings structs sbufs
threads unix vectors io.buffers io.backend io.encodings
io.streams.duplex math.parser continuations system libc
qualified namespaces io.timeouts io.encodings.utf8 accessors ;
io.nonblocking sequences strings structs sbufs threads unix
vectors io.buffers io.backend io.encodings math.parser
continuations system libc qualified namespaces io.timeouts
io.encodings.utf8 accessors ;
QUALIFIED: io
IN: io.unix.backend
@ -78,7 +78,8 @@ M: integer init-handle ( fd -- )
#! since on OS X 10.3, this operation fails from init-io
#! when running the Factor.app (presumably because fd 0 and
#! 1 are closed).
F_SETFL O_NONBLOCK fcntl drop ;
[ F_SETFL O_NONBLOCK fcntl drop ]
[ F_SETFD FD_CLOEXEC fcntl drop ] bi ;
M: integer close-handle ( fd -- )
close ;

31
extra/io/unix/launcher/launcher-tests.factor
View File

@ -31,16 +31,7 @@ accessors kernel sequences io.encodings.utf8 ;
"cat"
"launcher-test-1" temp-file
2array
ascii <process-stream> contents
] unit-test
[ f ] [
<process>
"cat"
"launcher-test-1" temp-file
2array >>command
+inherit+ >>stdout
ascii <process-stream> contents
ascii <process-reader> contents
] unit-test
[ ] [
@ -59,7 +50,7 @@ accessors kernel sequences io.encodings.utf8 ;
"cat"
"launcher-test-1" temp-file
2array
ascii <process-stream> contents
ascii <process-reader> contents
] unit-test
[ ] [
@ -77,14 +68,14 @@ accessors kernel sequences io.encodings.utf8 ;
"cat"
"launcher-test-1" temp-file
2array
ascii <process-stream> contents
ascii <process-reader> contents
] unit-test
[ t ] [
<process>
"env" >>command
{ { "A" "B" } } >>environment
ascii <process-stream> lines
ascii <process-reader> lines
"A=B" swap member?
] unit-test
@ -93,7 +84,7 @@ accessors kernel sequences io.encodings.utf8 ;
"env" >>command
{ { "A" "B" } } >>environment
+replace-environment+ >>environment-mode
ascii <process-stream> lines
ascii <process-reader> lines
] unit-test
[ "hi\n" ] [
@ -107,3 +98,15 @@ accessors kernel sequences io.encodings.utf8 ;
temp-directory "aloha" append-path
utf8 file-contents
] unit-test
[ ] [ "append-test" temp-file delete-file ] unit-test
[ "hi\nhi\n" ] [
2 [
<process>
"echo hi" >>command
"append-test" temp-file <appender> >>stdout
try-process
] times
"append-test" temp-file utf8 file-contents
] unit-test

Some files were not shown because too many files have changed in this diff Show More