reft.html

A very small LISP implementation with several packages and demo programs.

-> "10:57:56"
</code></pre>

<dt><a name="timeout"><code>(timeout ['num])</code></a>
<dd>Sets or refreshes a timeout value in the <code><a
href="refR.html#*Run">*Run</a></code> global, so that the current process
executes <code><a href="refB.html#bye">bye</a></code> after the given period. If
called without arguments, the timeout is removed. See also <code><a
href="refT.html#task">task</a></code>.

<p><pre><code>
: (timeout 3600000)           # Timeout after one hour
-> (-1 3600000 (bye))
: *Run                        # Look after a few seconds
-> ((-1 3574516 (bye)))
</code></pre>

<dt><a name="throw"><code>(throw 'sym 'any)</code></a>
<dd>Non-local jump into a previous <code><a
href="refC.html#catch">catch</a></code> environment with the jump label
<code>sym</code> (or <code>T</code> as a catch-all). Any pending <code><a
href="refF.html#finally">finally</a></code> expressions are executed, local
symbol bindings are restored, open files are closed and internal data structures
are reset appropriately, as the environment was at the time when the
corresponding <code>catch</code> was called. Then <code>any</code> is returned
from that <code>catch</code>.

<p><pre><code>
: (de foo (N)
   (println N)
   (throw 'Ok) )
-> foo
: (let N 1  (catch 'Ok (foo 7))  (println N))
7
1
-> 1
</code></pre>

<dt><a name="tick"><code>(tick (cnt1 . cnt2) . prg) -> any</code></a>
<dd>Executes <code>prg</code>, then (destructively) adds the number of elapsed
user ticks to the <code>cnt1</code> parameter, and the number of elapsed system
ticks to the <code>cnt2</code> parameter. Thus, <code>cnt1</code> and
<code>cnt2</code> will finally contain the total number of user and system time
ticks spent in <code>prg</code> and all functions called (this works also for
recursive functions). For execution profiling, <code>tick</code> is usually
inserted into words with <code>prof</code>, and removed with
<code>unprof</code>. See also <code><a href="refU.html#usec">usec</a></code>.

<p><pre><code>
: (de foo ()                        # Define function with empty loop
   (tick (0 . 0) (do 100000000)) )
-> foo
: (foo)                             # Execute it
-> NIL
: (pp 'foo)
(de foo NIL
   (tick (97 . 0) (do 100000000)) ) # 'tick' incremented 'cnt1' by 97
-> foo
</code></pre>

<dt><a name="till"><code>(till 'any ['flg]) -> lst|sym</code></a>
<dd>Reads from the current input channel till a character contained in
<code>any</code> is found (or until end of file if <code>any</code> is
<code>NIL</code>). If <code>flg</code> is <code>NIL</code>, a list of
single-character transient symbols is returned. Otherwise, a single string is
returned. See also <code><a href="refF.html#from">from</a></code> and <code><a
href="refL.html#line">line</a></code>.

<p><pre><code>
: (till ":")
abc:def
-> ("a" "b" "c")
: (till ":" T)
abc:def
-> "abc"
</code></pre>

<dt><a name="time"><code>(time ['T]) -> tim<br>
(time 'tim) -> (h m s)<br>
(time 'h 'm ['s]) -> tim | NIL<br>
(time '(h m [s])) -> tim | NIL</code></a>
<dd>Calculates the time of day, represented as the number of seconds since
midnight. When called without arguments, the current local time is returned.
When called with a <code>T</code> argument, the current Coordinated Universal
Time (UTC) is returned. When called with a single number <code>tim</code>, it is
taken as a time value and a list with the corresponding hour, minute and second
is returned. When called with two or three numbers (or a list of two or three
numbers) for the hour, minute (and optionally the second), the corresponding
time value is returned (or <code>NIL</code> if they do not represent a legal
time). See also <code><a href="refD.html#date">date</a></code>, <code><a
href="refU.html#usec">usec</a></code>, <code><a
href="refT.html#tim$">tim$</a></code> and <code><a
href="ref_.html#$tim">$tim</a></code>.

<p><pre><code>
: (time)                         # Now
-> 32334
: (time 32334)                   # Now
-> (8 58 54)
: (time 25 30)                   # Illegal time
-> NIL
</code></pre>

<dt><a name="tmp"><code>(tmp ['any ..]) -> sym</code></a>
<dd>Returns the path name to the <code><a
href="refP.html#pack">pack</a></code>ed <code>any</code> arguments in a
process-local temporary directory. The directory name consists of "tmp/"
followed by the current process id <code><a
href="refP.html#*Pid">*Pid</a></code>. This directory is automatically created
if necessary, and removed upon termination of the process (<code><a
href="refB.html#bye">bye</a></code>). See also <code><a
href="refT.html#*Tmp">*Tmp</a></code> and <code><a
href="refB.html#*Bye">*Bye</a></code> .

<p><pre><code>
: *Bye
-> ((saveHistory) (and *Tmp (call 'rm "-r" *Tmp)))
: *Pid
-> 27140
: (tmp "foo" 123)
-> "tmp/27140/foo123"
: (dir "tmp/")
-> ("27140")
: (out (tmp "foo" 123) (println 'Ok))
-> Ok
: (dir (tmp))
-> ("foo123")
: (in (tmp "foo" 123) (read))
-> Ok
</code></pre>

<dt><a name="touch"><code>(touch 'sym) -> sym</code></a>
<dd>When <code>sym</code> is an external symbol, it is marked as "modified" so
that upon a later <code><a href="refC.html#commit">commit</a></code> it will be
written to the database file. An explicit call of <code>touch</code> is only
necessary when the value or properties of <code>sym</code> are indirectly
modified.

<p><pre><code>
: (get '{2} 'lst)
-> (1 2 3 4 5)
: (set (cdr (get (touch '{2}) 'lst)) 999)    # Only read-access, need 'touch'
-> 999
: (get '{2} 'lst)                            # Modified second list element
-> (1 999 3 4 5)
</code></pre>

<dt><a name="trace"><code>(trace 'sym) -> sym<br>
(trace 'sym 'cls) -> sym<br>
(trace '(sym . cls)) -> sym</code></a>
<dd>Inserts <code><a href="ref_.html#$">$</a></code> trace function call at the
beginning of the function or method body of <code>sym</code>, so that trace
information will be printed before and after execution. Built-in functions
(C-function pointer) are automatically converted to Lisp expressions (see
<code><a href="refE.html#expr">expr</a></code>). See also <code><a
href="refD.html#*Dbg">*Dbg</a></code>, <code><a
href="refD.html#debug">debug</a></code> and <code><a
href="refL.html#lint">lint</a></code>.

<p><pre><code>
: (trace '+)
-> +
: (+ 3 4)
 + : 3 4
 + = 7
-> 7
</code></pre>

<dt><a name="tree"><code>(tree 'var 'cls ['hook]) -> tree</code></a>
<dd>Returns a data structure specifying a database index tree. <code>var</code>
and <code>cls</code> determine the relation, with an optional <code>hook</code>
object. See also <code><a href="refR.html#root">root</a></code>, <code><a
href="refF.html#fetch">fetch</a></code>, <code><a
href="refS.html#store">store</a></code>, <code><a
href="refC.html#count">count</a></code>, <code><a
href="refL.html#leaf">leaf</a></code>, <code><a
href="refM.html#minKey">minKey</a></code>, <code><a
href="refM.html#maxKey">maxKey</a></code>, <code><a
href="refI.html#init">init</a></code>, <code><a
href="refS.html#step">step</a></code>, <code><a
href="refS.html#scan">scan</a></code>, <code><a
href="refI.html#iter">iter</a></code>, <code><a
href="refP.html#prune">prune</a></code>, <code><a
href="refZ.html#zapTree">zapTree</a></code> and <code><a
href="refC.html#chkTree">chkTree</a></code>.

<p><pre><code>
: (tree 'nm '+Item)
-> (nm . +Item)
</code></pre>

<dt><a name="trim"><code>(trim 'lst) -> lst</code></a>
<dd>Returns a copy of <code>lst</code> with all trailing white space characters
or <code>NIL</code> elements removed. See also <code><a
href="refC.html#clip">clip</a></code>.

<p><pre><code>
: (trim (1 NIL 2 NIL NIL))
-> (1 NIL 2)
: (trim '(a b " " " "))
-> (a b)
</code></pre>

<dt><a name="try"><code>(try 'msg 'obj ['any ..]) -> any</code></a>
<dd>Tries to send the message <code>msg</code> to the object <code>obj</code>,
optionally with arguments <code>any</code>. If <code>any</code> is not an
object, or if the message cannot be located in <code>obj</code>, its classes and
superclasses, <code>NIL</code> is returned. See also <code><a
href="ref.html#oop">OO Concepts</a></code>, <code><a
href="refS.html#send">send</a></code>, <code><a
href="refM.html#method">method</a></code>, <code><a
href="refM.html#meth">meth</a></code>, <code><a
href="refS.html#super">super</a></code> and <code><a
href="refE.html#extra">extra</a></code>.

<p><pre><code>
: (try 'msg> 123)
-> NIL
: (try 'html> 'a)
-> NIL
</code></pre>

<dt><a name="type"><code>(type 'any) -> lst</code></a>
<dd>Return the type (list of classes) of the object <code>sym</code>. See also
<code><a href="ref.html#oop">OO Concepts</a></code>, <code><a
href="refI.html#isa">isa</a></code>, <code><a
href="refC.html#class">class</a></code>, <code><a
href="refN.html#new">new</a></code> and <code><a
href="refO.html#object">object</a></code>.

<p><pre><code>
: (type '{1A;3})
(+Address)
: (type '+DnButton)
-> (+Tiny +Rid +JS +Able +Button)
</code></pre>

</dl>

</body>
</html>