*Scl
- A global variable holding the current fixed-point input scale. See also Numbers and
scl
.
: (str "123.45") # Default value of '*Scl' is 0
-> (123)
: (setq *Scl 3)
-> 3
: (str "123.45")
-> (123450)
*Sig1
*Sig2
- Global variables holding (possibly empty)
prg
bodies, which
will be executed when a SIGUSR1 signal (or a SIGUSR2 signal, respectively) is
sent to the current process. Note that this mechanism is "unreliable", in the
way that when a second signal (it may be SIGHUP, SIGINT, another SIGUSR1/2,
SIGALRM or SIGTERM) arrives before the first signal's prg
is
running, the first signal will be lost. See also alarm
, *Run
, *Hup
and *Err
.
: (de *Sig1 (msg 'SIGUSR1))
-> *Sig1
*Solo
- A global variable indicating exclusive database access. Its value is
0
initially, set to T
(or NIL
) during
cooperative database locks when lock
is successfully called with a NIL
(or non-NIL
)
argument. See also *Zap
.
: *Solo
-> 0
: (lock *DB)
-> NIL
: *Solo
-> NIL
: (rollback)
-> T
: *Solo
-> 0
: (lock)
-> NIL
: *Solo
-> T
: (rollback)
-> T
: *Solo
-> T
(scan 'tree ['fun] ['any1] ['any2] ['flg])
- Scans through a database tree by applying
fun
to all key-value
pairs. fun
should be a function accepting two arguments for key and
value. It defaults to println
.
any1
and any2
may specify a range of keys. If
any2
is greater than any1
, the traversal will be in
opposite direction. If flg
is non-NIL
, partial keys
are skipped. See also tree
, iter
, init
and step
.
: (scan (tree 'nm '+Item))
("ASLRSNSTRSTN" {3-3} . T) {3-3}
("Additive" {3-4}) {3-4}
("Appliance" {3-6}) {3-6}
("Auxiliary Construction" . {3-3}) {3-3}
("Construction" {3-3}) {3-3}
("ENNSNNTTTF" {3-4} . T) {3-4}
("Enhancement Additive" . {3-4}) {3-4}
("Fittings" {3-5}) {3-5}
("GTSTFLNS" {3-6} . T) {3-6}
("Gadget Appliance" . {3-6}) {3-6}
...
: (scan (tree 'nm '+Item) println NIL T T) # 'flg' is non-NIL
("Auxiliary Construction" . {3-3}) {3-3}
("Enhancement Additive" . {3-4}) {3-4}
("Gadget Appliance" . {3-6}) {3-6}
("Main Part" . {3-1}) {3-1}
("Metal Fittings" . {3-5}) {3-5}
("Spare Part" . {3-2}) {3-2}
("Testartikel" . {3-8}) {3-8}
-> {7-6}
(scl 'num . prg) -> any
- Binds
*Scl
dynamically to
num
during the execution of prg
. See also Numbers.
: (scl 0 (str "123.45"))
-> (123)
: (scl 1 (read))
123.45
-> 1235
: (scl 3 (str "123.45"))
-> (123450)
(script 'any ..) -> any
- The first
any
argument is load
ed, with the remaining arguments pass
ed as variable arguments. They can be
accessed with next
, arg
, args
and rest
.
$ cat x
(* (next) (next))
$ ./p dbg.l
: (script "x" 3 4)
-> 12
(sect 'lst 'lst) -> lst
- Returns the intersection of the
lst
arguments. See also
diff
.
: (sect (1 2 3 4) (3 4 5 6))
-> (3 4)
: (sect (1 2 3) (4 5 6))
-> NIL
(seed 'any) -> cnt
- Initializes the random generator's seed, and returns a pseudo random number
in the range -2147483648 .. +2147483647. See also
rand
.
: (seed "init string")
-> 2015582081
: (rand)
-> -706917003
: (rand)
-> 1224196082
: (seed (time))
-> 128285383
(seek 'fun 'lst ..) -> lst
- Applies
fun
to lst
and all successive CDRs, until
non-NIL
is returned. Returns the tail of lst
starting
with that element, or NIL
if fun
did not return
non-NIL
for any element of lst
. When additional
lst
arguments are given, they are passed to fun
in the
same way. See also find
, pick
.
: (seek '((X) (> (car X) 9)) (1 5 8 12 19 22))
-> (12 19 22)
(send 'msg 'obj ['any ..]) -> any
- Sends the message
msg
to the object obj
,
optionally with arguments any
. If the message cannot be located in
obj
, its classes and superclasses, an error "Bad
message"
is issued. See also OO
Concepts
, try
, method
, meth
, super
and extra
.
: (send 'stop> Dlg) # Equivalent to (stop> Dlg)
-> NIL
(seq 'cnt|sym1 ['sym2 ['num]]) -> sym | num | NIL
- Sequential single step: Returns the first external symbol in the
cnt
'th database file, or the next external symbol following
sym1
in the database, or NIL
when the end of the
database is reached. When sym2
is given, the database is extended
up to (including the creation of) sym2
. If num
is
given, it should be the return value of a previous call to seq
, and
is used as an internal free list link. See also free
.
: (pool "db")
-> T
: (seq *DB)
-> {2}
: (seq @)
-> {3}
(set 'var 'any ..) -> any
- Stores new values
any
in the var
arguments. See
also setq
, val
, con
and def
.
: (set 'L '(a b c) (cdr L) '999)
-> 999
: L
-> (a 999 c)
(setq var 'any ..) -> any
- Stores new values
any
in the var
arguments. See
also set
, val
and def
.
: (setq A 123 B (list A A)) # Set 'A' to 123, then 'B' to (123 123)
-> (123 123)
(show 'any ['sym|cnt]) -> any
- Shows the name, value and property list of a symbol found by applying the
get
algorithm to any
and
the following arguments. See also view
.
: (setq A 123456)
-> 123456
: (put 'A 'x 1)
-> 1
: (put 'A 'lst (9 8 7))
-> (9 8 7)
: (put 'A 'flg T)
-> T
: (show 'A)
A 123456
flg
lst (9 8 7)
x 1
-> A
: (show 'A 'lst 2)
-> 8
(size 'any) -> cnt
- Returns the "size" of
any
. For numbers this is the number of
bytes needed for the value, for external symbols it is the number of bytes it
would occupy in the database, for other symbols it is the number of bytes
occupied in the UTF-8 representation of the name, and for lists it is the total
number of cells in this list and all its sublists. See also length
.
: (size "abc")
-> 3
: (size "äbc")
-> 4
: (size 123)
-> 1
: (size (1 (2) 3))
-> 4
: (size (1 2 3 .))
-> 3
(skip ['sym]) -> sym
- Skips all white space (and comments if
sym
is given) in the
input stream. Returns the next available character, or NIL
upon end
of file. See also peek
and eof
.
$ cat a
# Comment
abcd
$ ./p dbg.l
: (in "a" (skip "#"))
-> "a"
(sort 'lst ['fun]) -> lst
- Sorts
lst
by destructively exchanging its elements. If
fun
is given, it is used as a "less than" predicate for
comparisons. See also Comparing, group
and uniq
.
: (sort '(a 3 1 (1 2 3) d b 4 T NIL (a b c) (x y z) c 2))
-> (NIL 1 2 3 4 a b c d (1 2 3) (a b c) (x y z) T)
: (sort '(a 3 1 (1 2 3) d b 4 T NIL (a b c) (x y z) c 2) >)
-> (T (x y z) (a b c) (1 2 3) d c b a 4 3 2 1 NIL)
(space ['cnt]) -> cnt
- Prints
cnt
spaces, or a single space when cnt
is
not given.
: (space)
-> 1
: (space 1)
-> 1
: (space 2)
-> 2
(sp? 'any) -> flg
- Returns
T
when the argument any
is
NIL
, or if it is a string (symbol) that consists only of whitespace
characters.
: (sp? " ")
-> T
: (sp? "ABC")
-> NIL
: (sp? 123)
-> NIL
(split 'lst 'any ..) -> lst
- Splits
lst
at all places containing an element any
and returns the resulting list of sublists. See also stem
.
: (split (1 a 2 b 3 c 4 d 5 e 6) 'e 3 'a)
-> ((1) (2 b) (c 4 d 5) (6))
: (mapcar pack (split (chop "The quick brown fox") " "))
-> ("The" "quick" "brown" "fox")
(sqrt 'num) -> num
- Returns the square root of the
num
argument.
: (sqrt 64)
-> 8
: (sqrt 1000)
-> 31
: (sqrt 10000000000000000000000000000000000000000)
-> 100000000000000000000
(stamp ['dat 'tim]) -> sym
- Returns a date-time string in the form "YYYY-MM-DD HH:MM:SS". If
dat
and/or tim
is missing, the current date or time is
used. See also date
and time
.
: (stamp)
-> "2000-09-12 07:48:04"
: (stamp (date) 0)
-> "2000-09-12 00:00:00"
: (stamp (date 2000 1 1) (time 12 0 0))
-> "2000-01-01 12:00:00"
(state 'var ((sym|lst sym [. prg]) . prg) ..) -> any
- Implements a finite state machine. The variable
var
holds the
current state as a symbolic value. When a clause is found that contains the
current state in its CAAR sym|lst
value, and either has no
prg
condition in its CDDAR, or that condition returns
non-NIL
, the current state will be set to the CADAR
sym
of the clause, the body prg
in its CDR will be
executed, and the result returned. T
is a catch-all for any state.
If no state-condition matches, NIL
is returned. See also case
and job
.
: (de tst ()
(job '((Cnt . 4))
(state '(start)
((start run) (printsp 'start))
((run run (gt0 (dec 'Cnt)))
(printsp 'run) )
((run stop) (printsp 'run))
((stop start) (setq Cnt 4) (println 'stop)) ) ) )
-> tst
: (do 12 (tst))
start run run run run stop
start run run run run stop
-> stop
: (pp 'tst)
(de tst NIL
(job '((Cnt . 4))
(state '(start)
...
-> tst
: (do 3 (tst))
start run run -> run
: (pp 'tst)
(de tst NIL
(job '((Cnt . 2))
(state '(run)
...
-> tst
(stem 'lst 'any ..) -> lst
- Returns the tail of
lst
that does not contain any of the
any
arguments. (stem 'lst 'any ..)
is equivalent to
(last (split 'lst 'any ..))
. See also tail
and split
.
: (stem (chop "abc/def\\ghi") "/" "\\")
-> ("g" "h" "i")
(step 'lst ['flg]) -> any
- Single-steps iteratively through a database tree.
lst
is a
structure as received from init
. If
flg
is non-NIL
, partial keys are skipped. See also
tree
, leaf
and fetch
.
: (setq Q (init (tree 'nr '+Item) 3 5))
-> (((3 . 5) ((3 NIL . {3-3}) (4 NIL . {3-4}) (5 NIL . {3-5}) (6 NIL . {3-6}) (7 NIL . {3-8}))))
: (get (step Q) 'nr)
-> 3
: (get (step Q) 'nr)
-> 4
: (get (step Q) 'nr)
-> 5
: (get (step Q) 'nr)
-> NIL
(stk any ..) -> T
- Displays a dump of the internal runtime stack to standard error. All
(unevaluated)
any
arguments are printed as a header, then each
stack entry is printed per line, preceded by its (hexadecimal) address. See also
env
.
: (cons 'A (stk Test))
(Test)
BFFFF69C (A)
BFFFF70C (cons 'A (stk Test))
-> (A . T)
(store 'tree 'any1 'any2 ['(num1 . num2)])
- Stores a value
any2
for the key any1
in a database
tree. num1
is a database file number, as used in new
(defaulting to 1), and num2
a
database block size (defaulting to 256). When any2
is
NIL
, the corresponding entry is deleted from the tree. See also
tree
and fetch
.
: (store (tree 'nr '+Item) 2 '{3-2})
(str 'sym ['sym1]) -> lst
(str 'lst) -> sym
- In the first form, the string
sym
is parsed into a list. This
mechanism is also used by load
. If
sym1
is given, it should specify a set of characters, and
str
will then return a list of tokens analog to read
. The second form does the reverse
operation by building a string from a list. See also any
, name
and sym
.
: (str "a (1 2) b")
-> (a (1 2) b)
: (str '(a "Hello" DEF))
-> "a \"Hello\" DEF"
: (str "a*3+b*4" "_")
-> (a * 3 + b * 4)
(strDat 'sym) -> dat
- Converts a string
sym
in the date format of the current
locale
to a date
. See also expDat
, $dat
and datStr
.
: (strDat "2007-06-01")
-> 733134
: (strDat "01.06.2007")
-> NIL
: (locale "DE" "de")
-> NIL
: (strDat "01.06.2007")
-> 733134
: (strDat "1.6.2007")
-> 733134
(strip 'any) -> any
- Strips all leading
quote
symbols from any
.
: (strip 123)
-> 123
: (strip '''(a))
-> (a)
: (strip (quote quote a b c))
-> (a b c)
(str? 'any) -> sym | NIL
- Returns the argument
any
when it is a transient symbol
(string), otherwise NIL
. See also sym?
, box?
and ext?
.
: (str? 123)
-> NIL
: (str? '{ABC})
-> NIL
: (str? 'abc)
-> NIL
: (str? "abc")
-> "abc"
(sub? 'sym1 'sym2) -> flg
- Returns non-
NIL
when the name of the first symbol
sym1
is a substring of the name of the second symbol
sym2
. See also pre?
.
: (sub? "def" "abcdef")
-> T
: (sub? "abb" "abcdef")
-> NIL
: (sub? "" "abcdef")
-> T
(subr 'sym) -> num
- Converts a Lisp-function that was previously converted with
expr
back to a C-function.
: sqrt
-> 67325664
: (expr 'sqrt)
-> (@ (pass $134533847))
: (subr 'sqrt)
-> 67325664
(sum 'fun 'lst ..) -> num
- Applies
fun
to each element of lst
. When
additional lst
arguments are given, their elements are also passed
to fun
. Returns the sum of all numeric values returned from
fun
.
: (setq A 1 B 2 C 3)
-> 3
: (sum val '(A B C))
-> 6
: (sum # Total size of symbol list values
'((X)
(and (pair (val X)) (size @)) )
(what) )
-> 32021
(super ['any ..]) -> any
- Can only be used inside methods. Sends the current message to the current
object
This
, this time starting the search for a method at the
superclass(es) of the class where the current method was found. See also
OO Concepts
, extra
, method
, meth
, send
and try
.
(dm stop> () # 'stop>' method of current class
(super) # Call the 'stop>' method of the superclass
... ) # other things
(sym 'any) -> sym
- Generate the printed representation of
any
into the name of a
new symbol sym
. This is the reverse operation of any
. See also name
and str
.
: (sym '(abc "Hello" 123))
-> "(abc \"Hello\" 123)"
(sym? 'any) -> flg
- Returns
T
when the argument any
is a symbol. See
also str?
, box?
and ext?
.
: (sym? 'a)
-> T
: (sym? NIL)
-> T
: (sym? 123)
-> NIL
: (sym? '(a b))
-> NIL
(sync) -> flg
- Waits for pending data from all family processes. While other processes are
still sending data (via the
tell
mechanism), a select
system call is executed for all file
descriptors and timers in the VAL
of the global variable *Run
. See also key
and wait
.
: (or (lock) (sync)) # Ensure database consistency
-> T # (numeric process-id if lock failed)
(sys 'any ['any]) -> sym
- Returns or sets a system environment variable.
: (sys "TERM") # Get current value
-> "xterm"
: (sys "TERM" "vt100") # Set new value
-> "vt100"
: (sys "TERM")
-> "vt100"