(hide-trapped-error)

t

(show-trapped-error)

t

(env-get 0)

((gc-stack newline (section 3 "set-gc-stack-size" ((para ("With `set-gc-stack-size` you can change the size of the stack used for heap traversal" "by the garbage collector.")) (code ((set-gc-stack-size 100))) nil)) newline hline) (render-program-disp-gif-p

(env-get 1)

((gc-is-always-gc newline (section 3 "is-always-gc" ((para ("The `is-always-gc` predicate is true if LBM is built with the LBM_ALWAYS_GC debug flag.")) (code ((is-always-gc))) nil)) newline hline) (str-merge-list closure (strings) (match strings (nil [0]) 

(env-get 2)

((chapter-gc section 2 "GC" ((newline (section 3 "set-gc-stack-size" ((para ("With `set-gc-stack-size` you can change the size of the stack used for heap traversal" "by the garbage collector.")) (code ((set-gc-stack-size 100))) nil)) newline hline) (newlin

(env-get 3)

((environment-get newline (section 3 "env-get" ((para ("`env-get` can be used to reify, turn into value, parts of the global environment." "The global environment is stored as a hashtable and an index into this hashtable" "is used to extract the bindings s

(env-get 4)

((environment-set newline (section 3 "env-set" ((para ("`env-set` destructively sets an entry in the global environment hashtable.")) (program (((if (eq (env-get 1) nil) (env-set 1 (list (quote (a . 75))))) (env-get 1)))) (para ("Note that in the example c

(env-get 5)

((render closure (rend ss) (match ss (nil t) (((? x) ? xs) (progn (render-it rend x) (render rend xs))) ((? x) (print "RENDER ERROR: " x))) nil) (code-raw closure (c) (list (quote code-raw) c) nil))

(env-get 6)

((environment-drop newline (section 3 "env-drop" ((para ("drop a binding from an environment.")) (code ((env-drop (quote a) (quote ((a . 10) (b . 20) (c . 30)))))) nil)) newline hline) (pretty-aligned-on-top closure (n cs) (match cs (nil [0]) (((? x) ? xs)

(env-get 7)

((pretty closure (toplevel ind c) (if (and toplevel (list? c)) (pretty-toplevel-list c) (pretty-ind ind c)) nil))

(env-get 8)

((local-environment-get newline (section 3 "local-env-get" ((para ("`local-env-get` can be used to reify, turn into value, the local environment.")) (code ((local-env-get))) (program (((let ((a 50)) (local-env-get))))) nil)) newline hline) (disp-render-mac

(env-get 9)

((global-environment-size newline (section 3 "global-env-size" ((para ("Get the size (in number of bindings) of the global env.")) (code ((global-env-size))) nil)) newline hline) (render-code-png-table closure (rend img colors c) (progn (rend "<table>\n") 

(env-get 10)

((chapter-environments section 2 "Environments" ((newline (section 3 "env-get" ((para ("`env-get` can be used to reify, turn into value, parts of the global environment." "The global environment is stored as a hashtable and an index into this hashtable" "i

(env-get 11)

((symbol-table-size newline (section 3 "symtab-size" ((para ("`symtab-size` returns the size of the symbol table in bytes.")) (code ((symtab-size))) nil)) newline hline) (frame-i . 0))

(env-get 12)

((symbol-table-size-flash newline (section 3 "symtab-size-flash" ((para ("`symtab-size-flash` returns the size in bytes of the portion of the symbol table" "that is stored in flash.")) (code ((symtab-size-flash))) nil)) newline hline) (table closure (heade

(env-get 13)

((symbol-table-size-names newline (section 3 "symtab-size-names" ((para ("`symtab-size-names` returns the size in bytes of the string names stored in" "the symbol table.")) (code ((symtab-size-names))) nil)) newline hline) (render-code-res-raw-pairs closur

(env-get 14)

((symbol-table-size-names-flash newline (section 3 "symtab-size-names-flash" ((para ("`symtab-size-names` returns the size in bytes of the string names stored in" "the symbol table in flash.")) (code ((symtab-size-names-flash))) nil)) newline hline) (rende

(env-get 15)

((chapter-symboltable section 2 "Symbol table" ((newline (section 3 "symtab-size" ((para ("`symtab-size` returns the size of the symbol table in bytes.")) (code ((symtab-size))) nil)) newline hline) (newline (section 3 "symtab-size-flash" ((para ("`symtab-

(env-get 16)

((version newline (section 3 "lbm-version" ((para ("`lbm-version` returns the version of the lbm runtime system.")) (code ((lbm-version))) nil)) newline hline) (code-examples closure (c) (list (quote code-examples) c) nil))

(env-get 17)

((endian newline (section 3 "lbm-endian" ((para ("`lbm-endian` returns the endianness of the system lbm is running on.")) (code ((lbm-endian))) nil)) newline hline) (end) (glob-yeet))

(env-get 18)

((arch newline (section 3 "is-64bit" ((para ("`is-64bit` returns true if a 64bit version of lbm is running.")) (code ((is-64bit))) nil)) newline hline) (s+ closure (s ss) (cons s ss) nil) (eval-animation closure (gif c frames) (progn (setq frame-i 0) (setq

(env-get 19)

((word newline (section 3 "word-size" ((para ("`word-size` returns 4 on 32bit LBM  and 8 on 64bits.")) (code ((word-size))) nil)) newline hline) (ref-entry closure (str strings-or-tags) (let ((tags (and (rest-args 0) strings-or-tags)) (strings (or (rest-ar

(env-get 20)

((chapter-versioning section 2 "Version" ((newline (section 3 "lbm-version" ((para ("`lbm-version` returns the version of the lbm runtime system.")) (code ((lbm-version))) nil)) newline hline) (newline (section 3 "is-64bit" ((para ("`is-64bit` returns true

(env-get 21)

((hide-em newline (section 3 "hide-trapped-error" ((para ("The default behavior is to print error messages even if the error is trapped." "Trapped errors can be hidden by calling this function at the beginning of a program.")) (code ((hide-trapped-error)))

(env-get 22)

((show-em newline (section 3 "show-trapped-errors" ((para ("If you have hidden trapped errors they can be toggled back to being showed again" "using this function.")) (code ((show-trapped-error))) nil)) newline hline) (chapter-scheduling section 2 "Schedul

(env-get 23)

((chapter-errors section 2 "Errors" ((newline (section 3 "hide-trapped-error" ((para ("The default behavior is to print error messages even if the error is trapped." "Trapped errors can be hidden by calling this function at the beginning of a program.")) (

(env-get 24)

((manual (section 1 "LispBM Runtime Extensions Reference Manual" ((para ("The runtime extensions, if present, can be either compiled" "in a minimal or a full mode." "In the minimal mode only `set-eval-quota` is present." "Minimal mode is the default when c

(env-get 25)

((render-manual closure nil (let ((h (fopen "runtimeref.md" "w")) (r (lambda (s) (fwrite-str h s)))) (progn (gc) (var t0 (systime)) (render r manual) (print "Runtime reference manual was generated in " (secs-since t0) " seconds"))) nil) (pretty-toplevel-li

(env-get 26)

((chapter-threads section 2 "Threads" ((newline (section 3 "mailbox-get" ((para ("`mailbox-get` returns the mailbox contents of a thread as a list." "The form of a `mailbox-get` expression is `(mailbox-get pid)`." "Note that `mailbox-get` does **NOT** empt

(env-get 27)

((num-free newline (section 3 "mem-num-free" ((para ("`mem-num-free` returns the number of free words in the LBM memory." "This is the memory where arrays and strings are stored.")) (code ((mem-num-free))) nil)) newline hline) (render-code-res-pairs closur

(env-get 28)

((longest-free newline (section 3 "mem-longest-free" ((para ("`mem-longest-free` returns the length in words of the longest" "consecutive sequence of free words in the LBM memory.")) (code ((mem-num-free))) nil)) newline hline) (info para ("This document w

(env-get 29)

((memory-size newline (section 3 "mem-size" ((para ("`mem-size` returns the size of the LBM memory.")) (code ((mem-size))) nil)) newline hline) (para closure (str) (list (quote para) str) nil) (bullet closure (ss) (verb (map (lambda (x) (str-merge "   - " 

(env-get 30)

((heap-state newline (section 3 "lbm-heap-state" ((para ("`lbm-heap-state` can be used to query information about heap usage.")) (code ((lbm-heap-state (quote get-heap-size)) (lbm-heap-state (quote get-heap-bytes)) (lbm-heap-state (quote get-num-alloc-cell

(env-get 31)

((chapter-memory section 2 "Memory" ((newline (section 3 "mem-num-free" ((para ("`mem-num-free` returns the number of free words in the LBM memory." "This is the memory where arrays and strings are stored.")) (code ((mem-num-free))) nil)) newline hline) (n

(if (eq (env-get 1) nil) (env-set 1 (list '(a . 75))))
(env-get 1)

((gc-is-always-gc newline (section 3 "is-always-gc" ((para ("The `is-always-gc` predicate is true if LBM is built with the LBM_ALWAYS_GC debug flag.")) (code ((is-always-gc))) nil)) newline hline) (str-merge-list closure (strings) (match strings (nil [0]) 

(env-drop 'a '((a . 10) (b . 20) (c . 30)))

((b . 20) (c . 30))

(local-env-get)

nil

(let ((a 50))
     (local-env-get))

((a . 50) (res-str . $placeholder) (res (a . 50) (res-str . $placeholder) (res (a . 50) (res-str . $placeholder) (res (a . 50) (res-str . $placeholder) (res (a . 50) (res-str . $placeholder) (res (a . 50) (res-str . $placeholder) (res (a . 50) (res-str . $

(global-env-size)

104u

(set-gc-stack-size 100)

t

(is-always-gc)

nil

(mem-num-free)

120853

(mem-num-free)

120789

(mem-size)

128000

(lbm-heap-state 'get-heap-size)

100000u

(lbm-heap-state 'get-heap-bytes)

800000u

(lbm-heap-state 'get-num-alloc-cells)

13803u

(lbm-heap-state 'get-num-alloc-arrays)

771u

(lbm-heap-state 'get-gc-num)

1u

(lbm-heap-state 'get-gc-num-marked)

4609u

(lbm-heap-state 'get-gc-num-recovered-cells)

95391u

(lbm-heap-state 'get-gc-num-recovered-arrays)

0u

(lbm-heap-state 'get-gc-num-least-free)

95391u

(lbm-heap-state 'get-gc-num-last-free)

95391u

(set-eval-quota 30)

t

(symtab-size)

0u

(symtab-size-flash)

2348u

(symtab-size-names)

0u

(symtab-size-names-flash)

2348u

(define f (lambda nil
            (progn 
                (sleep 1)
                (f))))

(closure nil 
  (progn 
      (sleep 1)
      (f))
  nil)

(define pid (spawn f))

14235

(send pid "hello world")

t

(send pid (list 1 2 3))

t

(send pid 'apa)

t

(mailbox-get pid)

("hello world" (1 2 3) apa)

(lbm-version)

(0 36 0)

(is-64bit)

nil

(word-size)

4