*Adr
- A global variable holding the IP address of last recently accepted client.
See also
listen
and accept
.
: *Adr
-> "127.0.0.1"
*Allow
- A global variable holding allowed access patterns. If its value is
non-
NIL
, it should contain a list where the CAR is an idx
tree of allowed items, and the CDR a list of
prefix strings. See also allow
,
allowed
and pre?
.
: (allowed ("app/" "img/") # Initialize
"@start" "@stop" "favicon.ico" "lib.css" "@psh" )
-> NIL
: (allow "@myFoo") # additional item
-> "@myFoo"
: (allow "myDir/" T) # additional prefix
-> "myDir/"
: *Allow
-> (("@stop" ("@psh" ("@myFoo") "@start") "favicon.ico" NIL "lib.css") "app/" "img/" "myDir/")
: (idx *Allow) # items
-> ("@myFoo" "@psh" "@start" "@stop" "favicon.ico" "lib.css")
: (cdr *Allow) # prefixes
-> ("app/" "img/" "myDir/")
(abs 'num) -> num
- Returns the absolute value of the
num
argument.
: (abs -7)
-> 7
: (abs 7)
-> 7
(accept 'cnt) -> cnt | NIL
- Accepts a connection on descriptor
cnt
(as received by port
), and returns the new socket descriptor
cnt
. The global variable *Adr
is set to the IP address
of the client. See also listen
,
connect
and *Adr
.
: (setq *Socket
(accept (port 6789)) ) # Accept connection at port 6789
-> 4
(accu 'var 'any 'num)
- Accumulates
num
into a sum, using the key any
in
an association list stored in var
. See also assoc
.
: (off Sum)
-> NIL
: (accu 'Sum 'a 1)
-> (a . 1)
: (accu 'Sum 'a 5)
-> 6
: (accu 'Sum 22 100)
-> (22 . 100)
: Sum
-> ((22 . 100) (a . 6))
(align 'cnt 'any) -> sym
(align 'lst 'any ..) -> sym
- Returns a transient symbol with all
any
arguments pack
ed in an aligned format. In the first form,
any
will be left-aligned if cnt
ist negative,
otherwise right-aligned. In the second form, all any
arguments are
packed according to the numbers in lst
. See also tab
, center
and wrap
.
: (align 4 "a")
-> " a"
: (align -4 12)
-> "12 "
: (align (4 4 4) "a" 12 "b")
-> " a 12 b"
(all 'fun) -> any
- Applies
fun
to all internal symbols in the system. Returns the
result of the last application.
: (all printsp) # Print the names of all internal symbols
delWord +PwField +Fmt tail char cons month ..
.. conc cond -> cond
# Find all symbols starting with an underscore character
: (make (all '((X) (and (= "_" (car (chop X))) (link X)))))
-> (_ed _isa _delL _delR _dbg _del _query _scan _hex _boxSend _put)
(allow 'sym ['flg]) -> sym
- Maintains an index structure of allowed access patterns in the global
variable
*Allow
. If the value of
*Allow
is non-NIL
, sym
is added to the
idx
tree in the CAR of
*Allow
(if flg
is NIL
), or to the list of
prefix strings (if flg
is non-NIL
). See also allowed
.
: *Allow
-> (("@stop" ("@psh" NIL "@start") "favicon.ico" NIL "lib.css") "app/" "img/")
: (allow "@myFoo") # additionally allowed item
-> "@myFoo"
: (allow "myDir/" T) # additionally allowed prefix
-> "myDir/"
(allowed lst [sym ..])
- Creates an index structure of allowed access patterns in the global variable
*Allow
. lst
should
consist of prefix strings (to be checked at runtime with pre?
), and the sym
arguments
should specify the initially allowed items. See also allow
.
: (allowed ("app/" "img/") # allowed prefixes
"@start" "@stop" "favicon.ico" "lib.css" "@psh" ) # allowed items
-> NIL
(and 'any ..) -> any
- Logical AND. The expressions
any
are evaluated from left to
right. If NIL
is encountered, NIL
is returned
immediately. Else the result of the last expression is returned.
: (and (= 3 3) (read))
abc # User input
-> abc
: (and (= 3 4) (read))
-> NIL
(any 'sym) -> any
- Parses
any
from the name of sym
. See also sym
and str
.
: (any "(a b # Comment^Jc d)")
-> (a b c d)
: (any "\"A String\"")
-> "A String"
(append 'lst ..) -> lst
- Appends all argument lists. See also
conc
, insert
, delete
and remove
.
: (append '(a b c) (1 2 3))
-> (a b c 1 2 3)
: (append (1) (2) (3) 4)
-> (1 2 3 . 4)
(apply 'fun 'lst ['any ..]) -> any
- Applies
fun
to lst
. If additional any
arguments are given, they are applied as leading elements of lst
.
: (apply + (1 2 3))
-> 6
: (apply * (5 6) 3 4)
-> 360
: (apply '((X Y Z) (* X (+ Y Z))) (3 4 5))
-> 27
(arg ['cnt]) -> any
- Can only be used inside functions with a variable number of arguments (with
@
). If cnt
is not given, the value that was returned
from the last call to next
) is returned. Otherwise, the
cnt
'th remaining argument is returned. See also args
, next
, rest
and pass
.
: (de foo @ (println (next) (arg))) # Print argument twice
-> foo
: (foo 123)
123 123
-> 123
: (de foo @
(println (arg 1) (arg 2))
(println (next))
(println (arg 1) (arg 2)) )
-> foo
: (foo 'a 'b 'c)
a b
a
b c
-> c
(args) -> flg
- Can only be used inside functions with a variable number of arguments (with
@
). Returns T
when there are more arguments to be
fetched from the internal list. See also next
, arg
, rest
and pass
.
: (de foo @ (println (args))) # Test for arguments
-> foo
: (foo) # No arguments
NIL
-> NIL
: (foo NIL) # One argument
T
-> T
: (foo 123) # One argument
T
-> T
(argv [sym ..] [. sym]) -> lst|sym
- If called without arguments,
argv
returns a list of strings
containing all remaining command line arguments. Otherwise, the sym
arguments are subsequently bound to the command line arguments. A hyphen
"-
" can be used to stop load
ing further arguments. See
also Invocation
and opt
.
$ ./p -"println 'Ok" - abc 123
Ok
: (argv)
-> ("abc" "123")
: (argv A B)
-> "123"
: A
-> "abc"
: B
-> "123"
: (argv . Lst)
-> ("abc" "123")
: Lst
-> ("abc" "123")
(as 'any1 . any2) -> any2 | NIL
- Returns
any2
unevaluated when any1
evaluates to
non-NIL
. Otherwise NIL
is returned. (as Flg A B
C)
is equivalent to (and Flg '(A B C))
. See also quote
.
: (as (= 3 3) A B C)
-> (A B C)
(asoq 'any 'lst) -> lst
- Searches an association list. Returns the first element from
lst
with any
as its CAR
, or
NIL
if no match is found. ==
is used for comparison (pointer equality). See
also assoc
, delq
, memq
and mmeq
.
: (asoq 999 '((999 1 2 3) (b . 7) ("ok" "Hello")))
-> NIL
: (asoq 'b '((999 1 2 3) (b . 7) ("ok" "Hello")))
-> (b . 7)
(assoc 'any 'lst) -> lst
- Searches an association list. Returns the first element from
lst
with its CAR
equal to any
, or
NIL
if no match is found.
: (assoc "b" '((999 1 2 3) ("b" . 7) ("ok" "Hello")))
-> ("b" . 7)
: (assoc 999 '((999 1 2 3) ("b" . 7) ("ok" "Hello")))
-> (999 1 2 3)
: (assoc 'u '((999 1 2 3) ("b" . 7) ("ok" "Hello")))
-> NIL
(at '(cnt1 . cnt2) . prg) -> any
- Increments
cnt1
(destructively), and returns NIL
when it is less than cnt2
. Otherwise, prg
is executed
and cnt1
is reset to zero. Returns the result of prg
.
: (do 11 (prin ".") (at (0 . 3) (prin "!")))
...!...!...!..-> NIL
(atom 'any) -> flg
- Returns
T
when the argument any
is an atom (a
number or a symbol). See also pair
.
: (atom 123)
-> T
: (atom 'a)
-> T
: (atom NIL)
-> T
: (atom (123))
-> NIL
(aux 'var 'cls ['hook] 'any ..) -> sym
- Returns a database object of class
cls
, where the value for
var
corresponds to any
and the following arguments.
var
, cls
and hook
should specify a
tree
for cls
or one of
its superclasses, for a relation with auxiliary keys. aux
is simlar
to - but faster than - db
, because it can use a single tree access.
See also db
, collect
, fetch
, init
and step
.
(class +PS +Entity)
(rel par (+Dep +Joint) (sup) ps (+Part)) # Part
(rel sup (+Aux +Ref +Link) (par) NIL (+Supp))# Supplier
...
(aux 'sup '+PS # Access PS object
(db 'nr '+Supp 1234)
(db 'nr '+Part 5678) )