[ "/lib/bux" ] [ "/usr" "/lib/bux" append-path ] unit-test
[ "/lib/bux/" ] [ "/usr" "/lib/bux/" append-path ] unit-test
-[ "foo/" ] [ "foo/bar/." parent-directory ] unit-test
-[ "foo/" ] [ "foo/bar/./" parent-directory ] unit-test
-[ "foo/" ] [ "foo/bar/baz/.." parent-directory ] unit-test
-[ "foo/" ] [ "foo/bar/baz/../" parent-directory ] unit-test
+[ "foo/bar/." parent-directory ] must-fail
+[ "foo/bar/./" parent-directory ] must-fail
+[ "foo/bar/baz/.." parent-directory ] must-fail
+[ "foo/bar/baz/../" parent-directory ] must-fail
[ "." parent-directory ] must-fail
[ "./" parent-directory ] must-fail
[ "../../" parent-directory ] must-fail
[ "foo/.." parent-directory ] must-fail
[ "foo/../" parent-directory ] must-fail
+[ "" parent-directory ] must-fail
+[ "." ] [ "boot.x86.64.image" parent-directory ] unit-test
[ "bar/foo" ] [ "bar/baz" "..///foo" append-path ] unit-test
[ "bar/baz/foo" ] [ "bar/baz" ".///foo" append-path ] unit-test
right-trim-separators
dup last-path-separator [
1+ cut
- {
- { "." [ 1 head* parent-directory ] }
- { ".." [
- 2 head* parent-directory parent-directory
- ] }
- [ drop ]
- } case
- ] [ no-parent-directory ] if
+ ] [
+ drop "." swap
+ ] if
+ { "" "." ".." } member? [
+ no-parent-directory
+ ] when
] unless ;
<PRIVATE
SYMBOL: current-directory
+M: object cwd ( -- path ) "." ;
+
[ cwd current-directory set-global ] "current-directory" add-init-hook
: with-directory ( path quot -- )
prepend-path ;
: ?resource-path ( path -- newpath )
- "resource:" ?head [ resource-path ] when ;
+ "resource:" ?head [ left-trim-separators resource-path ] when ;
: resource-exists? ( path -- ? )
?resource-path exists? ;
SYMBOL: +normal-priority+
SYMBOL: +high-priority+
SYMBOL: +highest-priority+
+SYMBOL: +realtime-priority+
: <process> ( -- process )
process construct-empty
[ "/" ] [ "/etc/" parent-directory ] unit-test
[ "/" ] [ "/etc" parent-directory ] unit-test
[ "/" ] [ "/" parent-directory ] unit-test
-[ "asdf" parent-directory ] must-fail
[ f ] [ "" root-directory? ] unit-test
[ t ] [ "/" root-directory? ] unit-test
{ +normal-priority+ 0 }
{ +high-priority+ -10 }
{ +highest-priority+ -20 }
+ { +realtime-priority+ -20 }
} at set-priority
] when* ;
: join-arguments ( args -- cmd-line )
[ escape-argument ] map " " join ;
+: lookup-priority ( process -- n )
+ priority>> {
+ { +lowest-priority+ [ IDLE_PRIORITY_CLASS ] }
+ { +low-priority+ [ BELOW_NORMAL_PRIORITY_CLASS ] }
+ { +normal-priority+ [ NORMAL_PRIORITY_CLASS ] }
+ { +high-priority+ [ ABOVE_NORMAL_PRIORITY_CLASS ] }
+ { +highest-priority+ [ HIGH_PRIORITY_CLASS ] }
+ { +realtime-priority+ [ REALTIME_PRIORITY_CLASS ] }
+ [ drop f ]
+ } case ;
+
: app-name/cmd-line ( process -- app-name cmd-line )
command>> dup string? [
" " split1
0
pick pass-environment? [ CREATE_UNICODE_ENVIRONMENT bitor ] when
pick detached>> winnt? and [ DETACHED_PROCESS bitor ] when
+ pick lookup-priority [ bitor ] when*
>>dwCreateFlags ;
: fill-lpEnvironment ( process args -- process args )
! Copyright (C) 2008 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
-USING: kernel math sequences vectors classes combinators
-arrays words assocs parser namespaces definitions
+USING: kernel math sequences vectors classes classes.algebra
+combinators arrays words assocs parser namespaces definitions
prettyprint prettyprint.backend quotations arrays.lib
debugger io compiler.units kernel.private effects ;
IN: multi-methods
--- /dev/null
+
+USING: help.syntax help.markup ;
+
+IN: openssl
+
+ARTICLE: "openssl" "OpenSSL"
+
+"Factor on Windows has been tested with this version of OpenSSL: "
+
+{ $url "http://www.openssl.org/related/binaries.html" } ;
\ No newline at end of file
USING: kernel compiler.units parser words arrays strings math.parser sequences \r
quotations vectors namespaces math assocs continuations peg\r
peg.parsers unicode.categories multiline combinators.lib \r
- splitting ;\r
+ splitting accessors ;\r
IN: peg.ebnf\r
\r
TUPLE: ebnf-non-terminal symbol ;\r
TUPLE: ebnf-sequence elements ;\r
TUPLE: ebnf-repeat0 group ;\r
TUPLE: ebnf-repeat1 group ;\r
-TUPLE: ebnf-optional elements ;\r
+TUPLE: ebnf-optional group ;\r
TUPLE: ebnf-rule symbol elements ;\r
TUPLE: ebnf-action parser code ;\r
TUPLE: ebnf rules ;\r
\r
: 'rule' ( -- parser )\r
[\r
- 'non-terminal' [ ebnf-non-terminal-symbol ] action ,\r
+ 'non-terminal' [ symbol>> ] action ,\r
"=" syntax ,\r
'choice' ,\r
] seq* [ first2 <ebnf-rule> ] action ;\r
H{ } clone dup dup [ parser set swap (transform) main set ] bind ;\r
\r
M: ebnf (transform) ( ast -- parser )\r
- ebnf-rules [ (transform) ] map peek ;\r
+ rules>> [ (transform) ] map peek ;\r
\r
M: ebnf-rule (transform) ( ast -- parser )\r
- dup ebnf-rule-elements (transform) [\r
- swap ebnf-rule-symbol set\r
+ dup elements>> (transform) [\r
+ swap symbol>> set\r
] keep ;\r
\r
M: ebnf-sequence (transform) ( ast -- parser )\r
- ebnf-sequence-elements [ (transform) ] map seq ;\r
+ elements>> [ (transform) ] map seq ;\r
\r
M: ebnf-choice (transform) ( ast -- parser )\r
- ebnf-choice-options [ (transform) ] map choice ;\r
+ options>> [ (transform) ] map choice ;\r
\r
M: ebnf-any-character (transform) ( ast -- parser )\r
drop any-char ;\r
\r
M: ebnf-range (transform) ( ast -- parser )\r
- ebnf-range-pattern range-pattern ;\r
+ pattern>> range-pattern ;\r
+\r
+: transform-group ( ast -- parser ) \r
+ #! convert a ast node with groups to a parser for that group\r
+ group>> (transform) ;\r
\r
M: ebnf-ensure (transform) ( ast -- parser )\r
- ebnf-ensure-group (transform) ensure ;\r
+ transform-group ensure ;\r
\r
M: ebnf-ensure-not (transform) ( ast -- parser )\r
- ebnf-ensure-not-group (transform) ensure-not ;\r
+ transform-group ensure-not ;\r
\r
M: ebnf-repeat0 (transform) ( ast -- parser )\r
- ebnf-repeat0-group (transform) repeat0 ;\r
+ transform-group repeat0 ;\r
\r
M: ebnf-repeat1 (transform) ( ast -- parser )\r
- ebnf-repeat1-group (transform) repeat1 ;\r
+ transform-group repeat1 ;\r
\r
M: ebnf-optional (transform) ( ast -- parser )\r
- ebnf-optional-elements (transform) optional ;\r
+ transform-group optional ;\r
\r
M: ebnf-action (transform) ( ast -- parser )\r
- [ ebnf-action-parser (transform) ] keep\r
- ebnf-action-code string-lines [ parse-lines ] with-compilation-unit action ;\r
+ [ parser>> (transform) ] keep\r
+ code>> string-lines [ parse-lines ] with-compilation-unit action ;\r
\r
M: ebnf-terminal (transform) ( ast -- parser )\r
- ebnf-terminal-symbol token sp ;\r
+ symbol>> token sp ;\r
\r
M: ebnf-non-terminal (transform) ( ast -- parser )\r
- ebnf-non-terminal-symbol [\r
+ symbol>> [\r
, parser get , \ at , \r
] [ ] make delay sp ;\r
\r
USING: kernel sequences strings namespaces math assocs shuffle
vectors arrays combinators.lib math.parser match
unicode.categories sequences.lib compiler.units parser
- words quotations effects memoize ;
+ words quotations effects memoize accessors combinators.cleave ;
IN: peg
TUPLE: parse-result remaining ast ;
] if ;
M: token-parser (compile) ( parser -- quot )
- token-parser-symbol [ parse-token ] curry ;
+ symbol>> [ parse-token ] curry ;
TUPLE: satisfy-parser quot ;
] ;
M: satisfy-parser (compile) ( parser -- quot )
- satisfy-parser-quot \ ?quot satisfy-pattern match-replace ;
+ quot>> \ ?quot satisfy-pattern match-replace ;
TUPLE: range-parser min max ;
: seq-pattern ( -- quot )
[
dup [
- dup parse-result-remaining ?quot [
- [ parse-result-remaining swap set-parse-result-remaining ] 2keep
- parse-result-ast dup ignore = [
+ dup remaining>> ?quot [
+ [ remaining>> swap (>>remaining) ] 2keep
+ ast>> dup ignore = [
drop
] [
- swap [ parse-result-ast push ] keep
+ swap [ ast>> push ] keep
] if
] [
drop f
M: seq-parser (compile) ( parser -- quot )
[
[ V{ } clone <parse-result> ] %
- seq-parser-parsers [ compiled-parser \ ?quot seq-pattern match-replace % ] each
+ parsers>> [ compiled-parser \ ?quot seq-pattern match-replace % ] each
] [ ] make ;
TUPLE: choice-parser parsers ;
M: choice-parser (compile) ( parser -- quot )
[
f ,
- choice-parser-parsers [ compiled-parser \ ?quot choice-pattern match-replace % ] each
+ parsers>> [ compiled-parser \ ?quot choice-pattern match-replace % ] each
\ nip ,
] [ ] make ;
TUPLE: repeat0-parser p1 ;
: (repeat0) ( quot result -- result )
- 2dup parse-result-remaining swap call [
- [ parse-result-remaining swap set-parse-result-remaining ] 2keep
- parse-result-ast swap [ parse-result-ast push ] keep
+ 2dup remaining>> swap call [
+ [ remaining>> swap (>>remaining) ] 2keep
+ ast>> swap [ ast>> push ] keep
(repeat0)
] [
nip
M: repeat0-parser (compile) ( parser -- quot )
[
[ V{ } clone <parse-result> ] %
- repeat0-parser-p1 compiled-parser \ ?quot repeat0-pattern match-replace %
+ p1>> compiled-parser \ ?quot repeat0-pattern match-replace %
] [ ] make ;
TUPLE: repeat1-parser p1 ;
: repeat1-pattern ( -- quot )
[
[ ?quot ] swap (repeat0) [
- dup parse-result-ast empty? [
+ dup ast>> empty? [
drop f
] when
] [
M: repeat1-parser (compile) ( parser -- quot )
[
[ V{ } clone <parse-result> ] %
- repeat1-parser-p1 compiled-parser \ ?quot repeat1-pattern match-replace %
+ p1>> compiled-parser \ ?quot repeat1-pattern match-replace %
] [ ] make ;
TUPLE: optional-parser p1 ;
] ;
M: optional-parser (compile) ( parser -- quot )
- optional-parser-p1 compiled-parser \ ?quot optional-pattern match-replace ;
+ p1>> compiled-parser \ ?quot optional-pattern match-replace ;
TUPLE: ensure-parser p1 ;
] ;
M: ensure-parser (compile) ( parser -- quot )
- ensure-parser-p1 compiled-parser \ ?quot ensure-pattern match-replace ;
+ p1>> compiled-parser \ ?quot ensure-pattern match-replace ;
TUPLE: ensure-not-parser p1 ;
] ;
M: ensure-not-parser (compile) ( parser -- quot )
- ensure-not-parser-p1 compiled-parser \ ?quot ensure-not-pattern match-replace ;
+ p1>> compiled-parser \ ?quot ensure-not-pattern match-replace ;
TUPLE: action-parser p1 quot ;
: action-pattern ( -- quot )
[
?quot dup [
- dup parse-result-ast ?action call
- swap [ set-parse-result-ast ] keep
+ dup ast>> ?action call
+ >>ast
] when
] ;
M: action-parser (compile) ( parser -- quot )
- { action-parser-p1 action-parser-quot } get-slots [ compiled-parser ] dip
+ { [ p1>> ] [ quot>> ] } cleave [ compiled-parser ] dip
2array { ?quot ?action } action-pattern match-replace ;
: left-trim-slice ( string -- string )
M: sp-parser (compile) ( parser -- quot )
[
- \ left-trim-slice , sp-parser-p1 compiled-parser ,
+ \ left-trim-slice , p1>> compiled-parser ,
] [ ] make ;
TUPLE: delay-parser quot ;
#! This way it is run only once and the
#! parser constructed once at run time.
[
- delay-parser-quot % \ compile ,
+ quot>> % \ compile ,
] [ ] make
{ } { "word" } <effect> memoize-quot
[ % \ execute , ] [ ] make ;
swap >>command
+stdout+ >>stderr
+closed+ >>stdin
+ +low-priority+ >>priority
utf8 <process-stream>
dup copy-lines
process>> wait-for-process zero? [
} at ;
: ttf-path ( name -- string )
- "/fonts/" swap ".ttf" 3append resource-path ;
+ "resource:fonts/" swap ".ttf" 3append ?resource-path ;
: (open-face) ( path length -- face )
#! We use FT_New_Memory_Face, not FT_New_Face, since
: OF_REOPEN 32768 ;
: OF_VERIFY 1024 ;
-
: INFINITE HEX: FFFFFFFF ; inline
! From C:\cygwin\usr\include\w32api\winbase.h