Lisp2D

Start of the interpreter
Syntax
Keywords and variable environments
Types
Symbols
Setting the value
Forms of management
Logic
Numbers
List
Vector
Strings
Characters
Locks and signals
Object-oriented programming
Work with streams of an input/output
Windows
Space of names
Date and time
Directory
System functions
Index

Start of the interpreter

> ./lisp2d

Start without parameters enters into an interactive mode with the function read-eval-print.
This function supports necessary service traditional for Unix-consoles - editing with the keys: arrows left, right, backspace, delete, home, end and also listing history of the entered expressions with the keys arrows up and down.

> ./lisp2d filename [{ arg_i }]

Conseqently carries out all forms stored in a file filename. Before executing of a file a variable arg links with the list of strings ( "arg₁" … "arg_n" ).
In all cases the received result of calculation comes back as a return code of the program if result was value of type char or integer, otherwise a return code - 0.
Interpreter uses a system multithreading, streams of the POSIX standard.
The quantity of working streams will be equal to quantity of processors. The quantity of calculations history records is 16.
The history of calculations at programming gives the big advantage. All knots of a course of the program are visible and the site in which there was an unexpected operation is visible. Speed of a program debugging increases 10 times.
(nil setdebug),(nil setdebug false),(nil setdebug 0) - cancels record in history of calculations. Speed of the program increases.
(nil setdebug number) - changes the size of history of calculations.
(nil getdebug) - returns the size of history of calculations.
(cerr error) - to see the history of calculations.

Syntax

(obj … obj) - list
#(obj … obj) vector (array)

"ab…z" - string: The string having special characters is created by means of a sign \
"the \"abc\" is string" - it is one string
"\\" - string from one character \

'obj=(nil quote obj) - prohibition of calculations.
'''(very
long
comment
('class defmethod m (x) …)) - it is used and as the comment of old functions
;abc…z - the comment up to the end of a line
`obj=(nil backquote obj) - back quote (partial prohibition of calculations)
,obj=(nil unquote obj) - calculation inside backquote
,@obj=(nil unquote-splicing obj) - calculation with an insert inside backquote
(obj . obj) - dot pair

#\c - letter (character) c: #\space - space
#\tab - tabulator
#\backspace - the character returned by function read-char by pressing a key backspace
#\enter
#\escape
#\left
#\right
#\up
#\down
#\delete
#\home
#\end

Keywords and variable environments

&rest - Connects a variable with the list of the staying arguments: (nil defmethod m (a &rest b) (cout writeln a b))
(nil m 1 2 3 4) →
1
(2 3 4)

&env - connects a variable with a context of the moment of a call of function ((lock . vector) … (lock . vector)). vector=#((symbol . value) … (symbol . value)).

&whole - connects a variable with an original call where are not calculated neither object nor arguments.: >(nil defmethod t (&whole w) (cout writeln "w=" w))
(lambda (&whole w) (cout writeln "w=" w))
>((10 + 10) t)
w=((10 + 10) t)

nil nothing or empty list

true- The logic truth

false - The logic false

Global variables:

package - The variable, contacts a loaded file

arg - the variable, communicates with the list of the arguments transmitted at loading of a file.

pi=3.141592653589… π

e=2.718281828459…

cin - standard stream of input

cout - standard stream of an output

cerr - standard stream for error messages.

xk-enter, xk-home, xk-end, xk-left, xk-right, xk-up, xk-down, xk-page-up, xk-page-down, xk-insert, xk-delete, xk-caps-lock, xk-shift-l, xk-shift-r, xk-control-l, xk-control-r, xk-alt-l, xk-alt-r, xk-f1, xk-f2, xk-f3, xk-f4, xk-f5, xk-f6, xk-f7, xk-f8, xk-f9, xk-f10, xk-f11, xk-f12, xk-backspace, xk-undo, xk-num-lock, xk-kp-multiply, xk-space, xk-numbersign, xk-question - codes of the pressed keys for function (window read-keyb)

environ - the associative list of variables of environment. For work with them it is possible to take advantage of functions getenv, setenv.: >environ
(("LESSKEY" . "/etc/lesskey.bin") … ("_" . "./lisp2d"))
>(environ assoc "HOSTTYPE")
("HOSTTYPE" . "x86_64")

In objects:
this - value of itself (object)

Types

(nil type-of obj) - returns a symbol designating type of result of calculation obj, for objects returns a classname: nil - nothing (the empty list)
false - false (or lie)
true - The logic truth
cons - List cell
vector - vector (array)
string - string of characters
number - Number (only one type of numbers)
symbol - Symbol
char - character
stream - Stream of an input / output
window - really window
time - the date and time.
dir - directory processor.
bif - built-in kernel function.

At definition of types it is better to use logic functions:

(nil atom obj) - obj is not a list cell: (nil atom nil) → true
(nil atom false) → true
(nil atom cons) → false
(nil atom obj) → obj

(nil = {obj}) - all obj are nil: (nil = false) → false
(nil = nil) → true
(nil = true) → false

(nil <> {obj}) - none obj is not equal nil: (nil <> false) → true
(nil <> nil) → false
(nil <> true) → true

(false = {obj}) - equality false: (false = false) → true
(false = nil) → false
(false = true) → false

(false <> {obj}) - none obj is not equal false: (false <> false) → false
(false <> nil) → true
(false <> true) → true

(true = {obj}) - equality true: (true = false) → false
(true = nil) → false
(true = true) → true
(true = 12) → false

(true <> {obj}) - none obj is not equal true: (true <> false) → true
(true <> nil) → true
(true <> true) → false

(nil stringp obj) - obj is string: (nil stringp "ab") → "ab"
(nil stringp 1) → false

(nil charp x) - character: (nil charp #\t) → #\t
(nil charp true) → false

(nil listp obj) - of conformity to a list cell or nil: (nil listp nil) → true
(nil listp 1) → false
(nil listp '(1 . 2)) → (1 . 2)

(nil consp obj) - of conformity to a list cell: (nil consp 1) → false
(nil consp '(1)) → (1)

(nil vectorp obj) - of conformity to a vector: (nil vectorp #(1 2)) → #(1 2)
(nil vectorp 1) → false

(nil symbolp obj) - of conformity to a symbol

(nil numberp obj) - number

(nil streamp obj) - stream: (nil streamp notstream)→false
(nil streamp stream)→stream

(nil objectp obj) - object of a class

(nil windowp x) - conformity to a window: (nil windowp win) → win
(nil windowp 1) → false

(nil timep obj)

(nil dirp obj)

(nil bifp obj)

(nil lockp obj)

(nil signalp obj)

Symbols

Symbols it is auxiliary object for programming, Pure Lisp have no symbols. They can have values: usual and functional, at them is present auxiliary properties.

(symb <> s₁ … s_n) – any symbol s_i is not equal symb

(symb = symb…symb), (symb < symb…symb), (symb <= symb…symb), (symb > symb…symb), (symb >= symb…symb) - comparisons (alphabetically).

(symb min symb … symb), (symb max symb … symb) - minimal/maximal (alphabetically).

(symb + {symb|string|char}) - new symbol: (('abc + '- 'def) set 1) → ('abc-def set 1)

(symb - symb … symb) new symbol: (('abcdef - 'cd) set 1) → ('abef set 1)

(string|char symbol) - returns a symbol with a name string|char.

(symbol put prop val) - establishes property prop a symbol symbol with value val, returns val: Property of a symbol is only in the current space of names.
('work1 namespace
(symbol put prop propv))
('work2 namespace
(symbol get prop)) → NIL

(symb get prop) - property of a symbol symb with a name prop. At absence of the given property comes back NIL: At ocurrence of several spaces of names the first got property comes back.
('std namespace
(symb put prop propv)
…
('another namespace
(symb get prop) → propv
…))

(symb remprop prop) - deletes property of a symbol symb with a name prop. If deleted property is not present - comes back FALSE differently TRUE. Property deletes only in current space of names.

(symb properties) - returns all properties of a symbol as #((symb. value) …), pairs in vector are sorted on symb

(symb boundp) - whether symbol has a value. Returns a dot pair or false

(nil|symbol gensym) - Function-generator of the different symbols beginning on symbol if the initial symbol is not specified begins on T. It is guaranteed, that the returned symbol is new.

Setting the value

(symbol set val [env]) - calculated values of all arguments, val becomes value of symbol symbol. At presence env value is established there.: (('(x y) first) set 1)=(nil setq x 1)

(var letset val) - giving of values of a variable var in the current environment(does not touch value of a variable above). Name of a variable var is calculated. Result will be val: It is applied at lateness of definition of variables of the form let:
('x set 1)
(nil let ()
…
('x letset -2)
…)
x → 1

(nil setq {symb val}) - giving of value val to a symbol symb: The symbol symb is not calculated
(nil setq x (10 - 1))
x → 9

Forms of management

(nil progn b1 … bn) - consecutive calculation b1 … bn , returns result of calculation bn after calculation of all forms b1…bn.

(nil parallel task … task) - parallel calculation of task's. Comes back nil

(nil fork {tasks}) - creates parallel tasks tasks, does not expect their result and returns nil.

(nil if test then else) - calculates test if this value nil or false calculates else, differently - calculation then.: (nil if) →nil
(nil if test)=(nil progn test nil)

(nil when test {work})=(nil if test (nil progn {work})) - if result of test calculation is positive, calculates consecutive tasks work.

(nil let ((var₁ {val₁})|var₁…(var_n {val_n})|var_n) {body}) - creates in parallel local links of variables var with values val and consistently calculates the form body. Variables without value val are initialized with value nil.

(nil cond (test₁ [{form₁}]) … (test_n [{form_n}])) - consistently calculated test_i while not found not false and not nil value. Returns result of last calculation of the corresponding form form_i. If form_i it is not specified, the result of calculation test_i comes back: (nil cond (false 1)) → nil
(nil cond (false 1)(nil (cout write …))) → nil
(nil cond (false 1)(ok oking)) → evaling oking
(nil cond (false 1)(ok)) → ok
(nil cond (false 1)(notok oking)(true default)) → evaling default

(nil quote obj)='obj - calculation of obj is blocked.

(nil eval obj [env]) - double calculation. First obj it is calculated as argument of function eval , then returns the result of calculation by the interpreter of the received value. When arguments env are given, the second calculation will be made in a corresponding environment env.

(nil apply obj fn arglist [env]) - application of function fn to arguments arglist. Value of a variable fn can be a name or lambda-list. Arguments and object calculates only once.

(nil funcall obj fn [{arg}]) - application of function fn to arguments arg. Value of a variable fn can be a name or lambda-list. Arguments and object calculates only once.

(nil funcallenv env obj fn [{arg}]) - application of function fn to arguments arg. Value of a variable fn can be a name or lambda-list. Arguments and object calculates only once. Method calculation is made in an environment env.

(nil backquote obj)=`obj - partial prohibition of calculations of argument obj . When inside the form obj there is a ,x - that subform x is calculated and substituted in the form obj . Also there is a ,@x - it means that value x as the list is substituted by elements in the form obj.: ('x set 'test)
`(a b ,x c)→(a b test c)
('x set '(1 2))
`(0 ,@x 3)→(0 1 2 3)

(nil unquote obj)=,obj - insertion inside the form backquote.

(nil unquote-splicing obj)=,@obj - insertion with distribution inside the form backquote.

(stream error {mess}) - prints the message on a mistake mess. Wait pressing a key and returns nil.

(string load [arg₁ … arg_n]) - reads out a file with a name string, calculates and returns corresponding result. Before calculation the variable arg links with the list of arguments (arg₁ … arg_n) . After calculation the previous value arg is restored.

(string save obj) - writes down object obj in a format of writing in a file with a name string.

(nil do-while {body}) - cyclic calculation of the forms body if its last result will be nil or false calculations stop and result will be this value.

(nil while test {body}) consecutive conditional cycle. It is checked test, if test=false or nil then result will be this value. Then forms are consistently carried out body, then a step to check test.

Logic

(nil not obj) - simply not: (nil not nil) →true
(nil not false) → true
(nil not true) → false
(nil not 1) → nil

(nil or a b … z) - calculates in parallel arguments and returns the first calculated not false and not nil value if such has not got - false: (nil or) → false
(nil or nil) → false
(nil or true) → true
(nil or false) → false
(nil or false nil) → false
(nil or false nil 123) → 123

(nil and a b … z) - calculates in parallel arguments and returns the first calculated false or nil value if such has not got last argument: (nil and) → true
(nil and nil ) → false
(nil and false) → false
(nil and 123) → 123
(nil and 123 nil) → false
(nil and 123 nil false) → false

(nil xor a b … z) - returns unique affirmative value, if such has got more than one - false: (nil xor) → false
(nil xor nil) → false
(nil xor false) → false
(nil xor 123) → 123
(nil xor false false) → false
(nil xor false 123) → 123
(nil xor 123 234) → false
(nil xor nil 123) → 123
(nil xor false 1 false false) → 1
(nil xor false 1 false nil 2) → false

(nil eq a b) - physical equality of two objects (equality of pointers): (nil eq) → true
(nil eq a) → (nil = a)
(nil eq nil nil) → true
(nil eq false false) → true
(nil eq 1 1) → false
(nil eq 'sym 'sym) → sym

Numbers

(a + b c … z) - addition a+b+c+…+z.: (a +) → a
(a + 1) → a+1

(a - b c … z) - subtraction a-b-c-…-z.: (a -) → -a
(a - 1 2) → a-3

(a * b … z) - multiplication.: (a *) → a

(a / b … z) - division a on all other values.: (a /) → 1/a
(a / 2 3) → a/6

(a = b … z) - equality a=b=…=z.

(n <> x₁ … x_k) - any number x_i is not equal n .

(a < b … z) - numbers grow a<b<…<z.

(a > b … z) - numbers decrease a>b>…>z.

(a <= b … z) - less or equal(do not decrease) a≤b≤…≤z.

(a >= b … z) - bigger or equal(do not grow) a≥b≥…≥z.

At successful comparison the first argument a comes back.

(x nanp) - predicate of 0/0.

(x infp) - predicate of ±∞.

(x finitep) - predicate of finite number, not ±∞ and not 0/0.

(number integerp) - integer number.: (1.5 integerp) → false
(2 integerp) → 2
(1/0 integerp) → nil

(number evenp) - predicate, on evenness.: (3 evenp) → false
(-4 evenp) → -4
(3.5 evenp) → nil

(number oddp) - predicate, on oddness.: (4 oddp) → false
(-5 oddp) → -5
(3.5 oddp) → nil

(numb min numb … numb), (numb max numb … numb) - the minimal/maximal number.

(a abs) - absolute value.: (2 abs) → 2
(-3 abs) → 3

(x ceil [d]) - the minimal integer, not smaller x.: (-2.5 ceil)=-2
(2.5 ceil)=3
(7 ceil 2)=((7 / 2) ceil)=4
(2 ceil)=2

(x floor [y]) - rounding off x in the smaller side up to an integer. If given y then returns the whole part from division x on y.: (-2.5 floor) =-3
(13 floor 4) =3
(-13 floor 4) =-4

(x % [y]) - the rest of division x on y.: (13 % 4) =1
(-13 % 4) =3
(13 % -4) =-3
(-13 % -4) =-1
(13.4 % 1) =0.4
(-13.4 % 1) =0.6
(2.3 %)=(2.3 % 1)=0.3

(x gcd [{x_i}]) - the greatest common divider of integers, returns a positive integer.: (3 gcd)=3
(-10 gcd) =10
(12 gcd -8) =4
(32 gcd 16 3) =1

(x lcm [{x_i}]) - the minimum common multiple of integers, returns a positive integer.: (3 lcm)=3
(-10 lcm) =10
(12 lcm -8) =24
(32 lcm 16 3) =96

(x sin) - sine.

(x cos) - cosine.

(x tg) - a tangent.

(x ctg) - cotangent.

(x arcsin)=sin^-1x

(x arccos)=cos^-1x

(x arctg)=tg^-1x
(x arctg y)=tg^-1(x/y) ,y>0 ,x>0

(x sh)=(e^x-e^-x)/2

(x ch)=(e^x+e^-x)/2

(x th)=sh(x)/ch(x)

(x cth)=ch(x)/sh(x)

(x arsh)=sh^-1x

(x arch)=ch^-1x

(x arth)=th^-1x

(x sqrt) - square root √x

(x cbrt) - cube root x^1/3

(x exp) - exponent e^x

(b ^ n) - a degree bⁿ

(x log [a])=log_ax - the logarithm on the basis a (by default natural logarithm).

(x ln)=ln(x) - natural logarithm.

(x lg)=log₁₀x - the decimal logarithm.

(n string [digc]) - returns the string, which precisely represents number. Can be in a fractional form. The maximum quantity of digits digc is if necessary established.: (4/6 string) → "2/3"
(4/6 string 2) → "6.7e-1"
(4/6 string 0) → "6.66666666667e-1" ; 12 digits

(x !)=1*2*…*x - a factorial.

(nil random) - returns random floating number, in an interval [0…1).: (nil random) → 0.102355897908
(numb random) - returns random floating number, smaller on absolute value, than numb.: (pi random) → 2.0939049352352
(-3 random) → -1.194246236960

(number for symbol {body}) in parallel local variables symbol (for each process the personal variable symbol) numbers are given 0…number-1, at each value forms are calculated consistently body.: (3 for i (cout write " i+1=" (i + 1)) (i + 1)) →
i+1=2 i+1=1 i+1=3
→ nil

(number for* symbol {body}) consistently local variable symbol gives numbers 0…number-1, forms body are calculated consistently. Last result of the form body comes back.: (3 for* i (cout writeln "i=" i "..")) →
i=0..
i=1..
i=2..

(number setf number)=(number number number) - physically changes number with new value. Using of the given operation is fraught with mistakes of programming.: ('x set 7) → 7
('y set (nil list x x x)) → (7 7 7)
(x setf (x - 1)) → 6
y → (6 6 6)
For avoidance of damage of the working program it is necessary to use function of copying:
(nil let ((x 0)) … → (nil let ((x (0 copy))) …
('x set 0) → (x setf 0)
(nil setq x 0) → (x setf 0)

(number copy) - returns new number.

('number newobject number)=(number copy)
('number newobject)≈(0 copy)

(number += [{x}])≈(number setf (number + [{x}]))

(number -= [{x}])≈(number setf (number - [{x}]))

(number *= [{number}])≈(number setf (number * [{number}]))

(number /= [{number}])≈(number setf (number / [{number}]))

(number degrees)=number*180/π

(number radians)=number/180*π

(n combin x)=C(x,n)=n!/x!/(n-x)!

(n combina x)=n!/(n-x)!

(nil multinomial x … z)=(x+…+z)!/x!…/z!

(number round quality) - returns roundoff at a relative precision quality. [number*(1-quality) … number*(1+quality)]: >(pi round 1e-3)
3.14375
>(pi round 1e-4)
3/225/1592

(number roundint) - returns roundoff to the nearest integer.

(number num) - positive whole numerator of number.

(number denom) - positive whole denominator of number.

List

(list first) - returns a first element of the list list.: ('(1 2 3) first)→1
(nil first)→nil

(list rest) - returns a tail part of the list list.: ('(1 2 3) rest) → '(2 3)
(nil rest)→nil

(list second)=((list rest) first)

(list third)=(((list rest) rest) first)

(list size) - returns length of the list(count of list cells).: (nil size) → 0

(nil cons first rest) - creates a list cell with respective links.

('cons newobject first rest)=(nil cons first rest)
('cons newobject another-cons)=(another-cons copy)
('cons newobject)=(nil cons nil nil)

(nil list arg₁ … arg_n) - returns the list of arguments (arg₁ … arg_n), arguments are calculated in parallel

(nil list* arg₁ … arg_n) - returns the list of arguments (arg₁ … arg_n-1 . arg_n), last argument incorporates as tail, arguments are calculated in parallel: (nil list* 'a 'b '(c d e)) → (a b c d e)

(list last) - returns last list cell: ('(1 2 3) last) → (3)
('(1 2 . 3) last) → (2 . 3)
(nil last) → nil

(list + {list}) - returns concatenation of lists list. All lists do not destroyed.: ('(1 2 3) + '(4 5 6)) → (1 2 3 4 5 6)
('(1 2 3) + atom '(a) nil '(dotted . list)) → (1 2 3 a dotted . list)

(list reverse) - creates new list with the reverse place of elements.: ('(1 2 3) reverse)→ (3 2 1)

(list remove elt) – deletes from the list elements satisfying to equality (elt = list_i), returns the new list without the given elements: ('(1 2 3) remove 2) → (1 3)

(list substitute old new) – replacement of elements old on new (at comparison the method = is used). Returns the new list.: ('(a x x a) substitute 'x 'b) → (a b b a)

(list copy) - returns the new list. Cells of top level are copied only.

(list copy-tree) - returns a new tree. Cells, both first and rest are copied all.

(cons setfirst newfirst) - replaces a head part of the list cons with object newfirst

(list setrest newrest) - replaces a tail part of the list list with object newrest. If list an element of your program it is necessary to know, that these procedures change the program and it is hard to present as she then looks. That you did not have mistakes use in the program not (nil let ((l '(nil progn ) … but (nil let ((l (list nil 'progn)…

(cons cons first rest)=(cons setfirst first),(cons setrest rest)
(cons cons another-cons)=(cons setf another-cons)

(consthis setf consarg)=(consthis setfirst(consarg first)),(consthis setrest(consarg rest)) - replaces parts of a cell on new, given consarg. Use of the given operation is fraught with mistakes of programming.

(list += {list}) - all lists unites, destroys their structure, except for the last. Returns the united list.: ('list1 set '(a b))
('list2 set '(c d))
('list3 set '(e f))
(list1 += list2 list3)
list1→ (a b c d e f)
list2→ (c d e f)

(list for* symbol {body}) consistently local variable symbol gives elements of the list list , forms body are calculated consistently. Last result of the form body comes back.: ('(1 2 3) for* i (cout writeln "i=" i "..")) →
i=1..
i=2..
i=3..

(list for symbol {body}) - to in parallel local variables symbol (for each process the variable symbol) elements of the list are given, at each value forms body are calculated consistently.: ('(1 2 3) for i (cout write " i+1=" (i + 1)) (i + 1)) →
i+1=2 i+1=4 i+1=3
→ nil

(envir assoc who [testeql]) - returns a pair (obj . obj-value) from a list envir=((a . 1) (b . 2) … (c . 3)) at which who=obj if this pair there exists, and nil - at absence of value. By search predicates of equality of objects testeql, by default are used: =

(envir rassoc who [testeql]) - returns a pair (obj . obj-value) from a list envir=((a . 1) (b . 2) … (c . 3)) at which who=obj-value if this pair there exists, and nil - at absence of value. By search predicates of equality of objects testeql, by default are used: =: ('((1 . a) (2 . b) (3 . c)) rassoc 'c)→ (3 . c)

(a-list acons x y)=(nil cons (nil cons x y) a-list) - adds in the associative list a pair (x . y), the result should be saved: ('a-list set (a-list acons x y))

(a-list pairlist keys-list data-list) – returns the associative list from the list of keys and the list of data, and also adds old a-list.: ('((a . 1)) pairlist '(b c) '(2 3)) → ((b . 2) (c . 3) (a . 1))

(list = list … list) - comparisons of the contents of all lists

(list <> l₁ … l_n) - any list l_i is not equal list.

(list contain item [test]) - whether is item in sequence, by default test is =: ('(a b c d) contain 'c) → (c d)

(list vector) - returns a new vector with elements of the list

(nil vector) - returns a new empty vector #()

(list map fn [{list}]) - application of function fn to elements of list and elements of [{list}]. Value of a variable fn can be a name or lambda-list. The list of result is returned. Calculations executed in parallel.: ('(1 2 3 4) map '- '(1 1 1 1)) → '(0 1 2 3)
('(1 2 3 4) map '-) → '(-1 -2 -3 -4)
('(1 2.3 x "4") map '(lambda () (nil numberp this))) → '(1 2.3 false false)

(list mapc fn [{list}]) - application of function fn to elements of list and elements of [{list}]. Value of a variable fn can be a name or lambda-list. Does not return value. It is used for side effect obtaining. Calculations executed in parallel.: ('(a b c) mapc '(lambda(v &env env)(this set v env)) '(1 2 3)) → nil
a → 1
b → 2
c → 3

(list count [{x}]) - quantity of units of the list satisfying to inquiry (elt = [{x}]).

(list count-if fn [{x}]) - quantity of units of the list satisfying to inquiry (elt fn [{x}]).

(list find [{x}]) - the list cell containing a unit satisfying condition (elt = [{x}]) comes back.: ('(1 2 3) find 2) → (2 3)
('(1 2 3) find 4) → nil

R=M+N	R_i,j=M_i,j+N_i,j
R=M-N	R_i,j=M_i,j-N_i,j
*R=mN**	*R_i,j=mN_i,j**

in	on reading
out	on writing
trunc	to cut down a file till zero length
app	addition in the end
ate	opening and search of the end of a file

beg	from the beginning of a current file
cur	from a current position
end	from the end of a current file

Lisp2D

Start of the interpreter

Syntax

Keywords and variable environments

Types

Symbols

Setting the value

Forms of management

Logic

Numbers

List

Vector

Strings

Characters

Locks and signals

Object-oriented programming

Work with streams of an input/output

Windows

Space of names

Date and time

Directory

System functions

Index