marcuskammer/emacs.d
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update clones

Browse source
This commit is contained in:
Marcus Kammer 2022-10-07 19:32:11 +02:00
parent 7e48bb96c8
commit 0370a2eecf
Signed by: marcuskammer
GPG key ID: C374817BE285268F
506 changed files with 76893 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

94
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/alterFunction.cl.html Normal file
View file

@ -0,0 +1,94 @@
#! /usr/bin/gcl -f
; f computes square of x
(defun f (x) (* x x))
; show the function in use
(format t "f(3) gives square of 3: ~A~%" (f 3))
; try to display the component's of f
(format t "~%The original structure of f is:~%")
(dolist (component (function f))
(format t "the next component of f is ~A~%" component))
; all functions are stored as either in one of three forms:
;
; for functions created using defun
; (lambda-block functionName parameterList body)
;
; for functions created using labels
; (lambda-block-closure envList1 envList2 envList3 functionName parameterList body)
; note that envLists 2/3 can be circular lists, so if we print them we
; must first set *print-circle* to true to enable circle detection
;
; for functions created using closures
; (lambda-closure envList1 envList2 envList3 parameterList body)
;
; for lambda expressions that have not yet been evaluated into functions
; (lambda parameterList body)
;
; the first environment list consists of a list of pairs, identifying
; all the in-scope parameters and local variables and their current values
;
; the other two lists identify the block scopes in which the function was created
; thus if we want to examine the content of any (not-compiled) function, we can use:
; for functions defined using defun
; the car of f is 'lambda-block
; the cadr of f is the function name
; the caddr of f is the parameter list
; the cdddr of f is the body of f
; for functions defined using labels
; the car of f is 'lambda-block-closure
; the next three elements are environment lists, specifying
; - local variable/parameters and their values
; - creation environment 1
; - creation environment 2
; the caddr of (cddr f) is the function name
; the cadddr of (cddr f) is the parameter list
; the cddddr of (cddr f) is the body of f
; for functions defined otherwise (flet, closures, lambda)
; the car of f is 'lambda-closure
; the next three elements are environment lists, specifying
; - local variable/parameters and their values
; - creation environment 1
; - creation environment 2
; the caddr of (cddr f) is the parameter list
; the cdddr of (cddr f) is the body of f
; for lambda expressions that have not yet been evaluated to form functions
; the car of f is 'lambda
; the cadr of f is the parameter list
; the cddr of f is the body
; try to change the body of f to just x
(setf (cdddr (function f)) (list 'x))
; try to display the component's of f
(format t "~%The new structure of f is:~%")
(dolist (component (function f))
(format t "the next component of f is ~A~%" component))
; try to call f
(format t "~%calling the altered function, f(3) is ~A~%" (f 3))
; note that we can alter the name inside the function,
; but lisp's symbol table wouldn't know about that so
; wouldn't let us call it through the new name
; we can, however, create a function and associate it with
; any existing symbol (whether that used to be a variable
; or a function)
(defvar foo nil)
(setf (symbol-function 'foo) (lambda (x) (format t "inside foo, x is ~A~%" x)))
(format t "calling the new function through symbol foo~%")
(foo 3)
(format t "Is f bound to a function? ~A~%" (fboundp 'f))
(format t "Is foo bound to a function? ~A~%" (fboundp 'foo))

13
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/append.cl.html Normal file
View file

@ -0,0 +1,13 @@
(defun myappend (L1 L2)
(cond
; error checking
((not (listp L1)) (format t "cannot append, first argument is not a list~%" L1))
((not (listp L2)) (format t "cannot append, second argument is not a list~%" L2))
; base cases
((null L1) L2)
((null L2) L1)
; general case, neither list is empty
(t (cons (car L1) (myappend (cdr L1) L2)))))

27
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/apply.cl.html Normal file
View file

@ -0,0 +1,27 @@
#! /usr/bin/gcl -f
; (apply 'function '(list of operands))
; -------------------------------------
; apply is used to run a function against a specific set of parameters,
; e.g. to get the effect (function op1 op2 op3)
; we would use (apply 'function (op1 op2 op3))
; use apply to run (- 1 2 3 4)
(setf x (apply '- '(1 2 3 4)))
; print the result
(format t "~A~%" x)
; explanation of the successive - operations:
; (((1-2) - 3) - 4) gives -8
; function to apply a function to a list of arguments
(defun applyTo (f L)
(cond
((not (functionp f)) (format t "~A is not a function~%" f))
((not (listp L)) (format t "~A is not a list of operands~%" L))
(t (apply f L))))
(applyTo 'format '(t "hello!~%"))
(format t "3+3 is ~A~%" (applyTo '+ '(3 3)))

21
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/approxeq.cl.html Normal file
View file

@ -0,0 +1,21 @@
; (approxeq x y)
; --------------
; return true if x and y are equal
; or if x and y are numeric and within 0.001% of each other
; return nil otherwise
(defun approxeq (x y)
"(approxeq x y) true if value of x is within 0.001% of value of y"
(let ((precision 0.00001) ; allowable difference, 0.01 is 1%
(denom x)) ; either x or y, whichever is nonzero
(diffratio 0) ; will be set to abs(x-y)/denom
(cond
((not (numberp x)) (eq x y)) ; if not numbers just use eq
((not (numberp y)) nil) ; x is number, y isn't
((= x y) t) ; quick check if they are truly equal
(t (block
(setf denom (if (= 0 x) y) x) ; pick nonzero element of x,y
(setf diffratio (abs (/ (- x y) denom))) ; calc abs(x-y)/denom
(if (< diffratio precision) t nil) ; see if meets precision reqs.
)))))

16
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/arrSlice.cl.html Normal file
View file

@ -0,0 +1,16 @@
#! /usr/bin/gcl -f
; (getArrSlize arr rowNum)
; ------------------------
; given an array and a row number,
; get one row of an array as a vector
(defun getArrSlice (arr rowNum)
(make-array (array-dimension arr 1)
:displaced-to arr
:displaced-index-offset (* rowNum (array-dimension arr 1))))
; try it out
(defvar arr (make-array '(3 4) :initial-element 1))
(format t "~%as array:~%~A~%~%" arr)
(format t "~%as list:~%~A~%~%" (getArrSlice arr 1))

27
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/arrays.cl.html Normal file
View file

@ -0,0 +1,27 @@
#! /usr/bin/gcl -f
; function to print an arrays dimensions and contents
(defun prtArr (arr)
(cond
((not (arrayp arr)) (format t "Not an array ~A~%" arr))
(t (block
(format t "the array dimensions are ~A~%" (array-dimensions arr))
(format t "the length of dimension 0 is ~A~%" (array-dimension arr 0))
(format t "and its contents are ~A~%" arr)
)
)
)
)
; create a 3x4 array, initialize the contents to 0
(setf myArr (make-array '(3 4) :initial-element 0))
; set element [2][3] to -1
(setf (aref myArr 2 3) -1)
; set element [1][0] to 1
(setf (aref myArr 1 0) 1)
; pass the array to prtArr for display
(prtArr myArr)

46
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/ascSeqs.cl.html Normal file
View file

@ -0,0 +1,46 @@
#! /usr/bin/gcl -f
; (ascSeqs L)
; -----------
; given L is a list of numbers,
; return a list with the numbers in the same order
; but broken into lists of strictly ascending sequences
; e.g.
; (ascSeqs '(3 4 1 2)) ; returns ((3 4) (1 2))
; (ascSeqs '(1 2 0 3 3 11 4)) returns ((1 2) (0 3) (3 11) (4))
; returns nil if L is not a list of numbers
;
; uses a "private" accumulator to track what we've processed so far
(defun ascSeqs (L &optional (soFar 'ascSeqs_unstarted))
(cond
; basic error checking, L must be a list
((not (listp L)) nil)
; if this is the first call to ascSeqs, begin by reversing L
((equal soFar 'ascSeqs_unstarted) (ascSeqs (reverse L) nil))
; base case, return accumulated result
((null L) soFar)
; basic error checking, L's elements must be numbers
((not (numberp (car L))) nil)
; if this is the first value pulled from L, make it the
; the only element in the only list in soFar, then recurse
((null soFar) (ascSeqs (cdr L) (list (list (car L)))))
; if the next thing in L belongs at the start of the first
; sequence in soFar, add it to that sequence and rebuild soFar
((< (car L) (caar soFar)) (ascSeqs (cdr L)
(cons (cons (car L) (car soFar)) (cdr soFar))))
; otherwise the next thing in L belongs in a sequence of its own
; at the start of soFar
(t (ascSeqs (cdr L) (cons (list (car L)) soFar)))))
; ---- try out our function ----
(format t "Please enter a list of numbers:~%")
(defvar L (read))
(format t "The asc sequences of ~A are:~%~A~%" L (ascSeqs L))

237
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/bfs.cl.html Normal file
View file

@ -0,0 +1,237 @@
; (bfs Graph StartList)
; -------------------------
; assuming Graph represents a directed graph expressed as a
; list of pairs of the form (vertexid adjacencylist),
; where all vertices are specified by an integer id,
; and assuming StartList is a list of vertices in the graph
; to use as starting points,
; return a list of ids of all the vertices in the graph
; reachable from at least one of the starting vertices
; return nil if the graph is invalid
; (invalid structure, or contains multi-edges, or contains self-edges)
(defun bfs (Graph StartList)
(let
; list of local vars
( ; Ghash is the hash table of vertex ids - adjacency lists
(Ghash (make-hash-table))
)
; check if Graph is a valid pairs list
(if (pairsList Graph)
; if ok so far, try adding the pairs to the table
; and set ok to the result
(if (addpairs Graph Ghash)
; if ok so far, check for undeclared destination vertices
; (i.e. a vertex id in an adj list isn't a key in Ghash)
; for self edges (a vertex id is in its own adj list)
; and for duplicate edges (an adj list contains duplicate ids)
(if (checkdest Graph Ghash)
; if ok so far, check that all the vertices in StartList are valid
(if (keyList StartList Ghash)
; if ok so far, then call (bfsInternal Ghash ProcessList ReachableList)
; using the StartList with duplicates removed as the vertices
; need to be processed and the list of reachable vertices
(bfsInternal Ghash (removeDups StartList) (removeDups StartList))
; if any of the above if statements failed generate an error message and return nil
(errmsg "keyList failed"))
(errmsg "checkdest failed"))
(errmsg "addpairs failed"))
(errmsg "pairsList failed"))
)
)
; (bfsInternal GraphHash ProcessList ReachableList)
; -----------------------------------------
; given that GraphHash is the hash table representation of
; vertices and their adjacency lists,
; and that ProcessList is the list of current exploration points,
; and ReachableList is the list of known reachable vertices,
; complete the exploration and return the list of
; all reachable vertices
(defun bfsInternal (GraphHash ProcessList ReachableList)
(cond
; if ProcessList is empty, we are done
((eq ProcessList '()) ReachableList)
; otherwise update the reachable list based
; on what is connected to the next element
; and continue exploring with the rest of the process list
(t (let ( ; use locals to look up the current key/value
(vertex (car ProcessList))
(adjlist (removeDups (gethash (car ProcessList) GraphHash)))
)
(bfsInternal GraphHash
; the new process list is the tail of the old one plus any
; newly reachable vertices from the current source vertex
(append (cdr ProcessList)
(diff adjlist ReachableList))
; the new reachable list is the old one plus any additional
; vertices reachable from the current source vertex
(append ReachableList
(diff adjlist ReachableList)))))
)
)
; (keyList L HT)
; -----------------------
; assuming hash table HT has already been filled,
; check that L is indeed a list,
; and that every element of L appears as a key in HT
(defun keyList (L HT)
(cond
; reject non-lists
((not (listp L)) (errmsg "Not a list"))
; accept empty lists
((eq L '()) T)
; reject if the head is an invalid key
((eq (gethash (car L) HT) nil) (errmsg "Invalid vertex id in list"))
; check the remainder of the list
(t (keyList (cdr L) HT))
)
)
; (errMsg M)
; ----------
; prints an error message and returns false
(defun errMsg (M)
(let () (format t "~A~%" M) nil)
)
; (msg M Val)
; ---------
; prints a message on one line and an indented value on the next
(defun msg (M Val)
(format t "~A~% ~A~%" M Val)
)
; (pairsList L)
; -------------
; checks that L is a list of pairs
(defun pairsList (L)
(cond
; reject non-lists
((not (listp L)) (errMsg "given non-list"))
; accept empty lists
((eq L '()) t)
; head of L must be a 2-element list
((not (listp (car L))) (errmsg "graph contains non-list in place of a vertex/adjlist pair"))
((not (eq (length (car L)) 2)) (errmsg "graph contains non-pair for key-value"))
; head of head of L must be an integer
((not (integerp (car (car L)))) (errmsg "non-integer vertex id"))
; second element of head of L must be a list
((not (list (car (cdr (car L))))) (errmsg "non-list in place of adj list"))
; if head is ok then check the rest of the list
(t (pairsList (cdr L)))
)
)
; (addpairs L HT)
; ---------------
; adds each (key value) pair in list L to hash table HT
; assumes L and HT have already been validated
(defun addpairs (L HT)
(if (eq L '()) t ; if L is empty we're done
; otherwise add the next key value pair to the hash table
; and call recursively on the remainder of the list
; note that if the value is an empty list we'll add the word 'empty
; instead, so on retrieval we can tell the difference between
; an empty adjacency list and a missing key
(let* ( ; use local vars for the key and value
(key (car (car L)))
(value (car (cdr (car L)))) ; 2nd element of the head
)
(if (eq value '()) (setf (gethash key HT) 'empty)
(setf (gethash key HT) value))
(addpairs (cdr L) HT)
)
)
)
; (removeDups List)
; -----------------
; return a copy of the list with duplicate elements removed
(defun removeDups (List)
(cond
((not (listp List)) '())
((< (length List) 2) List)
((not (member (car List) (cdr List))) (cons (car List) (removeDups (cdr List))))
(t (removeDups (cdr List)))
)
)
; (diff List1 List2)
; ------------------
; return the list of elements that are in List1 but not List2
(defun diff (List1 List2)
(cond
((not (listp List2)) List1)
((eq 0 (length List2)) List1)
((not (listp List1)) '())
((eq '() List1) '())
((member (car List1) List2) (diff (cdr List1) List2))
(t (cons (car List1) (diff (cdr List1) List2)))
)
)
; (containsDups L)
; -------------------
; returns true if L contains duplicate elements
(defun containsDups (L)
(cond
((not (listp L)) nil)
((< (length L) 2) nil)
((member (car L) (cdr L)) t)
(t (containsDups (cdr L)))
)
)
; (checkdest Graph Ghash)
; -----------------------
; assuming pairsList has already validated graph
; and addPairs has already built up Ghash,
; check for undeclared destination vertices
; (i.e. a vertex id in an adj list isn't a key in Ghash),
; for self edges (a vertex id is in its own adj list), and
; for duplicate edges (an adj list contains duplicate ids)
(defun checkdest (Graph Ghash)
(cond
((eq Graph '()) t) ; accept empty graph
(t (let* ( ; extract front vertex id and adj list,
; lookup corresponding hash table entry
(vertex (car (car Graph)))
(adjlist (car (cdr (car Graph))))
(entry (gethash vertex Ghash))
)
(cond
; accept vertices with no outgoing edges
((eq entry 'empty) t)
; reject vertices with no hash table entry
((eq entry nil) (errmsg "destination vertex is not defined in graph"))
; reject if adjlist is not a list
((not (listp adjlist)) (errmsg "non-list supplied instead of adjaency list"))
; reject self edges
((member vertex adjlist) (errmsg "graph invalid: contains self edge"))
; reject multi-edges
((containsDups adjlist) (errmsg "graph invalid: contains duplicate edges"))
; reject if any vertices in the adjacency list are not in the hash table
((not (keyList adjlist Ghash)) (errmsg "destination vertex not defined"))
; call recursively on rest of list
(t (checkdest (cdr Graph) Ghash))
)
))
)
)

56
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/bitcheck.cl.html Normal file
View file

@ -0,0 +1,56 @@
#! /usr/bin/gcl -f
; (checksum N)
; ------------
; checksum expects a parameter, N, as a non-negative integer
; whose least significant D bits are treated as data bits,
; and all higher bits are treated as check bits
; the function returns true iff the check bits represent a
; correct count of the number of zeros in the data bits
;
; e.g. (checksum 658 7)
; N last 12 bits 7 data bits preceeding check bits
; 658 001010010010 0010010 00101
; there are 5 zeroes in the data bits, which is the same as
; the binary value shown in the checkbits, so N is valid
;
; more examples, showing just 10 bits of N since all higher bits are 0's
;
; N check/databits Result (explanation)
; 658 101 0010010 valid (count is 5, 5 zeros in last 7 bits)
; 399 011 0001111 valid (count is 3, 3 zeros in last 7 bits)
; 100 000 1100100 invalid (count is 0, 4 zeros in last 7 bits)
; 723 101 1010011 invalid (count is 5, 3 zeros in last 7 bits)
; -7 N/A invalid (N is out of range)
; "foo" N/A invalid (N is incorrect data type)
;
;
(defun checksum (N &optional (D 7))
"returns t iff N is a non-negative integer representing a bit sequence whose last D bits are data and all preceding bits represent a count of the zeroes in the data bits"
(let ((count 0))
(cond
((not (integerp N)) nil)
((< N 0) nil)
(t (block 'checkTheSum
(dotimes (pos D)
(when (= 0 (logand N (ash 1 pos))) (incf count)))
(= count (logand D (ash N (- D)))))))))
; try our examples above
(let ((N 0))
(setf N 658) (format t "N: ~A, result: ~A~%" N (checksum N))
(setf N 399) (format t "N: ~A, result: ~A~%" N (checksum N))
(setf N 100) (format t "N: ~A, result: ~A~%" N (checksum N))
(setf N 723) (format t "N: ~A, result: ~A~%" N (checksum N))
(setf N -7) (format t "N: ~A, result: ~A~%" N (checksum N))
(setf N "foo") (format t "N: ~A, result: ~A~%" N (checksum N))
)
; sample run results:
; N: 658, result: T
; N: 399, result: T
; N: 100, result: NIL
; N: 723, result: NIL
; N: -7, result: NIL
; N: foo, result: NIL

12
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/bits.cl.html Normal file
View file

@ -0,0 +1,12 @@
; there are a number of bitwise logic operators,
; which assume a 2's complement form for their arguments:
; (lognot x)
; (logand x y) (lognand x y)
; (logior x y) (lognor x y) for inclusive-or
; (logxor x y) for exclusive-or
; there is also an arithmetic shift operation for 2's comp:
; (ash x 1) shifts x left 1, effectively multiplying by 2
; (ash x -1) shifts x right 1, effectively doing integer division by 2

34
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/block.cl.html Normal file
View file

@ -0,0 +1,34 @@
#! /usr/bin/gcl -f
; create a block of statements,
; can be placed anywhere a single statement would be,
; first element of the block is treated as its name (not evaluated)
; the return value of the block is the return value
; of the last statement
(block
myBlockName
(format t "this is my block~%")
(format t "return the list 1 2 3~%")
'(1 2 3)
)
; the name allows us to have nested blocks, and thus
; to use the name of a specific block when we want to
; do something like return-from, e.g.
(defvar result
(block
outer
(format t "in the outer block~%")
(block
inner
(format t "in the inner block~%")
(return-from outer 3))
(format t "back in the outer block~%"))) ; <-- never reached
(format t "after all loops, result is ~A~%" result)
; note that many of the different block forms (let, prog, etc)
; either use an implicit block name of nil
; or allow the programmer to assigne a name to the block

103
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/bstree.cl.html Normal file
View file

@ -0,0 +1,103 @@
#! /usr/bin/gcl -f
;(setf mytree (bstree))
; ---------------------
; builds a binary search tree (initially empty)
; whose nodes each contain a string key and an associated value,
; it returns a dispatcher that allows the user to do the following
; (funcall mytree 'insert key val) ; insert a new node in the tree
; (funcall mytree 'lookup key) ; returns the associated value or nil
; (funcall mytree 'prttree) ; prints the tree contents in sorted order
; internally tree nodes look like (key value leftsubtree rightsubtree)
; with '() indicating empty subtrees
(defun bstree (&optional (treeinit '()))
(let* ( ; fields of the tree class
(root treeinit) ; root of the tree
)
(labels (
; methods of the tree class
(lookup (key &optional (subtree root))
(cond
((not (stringp key)) nil)
((null subtree) nil)
((string= key (car subtree)) (cadr subtree))
((string< key (car subtree)) (lookup key (caddr subtree)))
(t (lookup key (cadddr subtree)))
))
(prttree (&optional (subtree root))
(when (not (null subtree))
(prttree (caddr subtree))
(format t "~A:~A~%" (car subtree) (cadr subtree))
(prttree (cadddr subtree))))
(insert (key value &optional (subtree root))
(cond
((not (stringp key)) nil) ; bad key
((null subtree) ; empty tree so far, insert in root
(setf root (list key value '() '())))
((string< key (car subtree)) ; goes in left subtree, i.e. the caddr
(if (null (caddr subtree))
; left is empty, insert here
(setf (caddr subtree) (list key value '() ()))
; left is not empty, go recursively
(insert key value (caddr subtree))))
(t (if (null (cadddr subtree)) ; goes in right subtree, i.e. the cadddr
; right is empty, insert here
(setf (cadddr subtree) (list key value '() ()))
; right is not empty, go recursively
(insert key value (cadddr subtree)))))))
; dispatch function for the tree
(lambda (command &optional key value)
(cond
((equalp command 'prttree) (prttree))
((equalp command 'lookup) (lookup key))
((equalp command 'insert) (insert key value))
)))))
(defvar mytree (bstree '()))
(setf other (bstree '()))
(format t "~%Printing empty tree~%")
(funcall mytree 'prttree)
(format t "~%Inserting nodes~%")
(funcall mytree 'insert "june" 30)
(funcall mytree 'prttree)
(funcall mytree 'insert "july" 31)
(funcall mytree 'prttree)
(funcall mytree 'insert "april" 30)
(funcall mytree 'prttree)
(funcall mytree 'insert "may" 31)
(funcall mytree 'prttree)
(funcall mytree 'insert "december" 31)
(funcall mytree 'prttree)
(funcall mytree 'insert "august" 31)
(funcall mytree 'prttree)
(funcall mytree 'insert "october" 31)
(funcall mytree 'prttree)
(funcall mytree 'insert "september" 30)
(funcall mytree 'prttree)
(funcall mytree 'insert "march" 31)
(funcall mytree 'prttree)
(funcall mytree 'insert "january" 31)
(funcall mytree 'prttree)
(funcall mytree 'insert "november" 30)
(funcall mytree 'prttree)
(funcall mytree 'insert "february" 28)
(format t "~%Printing tree of 12 keys~%")
(funcall mytree 'prttree)
(format t "~%Testing valid lookups~%")
(format t "Looking up january ~A~%" (funcall mytree 'lookup "january"))
(format t "Looking up february ~A~%" (funcall mytree 'lookup "february"))
(format t "Looking up march: ~A~%" (funcall mytree 'lookup "march"))
(format t "Looking up april ~A~%" (funcall mytree 'lookup "april"))
(format t "Looking up may ~A~%" (funcall mytree 'lookup "may"))
(format t "Looking up june ~A~%" (funcall mytree 'lookup "june"))
(format t "Looking up july ~A~%" (funcall mytree 'lookup "july"))
(format t "Looking up august ~A~%" (funcall mytree 'lookup "august"))
(format t "Looking up september ~A~%" (funcall mytree 'lookup "september"))
(format t "Looking up october ~A~%" (funcall mytree 'lookup "october"))
(format t "Looking up november ~A~%" (funcall mytree 'lookup "november"))
(format t "Looking up december ~A~%" (funcall mytree 'lookup "december"))
(format t "~%Testing invalid lookup~%")
(format t "Looking up foo ~A~%~%" (funcall mytree 'lookup "foo"))

66
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/buildRotate.cl.html Normal file
View file

@ -0,0 +1,66 @@
#! /usr/bin/gcl -f
; (buildRotate N)
; ---------------
; returns a function that takes a list, L, as a parameter and
; rotates the list by N positions
; (if L is not a list the function simply returns it,
; also just returns L in cases where N is invalid or < 1)
;
; construction algorithm:
; what should be built can be simplified based on N
; if N < 1 or invalid no rotation needed, so just return the original list
; (lambda (L) L)
; otherwise build the customized rotation out of value N
; (lambda (L)
; (cond
; ((not (listp L)) L) ; base case
; (t (let* ((len (length L)) ; get length of L for computing fN, lN
; (fN (mod N len)) ; if N > len we can drop the first k*len cycles,
; ; fN is amount of L that 'drops off' the left side
; (lN (- len fN)) ; lN is amount of L that winds up at front of list
; (if (< fN 1) L ; don't bother shifting if fN is 0
; ; general case, the lN tail elements followed by fN front elements
; (append (last L lN) (butlast L (- (length L) N)))))))))
(defun buildRotate (N)
(cond
((not (integerp N)) (lambda (L) L))
((< N 1) (lambda (L) L))
(t (lambda (L)
(cond
((not (listp L)) L)
((null L) L)
(t (let* ((len (length L))
(fN (mod N len))
(lN (- len fN)))
(if (< fN 1) L
(append (last L lN) (butlast L lN))))))))))
(defun main ()
(let ; local variables
((L nil) ; the list to be rotated
(N 0) ; the number of positions to rotate
(F nil) ; the constructed list rotation function
(R nil)) ; the resulting list
; get L and N
(format t "Enter the list to be rotated~%")
(setf L (read))
(format t "Enter the number of positions to rotate~%")
(setf N (read))
; build the rotation function
(setf F (buildRotate N))
; if F is a function, apply it to L
; otherwise display an error message
(if (functionp F) (setf R (funcall F L))
(format t "Returned function is not valid: ~A~%" F))
; display the final result
(format t "The final result is ~A~%" R)))
; run the main routine
(main)

36
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/calcGrade.cl.html Normal file
View file

@ -0,0 +1,36 @@
#! /usr/bin/gcl -f
; compute and display your grade so far from a list of mark data,
; where the format for each assessment item is
; (actualMark maxPossibleMark weight)
; the weight is 0..100 (representing the weight of that assessment
; item as a percent of the total grade
;
; for example, suppose so far you have:
; 12/16 on an assignment worth 10%,
; 20/24 on a midterm worth 21%
;
; (calcGrade '((12 16 10) (20 24 21)))
;
; With 31.0% of the assessment completed, your average so far is 80.64%
;
(defun calcGrade (marksList)
(cond
((not (listp marksList)) (format t "Invalid marks list: ~A~%" marksList))
((null marksList) (format t "No marks entered yet~%"))
(t (let ( (percent 0.0) (total 0.0) (mark 0) (max 0) (weight 0))
(dolist (m marksList)
(when (and (listp m) (= 3 (length m)))
(setf mark (car m))
(setf max (cadr m))
(setf weight (caddr m))
(when (and (> max 0) (>= mark 0) (>= max mark) (> weight 0) (<= weight 100))
(setf percent (+ percent weight))
(setf total (+ total (/ (* weight mark) max))))))
(format t "With ~A% of the assessment completed, " percent)
(format t "your average so far is ~5,2F%~%" (/ (* 100 total) percent))))))
; let's try it out with out example data:
(calcGrade '((12 16 10) (20 24 21)))

19
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/case.cl.html Normal file
View file

@ -0,0 +1,19 @@
#! /usr/bin/gcl -f
; examples using case for testing value of an item
; initialize a variable x (just for the sake of the example)
(defvar x 3)
; case acts much like a C switch statement
(case x
(0 (format t "x is 0~%"))
(1 (format t "x is 1~%"))
(2 (format t "x is 2~%"))
("hi" (format t "x is string hi~%"))
('(2 4 6) (format t "x is list (2 4 6)~%"))
(3 (format t "x is 3~%"))
(otherwise (format t "x is something else~%"))
)

18
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/catch.cl.html Normal file
View file

@ -0,0 +1,18 @@
; catch and throw work a little differently than in
; most languages:
;
; catch defines a block during which a throw may occur,
; rather like a try block in other languages
;
; while throw identifies which block it is exiting,
; and what value to return
;
; (this is essentially a re-branding of blocks and return-from)
(catch 'example ; example being the name of our block
(... do whatever ...)
(if (somecondition)
(throw 'example "nooooo.....")) ; exit the example block, returning "nooooo...."
(... do more stuff ...))

107
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/cfg.cl.html Normal file
View file

@ -0,0 +1,107 @@
; -----------------------------------------------------------------
; Context free grammar checker for lists of simple lisp expressions
;
; Note format statements are currently included to show the
; parsing sequence followed
; -----------------------------------------------------------------
; suppose our CFG grammar goes like this:
;
; StatementList --> A list of one or more statements
; Statement --> Value
; --> Expression
; Expression --> (UnaryOperator Statement)
; --> (BinaryOperator Statement Statement)
; BinaryOperator --> +, -, *, /
; UnaryOperator --> +, -
; Value --> symbol, integer
; (statementList s)
; -----------------
; statementList returns true if s is a list of one or more
; valid statements, nil otherwise
(defun statementList (s)
(format t "statementList check on ~A~%" s)
(cond
; s must be a non-empty list
((not (listp s)) nil)
((null S) nil)
; the first element of s must be a statement
((not (statement (car S))) nil)
; if there are no remaining elements then s passes
((null (cdr S)) t)
; otherwise check the remaining elements recursively
(t (statementList (cdr S)))))
; (statement s)
; -------------
; statement returns true if s is a valid Statement, nil otherwise
; valid statements are values or expressions
(defun statement (s)
(format t "statement check on ~A~%" s)
(cond
((value s) t)
((expression s) t)
(t nil)))
; (expression e)
; --------------
; returns true if e is a valid expression, nil otherwise
; valid expressions have either of the forms:
; (unaryOp statement) or (binaryOp statement statement)
(defun expression (e)
(format t "expression check on ~A~%" e)
(cond
; e must be a list with at least two elements
((not (listp e)) nil)
((< (length e) 2) nil)
; if e has length two then it must be a unary operator
; followed by an operand (statement)
((null (cddr e))
(and (unaryOp (car e)) (statement (cadr e))))
; if e has length three then it must be a binary operator
; followed by two operands (statements)
((null (cdddr e))
(and (binaryOp (car e)) (statement (cadr e)) (statement (caddr e))))
; e cannot have more than three elements
(t nil)))
; (binaryOp op)
; -------------
; returns true if op is a valid binary operator, nil otherwise
; binary operators are +, -, *, and /
(defun binaryOp (op)
(format t "binary op check on ~A~%" op)
(cond
((equalp op '+) t)
((equalp op '-) t)
((equalp op '/) t)
((equalp op '*) t)
(t nil)))
; (unaryOp op)
; -------------
; returns true if op is a valid operator, nil otherwise
; unary operators are + and -
(defun unaryOp (op)
(format t "unary op check on ~A~%" op)
(cond
((equalp op '+) t)
((equalp op '-) t)
(t nil)))
; (value v)
; ---------
; returns true if v is a symbol or an integer, nil otherwise
(defun value (v)
(format t "value check on ~A~%" v)
(cond
((integerp v) t)
((symbolp v) t)
(t nil)))

37
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/chars.cl.html Normal file
View file

@ -0,0 +1,37 @@
; char functions
; #\x is the literal character x
; special chars:
; #\Backspace #\Space #\Newline #\Tab
; #\Return #\Linefeed #\Rubout #\Page
; special chars within text literals
; "... \" ... "
(setf c1 #\q)
(setf c2 #\Q)
; convert cases
(char-upcase c1)
(char-downcase c2)
; convert between ascii and chars
(code-char 63) ; converts from ascii to char
(char-code #\a) ; converts from char to ascii
; compare characters
(char= c1 c2)
(char/= c1 c2)
(char<= c1 c2)
(char>= c1 c2)
(char< c1 c2)
(char> c1 c2)
(char= c1 c2)
; reading chars from streams
(read-char stream nil) ; read from stream, nil if end of stream
(peek-char stream nil) ; peek at next char in stream, nil if end of stream
(unread-char c stream) ; put c back into front of input stream

43
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/classify.cl.html Normal file
View file

@ -0,0 +1,43 @@
#! /usr/bin/gcl -f
; program to read all the command line arguments and classify them by their data type
; classify each element of the supplied argument list
(defun classifyAll (argList)
(dolist (arg argList)
(classifyElement arg)))
; classify an item by its data type
(defun classifyElement (elem)
(typecase elem
(string (format t "~A is a string~%" elem))
(vector (format t "~A is a vector~%" elem))
(array (format t "~A is an array~%" elem))
(list (format t "~A is a list~%" elem))
(hash-table (format t "~A is a hash table~%" elem))
(integer (format t "~A is an integer~%" elem))
(float (format t "~A is a floating point number~%" elem))
(real (format t "~A is a real number~%" elem))
(number (format t "~A is a number~%" elem))
(function (format t "~A is a function~%" elem))
(symbol (if (boundp elem) (format t "~A is a bound symbol~%" elem)
(format t "~A is a symbol~%" elem)))
(keyword (format t "~A is a keyword~%" elem))
(character (format t "~A is a character~%" elem))
(t (format t "~A is an unknown type~%" elem))
))
; main routine for the program
(defun main (argList)
(cond
; if no command line arguments are given, tell the user how to run the program
((null argList) (format t "Provide a list of arguments on the command line to have them classified~%"))
; under any other circumstances run the classification on the argument list
(t (classifyAll argList))
)
)
; run the program
(main (cdr si::*command-args*))

53
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/client.cl.html Normal file
View file

@ -0,0 +1,53 @@
#! /usr/bin/gcl -f
; (geturl hostname port filepath)
; -------------------------------
; create a connection to the specified host/port,
; get the file at the specified path,
; and return a list of the lines of output retrieved
; e.g. (geturl "csci.viu.ca" 80 "/~wesselsd/index.html")
(defun geturl (hostname port filepath)
(let
; set up the socket and connection
((sock (si::socket port :host hostname))
; initialize the results list as empty
(result nil))
; use unwind-protect to make sure we close the socket
; even if the loop terminates abnormally
(unwind-protect
(progn
; send the get request with format (4 lines including the blank line)
; GET filepath HTTP/1.1
; Host: hostname
; Connection: close
;
(format sock "GET ~A HTTP/1.1" filepath)
(format sock "~A~A" #\RETURN #\NEWLINE)
(format sock "Host: ~A" hostname)
(format sock "~A~A" #\RETURN #\NEWLINE)
(format sock "Connection: close")
(format sock "~A~A" #\RETURN #\NEWLINE)
(format sock "~A~A" #\RETURN #\NEWLINE)
(force-output sock)
; read the response and display it, one line at a time
(loop
(let
; current line
((line (read-line sock nil nil)))
(unless line (return)) ; quit when read-line returns nil
(setq result (cons line result)))))
; last step of unwind: we close the socket
; ... currently this is producing a spurious error message ...
(close sock))
; note the lines of output are currently stored in reverse order,
; so re-arrange them before we return them
(reverse result)))
; test out our geturl
(defvar contents (geturl "csci.viu.ca" 80 "/~wesselsd/courses/csci330/index.html"))
(format t "~%Result:~%~%~A~%~%" contents)

70
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/closure.cl.html Normal file
View file

@ -0,0 +1,70 @@
#! /usr/bin/gcl -f
; CLOSURES: functions that build and return customized versions of functions
;
; (buildAdder N)
; -------------------
; builds and returns a function to manipulate numbers
; the built function has the form (f x) and the purpose
; of the function is return (x+N)
(defun buildAdder (N)
(lambda (x) (+ x N)))
; build one function (f x) that returns 3+x
(setf f (buildAdder 3))
; build another, (g x), that returns 0.1+x
(setf g (buildAdder 0.1))
; apply both functions to a variable
(defvar i 0)
(format t "initial value ~A~%" i)
(format t "after applying f (adds 3) ~A~%" (funcall f i))
(format t "after applying g (adds 0.1) ~A~%" (funcall g i))
(format t "(funcall (buildAdder 2) 4) gives ~A~%" (funcall (buildAdder 2) 4))
; Name clashes with dynamic variables (e.g. defvars)
; --------------------------------------------------
; Consider our buildAdder solution above in the circumstances where
; the user does something like this:
(defvar N 3)
(defvar h (buildAdder N))
(setf N 12)
(format t "Adding 3 to 5 gives: ~A~%" (funcall f 5))
; The result displayed is 17!
; The lambda function looks like (lambda (x) (+ x N))
; so when it runs in the call above it grabs the current
; value for N, i.e. 12, not the N value we passed to buildAdder
;
; One solution is to have our buildAdder use a let block with a
; local variable name that (hopefully) will not clash with
; any dynamically-scoped variables when called, e.g.
(defun betterBuilder (N)
(let ((betterBuilderLocal N))
(lambda (x) (+ x betterBuilderLocal)))
; Where would you really use closures?
; ------------------------------------
;
; Any situation where you would like to use a custom built function many
; times during a run of your program, but don't know the precise nature
; of the customization until runtime.
;
; Suppose you want to customize elements of a web page, and need to
; generate those customized elements many times with different data content,
; and as rapidly as possible, but you won't know until runtime what the
; specific customization is.
;
; To solve this, you add a function whose parameters define the possible
; customizations, and at runtime that function builds and returns the
; function that actually builds the specialized element.
;
; During the run of the program you can call the customized function as
; often as needed, passing it the data content.

1033
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/cmpinclude.h Normal file
View file

File diff suppressed because it is too large Load diff

37
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/columnizer.cl.html Normal file
View file

@ -0,0 +1,37 @@
; (buildColumnizer N W)
; ---------------------
; creates and returns a lambda function for printing lists
; that are formatted to a specified column width (W)
; and number of columns per row (N)
; e.g.
; (defvar prt (buildColumnizer 5 20))
; (funcall prt '(1 2 3 4 5 6 7 8 9 10 11 12))
; would print the list in rows of 5 columns,
; each column padded to a minimum width of 20
(defun buildColumnizer (N W)
(cond
; make sure N and W are valid values to build the function with
((or (not (integerp N)) (< N 1))
(format t "Error: number of columns (~A) must be a positive integer~%" N))
((or (not (integerp W)) (< W 1))
(format t "Error: column width (~A) must be a positive integer~%" W))
; use locals for number of columns, column width, and the format string
; the constructed function will use (e.g. "~20A")
(t (let* ((Cols N) (Width W) (fstr (format nil "~~~AA" Width)))
; generate the actual prt function to be returned
(lambda (L)
(let ((index 1)) ; tracks position on current row
(if (not (listp L)) (format t "Error: must be a list (~A)~%" L)
(dolist (e L)
(block 'prtNincrement
; print the element using the format string
(format t fstr e)
; see if we need to print a newline
(if (= index Cols) (format t "~%"))
; update index (either index++ or set to 1 to start new row)
(if (= index Cols) (setf index 1) (setf index (+ index 1))))))))))))

6
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/commandLine.cl.html Normal file
View file

@ -0,0 +1,6 @@
#! /usr/bin/gcl -f
; display the command line arguments passed to the script
(format t "this script is named: ~A~%" (car si::*command-args*))
(format t "the command line arguments the user entered were: ~A~%" (cdr si::*command-args*))

52
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/compile.cl.html Normal file
View file

@ -0,0 +1,52 @@
#! /usr/bin/gcl -f
; to compile an entire file into an executable, follow these steps:
; (1) create the source code, e.g. file myprog.cl
; and do NOT include the #! line in the file
; (2) in myprog.cl, define a function called si::top-level,
; this is the one where execution will automatically start,
; e.g. here we have it simply call our "main" function
; (defun si::top-level () (main))
; (3) open the interpretter and issue these commands:
; (compile-file "myprog.cl") ; creates myprog.o
; (load "myprog.o")
; (si::save-system "myprog") ; creates executable
; (4) you can now run your program in linux using ./myprog
; Note: the executable includes a lot of lisp environment information,
; so tends to be significantly larger than typical linux executables
; define two interpretted functions
(defun f (x y) (* x y))
(defun g (x y) (/ x y))
; compile a function g
(format t "~%Compiling function G~%")
(compile 'g)
; create a lambda function, store in variable h1
(format t "~%Creating lambda function, storing in h1~%")
(defvar h1 (lambda (x y) (+ x y)))
; create and compile a lambda function, store in variable h2
(format t "~%Compiling lambda function, storing in h2~%")
(defvar h2 (compile nil '(lambda (x y) (max x y))))
; compile and load another file, test.cl, which defines t1(x,y)
(format t "~%Compiling file test.o (containing definition of function t1)~%")
(compile-file "compileTest.cl" :output-file "compileTest.o")
(load "compileTest.o")
; call the five functions
(format t "~%f(2,3): ~A~%" (f 2 3))
(format t "g(2,3): ~A~%" (g 2 3))
(format t "h1(2,3): ~A~%" (apply h1 '(2 3)))
(format t "h2(2,3): ~A~%" (apply h2 '(2 3)))
(format t "t1(2,3): ~A~%" (t1 2 3)))
; use function to see the form of the functions
(format t "~%function(f): ~A~%" (function f))
(format t "function(g): ~A~%" (function g))
(format t "h1: ~A~%" h1)
(format t "h2: ~A~%" h2)
(format t "function(t1): ~A~%~%" (function t1))

30
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/cond.cl.html Normal file
View file

@ -0,0 +1,30 @@
#! /usr/bin/gcl -f
; examples using cond for condition testing
(defvar x 3)
(cond
; series of pairs, each pair consists of a boolean expression and
; the result to return if that expression is true
; the pairs are examined in order,
; the return value of the cond is the return value of the
; first pair whose boolean expression is true
((< x 0) -1) ; if x < 0 return -1
((> x 0) (- 0 x)) ; if x > 0 return negative x
(t 0) ; by default (since t is always true) return 0
)
; example chaining multiple statements together in one case of cond
(setf x '(1 2 3))
(cond
; if x is nil print an error message and return 0
((null x) (format t "x is empty~%") 0)
; else print a message and return the first element
(t (format t "x has length ~A~%" (length x)) (car x)))
; defining a constant named else to use as the default for cond
(defconstant else t)
(setf x 3)
(cond
((< x 0) -1)
((= x 0) 0)
(else 1))

20
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/countAll.cl.html Normal file
View file

@ -0,0 +1,20 @@
; (countAll L)
; ------------
; if L is not a list this returns 1
; otherwise it returns the number of elements
; contained in L and any sublists of L
; e.g. (countAll 1) returns 1
; (countAll '()) returns 0
; (countAll '(1 2 '())) returns 2
; (countAll '(1 2 3 4)) returns 4
; (countAll '((1 2) 3 (4 5 (6 7 8) (9 10)))) returns 10
(defun countAll (L)
(cond
((not (listp L)) 1)
((eq L '()) 0)
((eq (length L) 1) (countAll (car L)))
(t (+ (countAll (car L)) (countAll (cdr L))))
)
)

16
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/data.cl.html Normal file
View file

@ -0,0 +1,16 @@
; basic data types
; t is true, nil is false, nil and '() are equivalent
; text is put in double quotes "blah blah blah"
; characters are represented with #\, e.g. #\Q
; numbers supported include
; integers, eg 123
; fixed point, e.g. 123.456
; exp. notation, e.g. 1.23456e8
; rationals, e.g. 1/3
; complex, e.g. #c(5 6) represents (5 + 6i)
; lists are represented within parenthesis, and preceeded by a ', e.g.
; '(1 2 3 4 5)
; '("foo" #\y 5.43 (1 2 3))

33
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/debug.txt Normal file
View file

@ -0,0 +1,33 @@
Common errors/resulting messages in common lisp (gcl specifically):
1. You put the #! line in a file then try to load it, i.e. (load "filename.cl")
Error message: "BROKEN AT LOAD"
2. You're missing a ) somewhere
Error message: "END-OF-FILE :STREAM <path-to-your-lisp-file>"
3. You're missing a "
No error message, it just hangs waiting to find another "
4. You forget the ' in front of a data list
or you put ( ) around a data value, e.g. (3)
Error message: TYPE-ERROR :DATUM the front element of the list :EXPECTED-TYPE FUNCTION
5. You pass an incorrect data type to an operator or function
Error message: TYPE-ERROR :DATUM the value you passed :EXPECTED-TYPE the kind of data it expected
6. You use an undeclared variable (or undeclared in the current scope)
Error message: UNBOUND-VARIABLE :NAME your variable name
7. You use an undeclared function (or undeclared in the current scope)
Error message: UNBOUND-FUNCTION :NAME your function name
or: UNDEFINED-FUNCTION :NAME your function name
8. You call a function with the incorrect number of arguments
Error message: PROGRAM ERROR function name REQUIRES more/less THAN n ARGUMENTS
where n is the number of arguments you actually passed
9. You have infinite recursion
Error message: Frame Stack overflow

1977
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/dictionary.cl.html Normal file
View file

File diff suppressed because it is too large Load diff

18
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/diff.cl.html Normal file
View file

@ -0,0 +1,18 @@
; return a list whose elements are the elements of list1
; that do not also appear in list2
(defun diff (list1 list2)
(cond
; return nil if either of them are non-lists
((not (listp list1)) nil)
((not (listp list2)) nil)
; if list1 is empty then the result is an empty list
((null list1) nil)
; if list2 is empty then the result is all of list1
((null list2) list1)
; if the head of list1 isn't in list 2 then it belongs in the answer,
; call recursively on the tail of list1 to see what else belongs
((not (member (car list1) list2)) (cons (car list1) (diff (cdr list1) list2)))
; otherwise the head of list1 doesn't belong in the answer,
; call recursively on the tail of list1 to see what else may belong
(t (diff (cdr list1) list2))))

9
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/disassemble.cl.html Normal file
View file

@ -0,0 +1,9 @@
#! /usr/bin/gcl -f
; you can see the code the compiler produces for a function using
; disassemble, e.g.
(defun foo (x) (* x x))
(disassemble 'foo)

31
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/do.cl.html Normal file
View file

@ -0,0 +1,31 @@
; do loops consist of three parts
; - a list of local variables, their initial values, and
; how they get updated at the end of each pass through the loop
; - the stopping condition for the loop and
; a list of statements to execute after the loop stops
; (the return value of do is the return value of the last statement)
; - the body of the loop: the statements to execute each pass
(do
; initialization/update descriptions
( (x 0 (+ x 1)) ; x = 0 initially, add 1 after every pass
(y 10 (+ y 2))) ; y = 10 initially, add 2 after every pass
; stopping section
( ; stopping condition
(OR (= x 10) (> y 15)) ; stop if (x == 10) or (y > 15)
; actions to perform after stopping
(format t "~%exited loop~%" x)
(format t "x stopped at ~A~%" x)
(format t "y stopped at ~A~%" y)
(format t "returning ~A~%" (+ x y))
; return value
(+ x y))
; loop body
(format t "inside loop ~%")
(format t "x is currently ~A~%" x)
(format t "y is currently ~A~%" y))

11
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/docs.cl.html Normal file
View file

@ -0,0 +1,11 @@
#! /usr/bin/gcl -f
(defun foo (x)
; the documentation string for a function goes immediately after the parameter list
"foo does nothing"
(if (< x 0) T nil))
; lookup the documentation string using (documentation 'func 'foo)
(format t "Docs information:~%~A~%" (documentation 'foo 'function))

15
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/dolist.cl.html Normal file
View file

@ -0,0 +1,15 @@
#! /usr/bin/gcl -f
; example of dolist to iterate through a list
; print each element of a list
(defvar L '(1 2 3 4))
(dolist
; variable to use for iterating through L
(x L)
; expression to apply to each element (x) of L
(format t "x is ~A~%" x)
)

16
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/dotimes.cl.html Normal file
View file

@ -0,0 +1,16 @@
; dotimes allows us to iterate a fixed number of times,
; allowing us to specify an index variable,
; the number of times to repeat,
; and the expression to use as a return value
;
; e.g.
; (dotimes (x 5 (* x 2)) (format t "Hi ~A~%" x))
; displays
; Hi 0
; Hi 1
; Hi 2
; Hi 3
; Hi 4
; and returns 10

15
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/dribble.cl.html Normal file
View file

@ -0,0 +1,15 @@
#! /usr/bin/gcl -f
; you can record everything that happens in a lisp session using
; (dribble "filename") to start and (dribble) to finish, e.g.
(dribble "mylog.txt")
(format t "begin experimenting~%")
(defun foo (x) (* x x))
(defvar a 3)
(defvar b (foo a))
(format t "foo(~A) is ~A~%" a b)
(dribble)

61
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/effects.cl.html Normal file
View file

@ -0,0 +1,61 @@
; a collection of ascii-based screen manipulation functions
; set up a global constant to represent the escape character
(defconstant Escape (code-char 27))
; clear the screen by printing an ascii control sequence
(defun clearscrn ()
(format t "~A[2J~A[H" Escape Escape))
; move the cursor to a set row column position
; where (1 1) is the upper left corner
(defun moveCursor (row col)
(format t "~A[~A;~AH" Escape row col))
; colour manipulation functions use the following colours:
; Black, Red, Green, Yellow, Blue, Purple, Pale, Grey, or Default
; or Help to get this list
; set the colour of text
(defun textColour (colour)
(cond
((equalp colour 'Help) (format t "Available colours: Black, Red, Green, Yellow, Blue, Purple, Pale, Grey, (anything else for default)"))
((equalp colour 'Black) (format t "~A[30m" Escape))
((equalp colour 'Red) (format t "~A[31m" Escape))
((equalp colour 'Green) (format t "~A[32m" Escape))
((equalp colour 'Yellow) (format t "~A[33m" Escape))
((equalp colour 'Blue) (format t "~A[34m" Escape))
((equalp colour 'Purple) (format t "~A[35m" Escape))
((equalp colour 'Pale) (format t "~A[36m" Escape))
((equalp colour 'Grey) (format t "~A[37m" Escape))
(t (format t "~A[0m" Escape))))
; set the background colour
(defun bkgdColour (colour)
(cond
((equalp colour 'Help) (format t "Available colours: Black, Red, Green, Yellow, Blue, Purple, Pale, Grey, (anything else for default)"))
((equalp colour 'Black) (format t "~A[40m" Escape))
((equalp colour 'Red) (format t "~A[41m" Escape))
((equalp colour 'Green) (format t "~A[42m" Escape))
((equalp colour 'Yellow) (format t "~A[43m" Escape))
((equalp colour 'Blue) (format t "~A[44m" Escape))
((equalp colour 'Purple) (format t "~A[45m" Escape))
((equalp colour 'Pale) (format t "~A[46m" Escape))
((equalp colour 'Grey) (format t "~A[47m" Escape))
(t (format t "~A[0m" Escape))))
; set text effects, options are
; Faint, Negative, Normal, AltFont, Underline, Bold, Clear
; or Help to get this list
(defun textEffect (effect)
(cond
((equalp effect 'Help) (format t "Available effects: Faint, Negative, Normal, AltFont, Underline, Bold, Clear"))
((equalp effect 'Clear) (format t "~A[0m" Escape))
((equalp effect 'Bold) (format t "~A[1m" Escape))
((equalp effect 'Underline) (format t "~A[4m" Escape))
((equalp effect 'Faint) (format t "~A[5m" Escape))
((equalp effect 'Negative) (format t "~A[7m" Escape))
((equalp effect 'Normal) (format t "~A[10m" Escape))
((equalp effect 'AltFont) (format t "~A[12m" Escape))
(t (format t "~A[0m" Escape))))

50
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/efficiency.cl.html Normal file
View file

@ -0,0 +1,50 @@
; Notes on efficiency and maintainability
; ---------------------------------------
; Efficiency
; ----------
;
; while the logical behaviour is similar,
; internally the implementation of strings, vectors, arrays, and lists
; do in fact differ, and best efficiency can be obtained by using the
; most suitable type and operations
;
; the best choices, in order of decreasing effiency, are:
; string, access elements with (char str i)
; vectors, access elements with svref
; arrays, access elements with aref
; lists, access elements with nth
; sequences, access elements with elt
;
; if dealing with lists of values with particular meanings,
; use a struct rather than a positionally-accessed list
;
; favour iteration constructs over tail recursion, as these
; are more reliably optimized at compile time, and
; if you do use tail recursion, then don't use dynamically-scoped
; variables within the tail recursive functions, and ensure
; you identify and apply any necessary settings to ensure that
; tail recursion optimizations are actually applied
; favour dotimes and dolist over the more generalized loop
; features (again, more reliably optimized)
; Maintainability
; ---------------
; most common sense rules for program maintainability apply,
; a few things may be worth specifically noting:
;
; - avoid side effects where not needed
; - use (function f) or #'f, rather than just 'f when
; what you want to access is known to be a function
; - avoid runtime use of eval, #, and intern
; - avoid the use of dynamic scope where possible,
; a decent rule of thumb is to use it for situations
; where you need to do something with "the current" X,
; where what constitutes "the current" can be set in
; a variety of ways/places, but not so commonly as to
; make passing an additional parameter worthwhile
; if dealing with sequences of characters, use the string type
; if dealing with
;

54
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/equal.cl.html Normal file
View file

@ -0,0 +1,54 @@
#! /usr/bin/gcl -f
; set up some values for comparison
(setf x 3)
(setf y 3.0)
(setf z 3)
(setf L1 '(1 2))
(setf L2 '((1 2) 3))
(setf L3 (list L1 z))
(format t "x is 3, y is 3.0, z is 3~%")
(format t "L1 is (1 2), L2 is ((1 2) 3), L3 is (list L1 z)~%")
(format t "~%")
; equal does a structural comparison of the two values for equality
(format t "(equal x y): ~A~%" (equal x y))
(format t "(equal x z): ~A~%" (equal x z))
(format t "(equal x 3): ~A~%" (equal x 3))
(format t "(equal x 3.0): ~A~%" (equal x 3.0))
(format t "(equal L2 L3): ~A~%" (equal L2 L3))
(format t "~%")
; equalp and = true if two values are equivalent, e.g. 3 and 3.0
; but = is just for numbers
(format t "(equalp x y): ~A~%" (equalp x y))
(format t "(equalp x z): ~A~%" (equalp x z))
(format t "(equalp x 3): ~A~%" (equalp x 3))
(format t "(equalp x 3.0): ~A~%" (equalp x 3.0))
(format t "(equalp L2 L3): ~A~%" (equalp L2 L3))
(format t "~%")
(format t "(= x y): ~A~%" (= x y))
(format t "(= x z): ~A~%" (= x z))
(format t "(= x 3): ~A~%" (= x 3))
(format t "(= x 3.0): ~A~%" (= x 3.0))
(format t "~%")
; eql is true if the two things compared are actually the same object,
; of if a variable is compared to a character or number with the same value and type
(format t "(eql x y): ~A~%" (eql x y))
(format t "(eql x z): ~A~%" (eql x z))
(format t "(eql x 3): ~A~%" (eql x 3))
(format t "(eql x 3.0): ~A~%" (eql x 3.0))
(format t "(eql L2 L3): ~A~%" (eql L2 L3))
(format t "~%")
; eq is true iff the two things are actually the same object
(format t "(eq x y): ~A~%" (eq x y))
(format t "(eq x z): ~A~%" (eq x z))
(format t "(eq x 3): ~A~%" (eq x 3))
(format t "(eq x 3.0): ~A~%" (eq x 3.0))
(format t "(eq L2 L3): ~A~%" (eq L2 L3))
(format t "~%")
(setf a x)
(format t "a is set to x, (eq a x): ~A~%" (eq a x))

23
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/error.cl.html Normal file
View file

@ -0,0 +1,23 @@
#! /usr/bin/gcl -f
; define a constant as a unique default error value
(defconstant Err 'Err)
; use the constant in a function that tests lists
(defun nonemptyList (L)
(cond
((not (listp L)) Err)
((null L) Err)
(t t)))
; function to check if something is an error value
(defun errorp (e) (equalp e Err))
; ---- use example ---
(defvar list1 3)
(defvar list2 '(3))
(defvar result (nonEmptyList list1))
(format t "is ~A an ok list?: ~A~%" list1 (not (errorp result)))
(setf result (nonEmptyList list2))
(format t "is ~A an ok list?: ~A~%" list2 (not (errorp result)))

53
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/eval.cl.html Normal file
View file

@ -0,0 +1,53 @@
#! /usr/bin/gcl -f
; (eval '(expression))
; --------------------
; given a lisp expression as a list, eval can be
; used to evaluate it
; run eval on the list (+ 1 2 3 4)
(setf x (eval '(+ 1 2 3 4)))
; consider what happens if we run the following:
(setf x (eval (+ 1 2 3 4))) ; lisp evaluates the (+ 1 2 3 4) first,
; *then* runs (eval 10)
; examples of eval and quoting
(defvar x 1)
(eval x) ; 1 - lisp evaluates x as 1, then runs (eval 1)
(eval 'x) ; 1 - eval is looking up the value associated with symbol x
(eval (quote x)) ; 1 - as above
(eval '(quote x)) ; x
; print the result
(format t "~A~%" x)
; build an expression using cons then pass it to eval and print the result:
(format t "~A~%" (eval (cons '* '(10 20))))
; function that accepts an expression as a parameter and runs eval on it
(defun evalon (expr)
(eval expr))
(format t "result of (evalon '(sqrt 4)) is ~A~%" (evalon '(sqrt 4)))
; function that takes a list of expressions, L, as a parameter
; and runs eval on each of them, in order
(defun evalEach (L)
(cond
((not (listp L)) L)
((null L) nil)
(t (block
evalBlock
(eval (car L))
(evalEach (cdr L))))))
(evalEach '((format t "this is expression 1~%")
(format t "this is expression 2~%")))
; you can also specify the conditions under which eval will be run:
; - at compile time
; - at load time
; - at time of interpretation
(eval when (compile load eval) (format t "hi!"))

49
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/fileio.cl.html Normal file
View file

@ -0,0 +1,49 @@
#! /usr/bin/gcl -f
; test if a file exists using probe-file
(format t "checking for file fileio.cl: ~A~%" (probe-file "fileio.cl"))
; read the contents of a file
(with-open-file (stream "./fileio.cl")
(do
( ; local variable nextline is initialized with the first
; line of the file, and after each pass through the
; loop is gets the next line of the file
(nextline (read-line stream nil) (read-line stream nil)))
( ; stopping condition and actions
(null nextline) ; quits when nextline is null, ie eof
(format t "done!~%") ; message to print after quitting
)
; body of loop
(format t "current line: ~A~%" nextline)
)
)
; write some stuff to a file
(with-open-file
; set up the file specs
(stream "testfile.txt"
:direction :output ; opens for output
:if-exists :overwrite ; replace existing file
:if-does-not-exist :create) ; otherwise create new one
; action(s) to perform,
; here writing list to file
(format stream "~A~%" '(1 2 3 4)))
; we can delete an existing file using
; (delete-file "filename")
; a number of functions are provided to get file information based
; on the file name, e.g.
; (file-author "filename")
; (file-write-date "filename")
; (file-namestring "path/filename") ; extracts just the filename
; (directory-namestring "path/filename") ; extracts just the path
; a number of others are provided to work from the open stream
; (as shown above), e.g.
; (file-position stream)
; (file-length stream)

27
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/flatten.cl.html Normal file
View file

@ -0,0 +1,27 @@
#! /usr/bin/gcl -f
; (flatten L)
; -----------
; takes a potentially-nested list, L,
; and collapses all its elements into a single level,
; maintaining their order
; e.g. ((1 2 (3 4) 5) 6 ((7 8) 9))
; becomes (1 2 3 4 5 6 7 8 9)
(defun flatten (L)
(cond
((not (listp L)) L)
((null L) L)
((not (listp (car L))) (cons (car L) (flatten (cdr L))))
(t (append (flatten (car L)) (flatten (cdr L))))))
; trial runs
(defvar L1 '((1 2 (3 4) 5) 6 ((7 8) 9)))
(defvar L2 '(1 2 3))
(defvar L3 '())
(defvar L4 1)
(format t "Flattening ~A gives ~A~%" L1 (flatten L1))
(format t "Flattening ~A gives ~A~%" L2 (flatten L2))
(format t "Flattening ~A gives ~A~%" L3 (flatten L3))
(format t "Flattening ~A gives ~A~%" L4 (flatten L4))

31
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/flatten_tailrec.cl.html Normal file
View file

@ -0,0 +1,31 @@
; tail recursive flatten
; ----------------------
; our tail recursive solution will have one parameter for the
; list we're working on right now,
; plus an accumulator to keep track of the content still to be processed in
; the "parent" list
; plus another accumulator to track the result built so far
;
(defun fflat (L &optional (todo nil) (sofar nil))
(cond
; error check
((not (listp L)) 'error)
; nothing at all left to process
((and (null L) (null todo)) sofar)
; nothing left in L, but still stuff in todo list
((null L) (fflat (car todo) (cdr todo) sofar))
; front thing in L isn't a list, move it to end of result so far
((not (listp (car L))) (fflat (cdr L) todo (append sofar (list (car L)))))
; front thing in L is a nil, move it to end of result so far
((null (car L)) (fflat (cdr L) todo (append sofar (list (car L)))))
; front thing in L is a nonempty list, move the rest of L to the front of todo list
(t (fflat (car L) (cons (cdr L) todo) sofar))))

46
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/forloop.cl.html Normal file
View file

@ -0,0 +1,46 @@
#! /usr/bin/gcl -f
; emulating a for loop like
; for (current = small; current < large; current *= 2) {
; print("%d squared is %d\n", current, current*current)
; }
(defun printsquares (small large)
(loop
; count which iteration we're on
for pass from 1
; update for the current base value:
; set it to small if we're on the first pass,
; otherwise double it on each pass
for current = (if (eql pass 1) small (* 2 current))
; keep going as long as we haven't hit the end value
while (< current large)
; body of the loop: prints the square of the current value
do (format t "~A squared is ~A~%" current (* current current))
)
)
; emulating a for loop like
; for (current = L; member(E,current); current = tail(current)) {
; print current;
; }
(defun printlist (E L)
(loop
; count which iteration we're on
for pass from 1
; update for the current list to examing:
; the entire list if we're on the first pass,
; otherwise chop off the front element
for current = (if (eql pass 1) L (cdr current))
; keep going as long as we the current list still contains the test element
while (member E current)
; body of the loop: print the current list
do (format t "~A~%" current)
)
)
; sample calls
(format t "Calling printsquares~%")
(printsquares 1 10)
(format t "~%Calling printlist~%")
(printlist 3 '(6 5 4 3 2 1))

53
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/format.cl.html Normal file
View file

@ -0,0 +1,53 @@
#! /usr/bin/gcl -f
; examples using format
; (format t "text") writes the text to standard output,
; ~% is the newline character
(format t "blah blah~% more stuff ~%~%")
; ~A is a placeholder to embed variable/expression values into the string
(setf x 1)
(setf L '(2 4 6))
(format t "x is ~A, (* 3 5) is ~A, L is ~A ~%" x (* 3 5) L)
; ~S is another placeholder, but prints in a way that lisp can read back in
(format t "x is ~S, (* 3 5) is ~S, L is ~S ~%" x (* 3 5) L)
; using nil instead of t causes format to return the string it would have printed
(setf str (format nil "x is ~A~%" x))
; we can now use str as a regular chunk of text
(format t "~A" str)
; formats embedded in ~{ ... ~} also allow us to specify how to do something
; with every element of a list,
; e.g. to print every element of a list formatted to width 6:
(format t "list elements are: ~{~6A~}~%" '(1 2 3))
; ~F allows us to format numeric values, embedding a list of 5 comma-separated
; options for how to display them:
; the first option is the total number of characters to display
; the second is the number of digits after the decimal
; the third is the number of digits to shift the decimal point left
; (each shift effectively multiplying the output by 10)
; the fourth is the character to print if the number is too long
; to fit in the space allocated by option 1
; the fifth is the character to pad with on the left
; here width 8, 3 decimal points, don't shift, print ! if it's too big, pad with 0's
(format t "~8,3,0,'!,'0F ~%" (* 1.23 62.5))
(format t "~8,3,0,'!,'0F ~%" (/ 100000 3))
; some other options include ~B, ~O, and ~X for binary, octal, and hexadecimal
; note that you can force display of any buffered output using
(force-output)
; or you can discard any buffered output using
(clear-output)
; you can also display warning messages (goes to stderr), e.g.
(defvar someValue 27)
(warn "something went wrong with ~A~%" someValue)
; or you can generate an error message and halt the program
(error "something REALLY wrong with ~A, dropping to debug mode!~%" someValue)

22
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/funcall.cl.html Normal file
View file

@ -0,0 +1,22 @@
#! /usr/bin/gcl -f
; (funcall 'function ...function arguments...)
; ---------------------------------------------
; given a function and a sequence of parameters,
; funcall can be used to apply the function to the arguments
; use funcall to evaluate (* 1 2 3 4)
(setf x (funcall '* 1 2 3 4))
; print the result
(format t "~A~%" x)
; function that takes a binary operator and two values as parameters
; and runs the function on the two values
(defun binRun (f a b)
(cond
((not (functionp f)) (format t "~A is not a function~%" f))
(t (funcall f a b))))
(binRun 'format t "hello!~%")

44
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/function.cl.html Normal file
View file

@ -0,0 +1,44 @@
#! /usr/bin/gcl -f
; functions can be globally declared using defun,
; which actually treats them much like a special global variable,
; (global function variables are treated differently than global data variables)
; example of function declaration and call
; declare function foo that takes parameters x and y
(defun foo (x y)
; run the statements contained in foo
(format t "we are inside function foo~%")
(format t "x is ~A, y is ~A~%" x y)
; foo's return value is the value of the last statement run
(+ x y) ; returns x+y
)
; call foo passing 2 for x, 3 for y,
; store the result in variable x
(setf x (foo 2 3))
; print x
(format t "x is ~A~%" x)
; --- functions operating on functions ---
; test if a symbol has a function bound to it
(fboundp 'foo)
; look up the structure of a function
(function foo)
; look up the global function associated with a symbol
(symbol-function foo)
; unbind (delete) an existing function definition
(makunbound 'foo)
; bind a function body to an existing symbol,
; can be used to turn a variable into a function,
; or to overwrite an existing function definition
(setf (symbol-function 'foo) (lambda (x) (+ x x)))
(foo 3) ; foo now returns x+x, here 6

98
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/functionAnalysis.cl.html Normal file
View file

@ -0,0 +1,98 @@
#! /usr/bin/gcl -f
; in this script we create and test a variety of macros to determine what form
; was used in a function definition, and to extract the function
; name, parameter list, body, and local environment (accessible variables/parameters)
;
; the core macros are
; (getName func)
; (getParams func)
; (getBody func)
; (getEnv func)
;
; usage note:
; for functions defined using defun or labels you cannot pass the symbol,
; you must pass the function, e.g. (getname (function f))
; whereas for functions assigned to a variable you can simply pass the variable
; (e.g. variables in a let block that have been assigned a lambda
; or variables storing the result of a closure)
; macro to capture the definition form of a function
(defmacro getForm (func)
`(cond
((not (listp ,func)) 'err)
((null ,func) 'err)
((string= (symbol-name (car ,func)) (symbol-name 'LAMBDA-BLOCK)) 'defun)
((string= (symbol-name (car ,func)) (symbol-name 'LAMBDA)) 'lambda)
((string= (symbol-name (car ,func)) (symbol-name 'LAMBDA-CLOSURE)) 'closure)
((string= (symbol-name (car ,func)) (symbol-name 'LAMBDA-BLOCK-CLOSURE)) 'labels)
(t 'err)))
; macros to capture the name, parameter list, body, and environment (accessible variables/parameters) of a function
; (after identifying the form of the function)
(defmacro getName (func)
`(case (getForm ,func)
(defun (if (< (length ,func) 2) 'err (cadr ,func)))
(lambda 'lambda)
(closure 'closure)
(labels (if (< (length ,func) 5) 'err (car (cddddr ,func))))
(t 'err)))
(defmacro getParams (func)
`(case (getForm ,func)
(defun (if (< (length ,func) 3) 'err (caddr ,func)))
(lambda (if (< (length ,func) 2) 'err (cadr ,func)))
(closure (if (< (length ,func) 5) 'err (car (cddddr ,func))))
(labels (if (< (length ,func) 6) 'err (cadr (cddddr ,func))))
(t 'err)))
(defmacro getBody (func)
`(case (getForm ,func)
(defun (if (< (length ,func) 3) 'err (cdddr ,func)))
(lambda (if (< (length ,func) 2) 'err (cddr ,func)))
(closure (if (< (length ,func) 5) 'err (cdr (cddddr ,func))))
(labels (if (< (length ,func) 6) 'err (cddr (cddddr ,func))))
(t 'err)))
(defmacro getEnv (func)
`(case (getForm ,func)
(defun nil)
(lambda nil)
(closure (if (< (length ,func) 2) 'err (cadr ,func)))
(labels (if (< (length ,func) 2) 'err (cadr ,func)))
(t 'err)))
; function to analyze all the parts of our function
(defun analyze (func)
(format t "~%Name of function is ~A~%" (getName func))
(format t " paramList of function is ~A~%" (getParams func))
(format t " env of function is ~A~%" (getEnv func))
(format t " body of function is ~A~%" (getBody func)))
; test out our macros
(defun f (x)
(let ((sq (lambda () (* x x))))
(labels
((prt (j) (format t "hi ~A, ~A squared is ~A~%" j x (sq))))
(format t "~%---analyze f let variable with a lambda---~%")
(analyze sq)
(format t "~%---analyze f labels function---~%")
(analyze (function prt)))))
(format t "~%---analyze prt2 in global labels block---~%")
(labels ((prt2 (i) (format t "hi ~A!~%" i)))
(analyze (function prt2)))
(format t "~%---analyze defun f---~%")
(analyze (function f))
(format t "~%---run f to analyze local let/labels---~%")
(f 3)
(format t "~%---analyze lambda expression---~%")
(analyze (lambda (a) (* a a)))

158
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/functionEditor.cl.html Normal file
View file

@ -0,0 +1,158 @@
#! /usr/bin/gcl -f
; sample program to let you interactively edit and run a lisp function
; as long as the function is of the form supported by selfModMacros
(load "selfModMacros.cl")
; modifyParams allows the user to rewrite the function's parameter list
(defun modifyParams (func)
(format t "The parameter list is currently: ~A~%" (fGetParams func))
(format t "Please enter the new parameter list:~%")
(setf (fGetParams func) (read))
(format t "The new parameter list is: ~A~%" (fGetParams func)))
; modifyLocals allows the user to rewrite the function's local variable list
(defun modifyLocals (func)
(format t "The local variable list is currently ~A~%" (fGetLocals func))
(format t "Please enter the new local variable list:~%")
(setf (fGetLocals func) (read))
(format t "The new local variable list is: ~A~%" (fGetLocals func)))
; getCommand prompts the user to choose remove, add, or modify
; and return their choice
(defun getCommand ()
(format t "Enter rem to remove an element, add to add one, or mod to modify one~%")
(case (read)
(rem 'rem)
(add 'add)
(mod 'mod)
(t (format t "Invalid selection, please try again~%")
(getCommand))))))
; modifyMethods allows the user to modify the function's local method list
(defun modifyMethods (func)
(let ((pos nil) (newF nil))
(format t "The local method list is currently ~A~%" (fGetMethods func))
(case (getCommand)
(rem (format t "Please enter the position of the method to remove (0-based)~%")
(setf pos (read))
(removeNth pos (fGetMethods func)))
(add (format t "Please enter the definition of the method you wish added~%")
(insertNth 0 (read) (fGetMethods func)))
(mod (format t "Please enter the position of the method you wish to replace (0-based)~%")
(setf pos (read))
(format t "Please enter the new method definition~%")
(setf newF (read))
(replaceNth pos newF (fGetMethods func)))
(t (format t "Err: invalid command, no action taken~%")))))
; modifyBlock allows the user to modify the function's preprocessing block
; (adding, removing, or altering statements within the block)
(defun modifyBlock (func)
(let ((pos nil) (newS nil))
(format t "The setup block is currently ~A~%" (fGetBlock func))
(format t " -- note the first statement is always in position 2 --~%")
(case (getCommand)
(rem (format t "Please enter the position of the statement to remove (2+)~%")
(setf pos (read))
(removeNth pos (fGetBlock func)))
(add (format t "Please enter the position in which you wish to add the new statement (2+)~%")
(setf pos (read))
(format t "Please enter the statement you wish added~%")
(setf newS (read))
(insertNth pos newS (fGetBlock func)))
(mod (format t "Please enter the position of the statement you wish to replace (2+)~%")
(setf pos (read))
(format t "Please enter the new statment~%")
(setf newS (read))
(replaceNth pos newS (fGetBlock func)))
(t (format t "Err: invalid command, no action taken~%")))))
; modifyCond allows the user to modify the function's final conditions block
(defun modifyCond (func)
(let ((pos nil) (newC nil))
(format t "The final cond is currently ~A~%" (fGetCond func))
(format t " -- note the first case is always in position 1 --~%")
(case (getCommand)
(rem (format t "Please enter the position of the case to remove (1+)~%")
(setf pos (read))
(removeNth pos (fGetCond func)))
(add (format t "Please enter the position in which you wish to add the new case (1+)~%")
(setf pos (read))
(format t "Please enter the case you wish added~%")
(setf newC (read))
(insertNth pos newC (fGetCond func)))
(mod (format t "Please enter the position of the case you wish to replace (1+)~%")
(setf pos (read))
(format t "Please enter the new case~%")
(setf newC (read))
(replaceNth pos newC (fGetCond func)))
(t (format t "Err: invalid command, no action taken~%")))))
; displayHelp shows the available commands
(defun displayHelp ()
(format t "Enter help to display this menu~%")
(format t " or show to display the function~%")
(format t " or params to modify the function parameters~%")
(format t " or locals to modify the function local variables~%")
(format t " or methods to modify the function local methods~%")
(format t " or block to modify the function preprocessing block~%")
(format t " or cond to modify the function final condition statement~%")
(format t " or run to run the function~%")
(format t " or quit to quit the program~%"))
; run allows the user to supply parameters and then run the function
(defun run (func)
(let ; local vars, just the parameter list
((params nil))
(format t "Please enter the list of parameters to be supplied to the function~%")
(setf params (read))
(format t "Beginning execution:~%")
(apply func params)))
; editFunc allows editing and execution of the given function
(defun editFunc (func)
; let the user repeatedly customize the function
(do
; local variables: the user command choice
((cmd nil))
; stopping condition (when the user enters the quit command),
; return value is the modified function
((symbol-equal cmd 'quit)
func)
; loop body - prompt/read/process command
(format t "~%Enter a command (help for a list of commands)~%")
(setf cmd (read))
(case cmd
(help (displayHelp))
(params (modifyParams func))
(locals (modifyLocals func))
(methods (modifyMethods func))
(cond (modifyCond func))
(block (modifyBlock func))
(run (run func))
(show (printFunc func))
(help (displayHelp))
(quit (format t "Bye!~%"))
(t (format t "Invalid command: ~A~%" cmd)))))
(format t "~%---Welcome---~%~%")
; generate an initial function and start editing it
(defvar newF (editFunc (fGenFunc)))
(format t "~%The final modified function is:~%~A~%" newF)
(format t "~%---Done---~%")

97
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/functional.cl.html Normal file
View file

@ -0,0 +1,97 @@
#! /usr/bin/gcl -f
; pure functional programming generally has the philosophy that
; we avoid explicit use of state and sequence - no variables,
; no side effects, no explicitly ordering of steps
;
; this allows cleaner theoretical analysis of a program based on
; logical compositions of it's individual components, which
; (i) permits much simpler proofs of correctness
; (proving the parts are correct proves the whole is correct,
; since there is no state, no side effects)
; (ii) permits much simpler testing (for the same reasons,
; if the parts are correct and pass testing then the whole
; is correct and passes testing)
; (iii) since there are no interactions and no side effects,
; it is much simpler to autumatically parallelize code, since
; if we have a call like (f (g ...params...) (h ...params...))
; we know we can give h and g to different processors to run
; in parallel [and, in a purely functional implementation,
; calls of that form will be extremely common)
;
; in fact, many features of lisp and other functional languages
; appear to violate those principles - defvar allows creation
; of global variables which can be modified with setf,
; block and let specify ordered sequences of operations,
; let blocks also allow definitions of local variables, etc.
;
; those features can, generally, actually be implemented to operate
; in a functionally pure manner, while allowing the programmer to
; use the features in an apparently impure manner
;
; here we'll look at taking some impure features of lisp,
; and show how we could achieve the desired results
; in a pure fashion - the actual implementation of the
; features often follow similar approaches (though more
; efficiently)
; Technique 1: eliminating the need for local variables
; ------------
; consider the function below with parameters x and y,
; and local variables a and b:
(defun f (x y)
(let ( ; read two values entered by the user and store in a,b
(a (read))(b (read)))
; compute and return ay + x(b-(a/y))
(+ (* y a) (* x (- b (/ a y))))))
; if we wanted the same effect, but done in a "purely" functional manner
; (i.e. with parameters only, no local variables)
; we could rewrite it as two functions - the public call to f,
; and an internal call to fHidden:
(defun f (x y)
; read the two values entered by the user, pass everything to fHidden
(fHidden x y (read) (read)))
(defun fHidden (x y a b)
; perform the calculation and return the result
(+ (* y a) (* x (- b (/ a y))))))
; Technique 2: functionally enforcing sequential statements
; ------------
; consider the block below, which runs several statements in the
; order presented, and returns the value of the last statement
(block
Example
(format t "statement 1~%")
(format t "statement 2~%"))
; we could force the same effect in a "pure" manner using
(if (format t "statement 1~%") (format t "statement 2~%")
(format t "statement 2~%"))
; (essentially guaranteeing statement 1 is run first to evaluate the if,
; and regardless of the result of statement 1 it will go on to run statement 2)
; Technique 3: functionally supporting setting of variable values
; ------------
; consider this example with global variables:
(defvar x C)
(f1 x)
(setf x (f2 x))
(f3 x)
; we combine techniques 1 and 2 above:
(defun hidden (x)
(if (f1 x) (f3 (f2 x)) (f3 (f2 x))))
(hidden C)
; Technique 4: eliminating side effects
; ------------
; The primary source of side effects comes from the implementation of lists
; through pointers/references, and permitting functions to simply access/return
; the pointer/reference. To eliminate this would require using our own set of
; functions that always returned COPIES of the list component being accessed,
; rather than pointers/references into the original. While this is not difficult,
; it would certainly cause a significant increase in memory use and (sometimes)
; execution time for functions that manipulate large lists.

82
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Available-Symbols.html Normal file
View file

@ -0,0 +1,82 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Available Symbols</title>
<meta name="description" content="GCL SI Manual: Available Symbols">
<meta name="keywords" content="GCL SI Manual: Available Symbols">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="C-Interface.html#C-Interface" rel="up" title="C Interface">
<link href="System-Definitions.html#System-Definitions" rel="next" title="System Definitions">
<link href="C-Interface.html#C-Interface" rel="prev" title="C Interface">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Available-Symbols"></a>
<div class="header">
<p>
Previous: <a href="C-Interface.html#C-Interface" accesskey="p" rel="prev">C Interface</a>, Up: <a href="C-Interface.html#C-Interface" accesskey="u" rel="up">C Interface</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Available-Symbols-1"></a>
<h3 class="section">16.1 Available Symbols</h3>
<p>When GCL is built, those symbols in the system libraries which
are referenced by functions linked in in the list of objects
given in <samp>unixport/makefile</samp>, become available for reference
by GCL code.
</p>
<p>On some systems it is possible with <code>faslink</code> to load <samp>.o</samp> files
which reference other libraries, but in general this practice is not
portable.
</p>
</body>
</html>

131
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Bignums.html Normal file
View file

@ -0,0 +1,131 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Bignums</title>
<meta name="description" content="GCL SI Manual: Bignums">
<meta name="keywords" content="GCL SI Manual: Bignums">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="GCL-Specific.html#GCL-Specific" rel="up" title="GCL Specific">
<link href="C-Interface.html#C-Interface" rel="next" title="C Interface">
<link href="GCL-Specific.html#GCL-Specific" rel="prev" title="GCL Specific">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Bignums"></a>
<div class="header">
<p>
Previous: <a href="GCL-Specific.html#GCL-Specific" accesskey="p" rel="prev">GCL Specific</a>, Up: <a href="GCL-Specific.html#GCL-Specific" accesskey="u" rel="up">GCL Specific</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Bignums-1"></a>
<h3 class="section">15.1 Bignums</h3>
<p>A directory mp was added to hold the new multi precision arithmetic
code. The layout and a fair amount of code in the mp directory is an
enhanced version of gpari version 34. The gpari c code was rewritten
to be more efficient, and gcc assembler macros were added to allow
inlining of operations not possible to do in C. On a 68K machine,
this allows the C version to be as efficient as the very carefully
written assembler in the gpari distribution. For the main machines,
an assembler file (produced by gcc) based on this new method, is
included. This is for sites which do not have gcc, or do not
wish to compile the whole system with gcc.
</p>
<p>Bignum arithmetic is much faster now. Many changes were made to
cmpnew also, to add &rsquo;integer&rsquo; as a new type. It differs from
variables of other types, in that storage is associated to each such
variable, and assignments mean copying the storage. This allows a
function which does a good deal of bignum arithmetic, to do very
little consing in the heap. An example is the computation of PI-INV
in scratchpad, which calculates the inverse of pi to a prescribed
number of bits accuracy. That function is now about 20 times faster,
and no longer causes garbage collection. In versions of GCL where
HAVE_ALLOCA is defined, the temporary storage growth is on the C
stack, although this often not so critical (for example it makes
virtually no difference in the PI-INV example, since in spite of the
many operations, only one storage allocation takes place.
</p>
<p>Below is the actual code for PI-INV
</p>
<p>On a sun3/280 (cli.com)
</p>
<p>Here is the comparison of lucid and gcl before and after
on that pi-inv. Times are in seconds with multiples of the
gcl/akcl time in parentheses.
</p>
<p>On a sun3/280 (cli.com)
</p>
<div class="example">
<pre class="example">
pi-inv akcl-566 franz lucid old kcl/akcl
----------------------------------------
10000 3.3 9.2(2.8 X) 15.3 (4.6X) 92.7 (29.5 X)
20000 12.7 31.0(2.4 X) 62.2 (4.9X) 580.0 (45.5 X)
(defun pi-inv (bits &amp;aux (m 0))
(declare (integer bits m))
(let* ((n (+ bits (integer-length bits) 11))
(tt (truncate (ash 1 n) 882))
(d (* 4 882 882))
(s 0))
(declare (integer s d tt n))
(do ((i 2 (+ i 2))
(j 1123 (+ j 21460)))
((zerop tt) (cons s (- (+ n 2))))
(declare (integer i j))
(setq s (+ s (* j tt))
m (- (* (- i 1) (- (* 2 i) 1) (- (* 2 i) 3)))
tt (truncate (* m tt) (* d (the integer (expt i 3))))))))
</pre></div>
<hr>
<div class="header">
<p>
Previous: <a href="GCL-Specific.html#GCL-Specific" accesskey="p" rel="prev">GCL Specific</a>, Up: <a href="GCL-Specific.html#GCL-Specific" accesskey="u" rel="up">GCL Specific</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

70
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/C-Interface.html Normal file
View file

@ -0,0 +1,70 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: C Interface</title>
<meta name="description" content="GCL SI Manual: C Interface">
<meta name="keywords" content="GCL SI Manual: C Interface">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="Available-Symbols.html#Available-Symbols" rel="next" title="Available Symbols">
<link href="Bignums.html#Bignums" rel="prev" title="Bignums">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="C-Interface"></a>
<div class="header">
<p>
Next: <a href="System-Definitions.html#System-Definitions" accesskey="n" rel="next">System Definitions</a>, Previous: <a href="GCL-Specific.html#GCL-Specific" accesskey="p" rel="prev">GCL Specific</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="C-Interface-1"></a>
<h2 class="chapter">16 C Interface</h2>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Available-Symbols.html#Available-Symbols" accesskey="1">Available Symbols</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

488
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Characters.html Normal file
View file

@ -0,0 +1,488 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Characters</title>
<meta name="description" content="GCL SI Manual: Characters">
<meta name="keywords" content="GCL SI Manual: Characters">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="Lists.html#Lists" rel="next" title="Lists">
<link href="Sequences-and-Arrays-and-Hash-Tables.html#Sequences-and-Arrays-and-Hash-Tables" rel="prev" title="Sequences and Arrays and Hash Tables">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Characters"></a>
<div class="header">
<p>
Next: <a href="Lists.html#Lists" accesskey="n" rel="next">Lists</a>, Previous: <a href="Sequences-and-Arrays-and-Hash-Tables.html#Sequences-and-Arrays-and-Hash-Tables" accesskey="p" rel="prev">Sequences and Arrays and Hash Tables</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Characters-1"></a>
<h2 class="chapter">3 Characters</h2>
<dl>
<dt><a name="index-NAME_002dCHAR"></a>Function: <strong>NAME-CHAR</strong> <em>(name)</em></dt>
<dd><p>Package:LISP
</p>
<p>Given an argument acceptable to string,
Returns a character object whose name is NAME if one exists. Returns NIL
otherwise. NAME must be an object that can be coerced to a string.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dNAME"></a>Function: <strong>CHAR-NAME</strong> <em>(char)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the name for CHAR as a string; NIL if CHAR has no name.
Only #\Backspace, #\Tab, #\Newline (or #\Linefeed), #\Page, #\Return,
and #\Rubout have names.
</p>
</dd></dl>
<dl>
<dt><a name="index-BOTH_002dCASE_002dP"></a>Function: <strong>BOTH-CASE-P</strong> <em>(char)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if CHAR is an alphabetic character; NIL otherwise. Equivalent to
ALPHA-CHAR-P.
</p>
</dd></dl>
<dl>
<dt><a name="index-SCHAR"></a>Function: <strong>SCHAR</strong> <em>(simple-string index)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the character object representing the INDEX-th character in STRING.
This is faster than CHAR.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dSUPER_002dBIT"></a>Constant: <strong>CHAR-SUPER-BIT</strong></dt>
<dd><p>Package:LISP
The bit that indicates a super character.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dFONT_002dLIMIT"></a>Constant: <strong>CHAR-FONT-LIMIT</strong></dt>
<dd><p>Package:LISP
The upper exclusive bound on values produced by CHAR-FONT.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dDOWNCASE"></a>Function: <strong>CHAR-DOWNCASE</strong> <em>(char)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the lower-case equivalent of CHAR, if any.
If not, simply returns CHAR.
</p>
</dd></dl>
<dl>
<dt><a name="index-STRING_002dCHAR_002dP"></a>Function: <strong>STRING-CHAR-P</strong> <em>(char)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if CHAR can be stored in a string. In GCL, this function always
returns T since any character in GCL can be stored in a string.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dNOT_002dLESSP"></a>Function: <strong>CHAR-NOT-LESSP</strong> <em>(char &amp;rest more-chars)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if the codes of CHARs are in strictly non-increasing order; NIL
otherwise. For a lower-case character, the code of its upper-case equivalent
is used.
</p>
</dd></dl>
<dl>
<dt><a name="index-DISASSEMBLE"></a>Function: <strong>DISASSEMBLE</strong> <em>(thing)</em></dt>
<dd><p>Package:LISP
</p>
<p>Compiles the form specified by THING and prints the intermediate C language
code for that form. But does NOT install the result of compilation.
If THING is a symbol that names a not-yet-compiled function, the function
definition is disassembled.
If THING is a lambda expression, it is disassembled as a function definition.
Otherwise, THING itself is disassembled as a top-level form.
</p>
</dd></dl>
<dl>
<dt><a name="index-LOWER_002dCASE_002dP"></a>Function: <strong>LOWER-CASE-P</strong> <em>(char)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if CHAR is a lower-case character; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_003c_003d"></a>Function: <strong>CHAR&lt;=</strong> <em>(char &amp;rest more-chars)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if the codes of CHARs are in strictly non-decreasing order; NIL
otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dHYPER_002dBIT"></a>Constant: <strong>CHAR-HYPER-BIT</strong></dt>
<dd><p>Package:LISP
The bit that indicates a hyper character.
</p>
</dd></dl>
<dl>
<dt><a name="index-CODE_002dCHAR"></a>Function: <strong>CODE-CHAR</strong> <em>(code &amp;optional (bits 0) (font 0))</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a character object with the specified code, if any.
If not, returns NIL.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dCODE"></a>Function: <strong>CHAR-CODE</strong> <em>(char)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the code attribute of CHAR.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dCONTROL_002dBIT"></a>Constant: <strong>CHAR-CONTROL-BIT</strong></dt>
<dd><p>Package:LISP
The bit that indicates a control character.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dLESSP"></a>Function: <strong>CHAR-LESSP</strong> <em>(char &amp;rest more-chars)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if the codes of CHARs are in strictly increasing order; NIL
otherwise. For a lower-case character, the code of its upper-case equivalent
is used.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dFONT"></a>Function: <strong>CHAR-FONT</strong> <em>(char)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the font attribute of CHAR.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_003c"></a>Function: <strong>CHAR&lt;</strong> <em>(char &amp;rest more-chars)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if the codes of CHARs are in strictly increasing order; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_003e_003d"></a>Function: <strong>CHAR&gt;=</strong> <em>(char &amp;rest more-chars)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if the codes of CHARs are in strictly non-increasing order; NIL
otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dMETA_002dBIT"></a>Constant: <strong>CHAR-META-BIT</strong></dt>
<dd><p>Package:LISP
The bit that indicates a meta character.
</p>
</dd></dl>
<dl>
<dt><a name="index-GRAPHIC_002dCHAR_002dP"></a>Function: <strong>GRAPHIC-CHAR-P</strong> <em>(char)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if CHAR is a printing character, i.e., #\Space through #\~;
NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dNOT_002dEQUAL"></a>Function: <strong>CHAR-NOT-EQUAL</strong> <em>(char &amp;rest more-chars)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if no two of CHARs are the same character; NIL otherwise.
Upper case character and its lower case equivalent are regarded the same.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dBITS_002dLIMIT"></a>Constant: <strong>CHAR-BITS-LIMIT</strong></dt>
<dd><p>Package:LISP
The upper exclusive bound on values produced by CHAR-BITS.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHARACTERP"></a>Function: <strong>CHARACTERP</strong> <em>(x)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if X is a character; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_003d"></a>Function: <strong>CHAR=</strong> <em>(char &amp;rest more-chars)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if all CHARs are the same character; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-ALPHA_002dCHAR_002dP"></a>Function: <strong>ALPHA-CHAR-P</strong> <em>(char)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if CHAR is an alphabetic character, A-Z or a-z; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-UPPER_002dCASE_002dP"></a>Function: <strong>UPPER-CASE-P</strong> <em>(char)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if CHAR is an upper-case character; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dBIT"></a>Function: <strong>CHAR-BIT</strong> <em>(char name)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if the named bit is on in the character CHAR; NIL otherwise.
In GCL, this function always returns NIL.
</p>
</dd></dl>
<dl>
<dt><a name="index-MAKE_002dCHAR"></a>Function: <strong>MAKE-CHAR</strong> <em>(char &amp;optional (bits 0) (font 0))</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a character object with the same code attribute as CHAR and with
the specified BITS and FONT attributes.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHARACTER"></a>Function: <strong>CHARACTER</strong> <em>(x)</em></dt>
<dd><p>Package:LISP
</p>
<p>Coerces X into a character object if possible.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dEQUAL"></a>Function: <strong>CHAR-EQUAL</strong> <em>(char &amp;rest more-chars)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if all of its arguments are the same character; NIL otherwise.
Upper case character and its lower case equivalent are regarded the same.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dNOT_002dGREATERP"></a>Function: <strong>CHAR-NOT-GREATERP</strong> <em>(char &amp;rest more-chars)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if the codes of CHARs are in strictly non-decreasing order; NIL
otherwise. For a lower-case character, the code of its upper-case equivalent
is used.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_003e"></a>Function: <strong>CHAR&gt;</strong> <em>(char &amp;rest more-chars)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if the codes of CHARs are in strictly decreasing order; NIL
otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-STANDARD_002dCHAR_002dP"></a>Function: <strong>STANDARD-CHAR-P</strong> <em>(char)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if CHAR is a standard character, i.e., one of the 95 ASCII printing
characters #\Space to #\~ and #Newline; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dUPCASE"></a>Function: <strong>CHAR-UPCASE</strong> <em>(char)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the upper-case equivalent of CHAR, if any.
If not, simply returns CHAR.
</p>
</dd></dl>
<dl>
<dt><a name="index-DIGIT_002dCHAR_002dP"></a>Function: <strong>DIGIT-CHAR-P</strong> <em>(char &amp;optional (radix 10))</em></dt>
<dd><p>Package:LISP
</p>
<p>If CHAR represents a digit in RADIX, then returns the weight as an integer.
Otherwise, returns nil.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002f_003d"></a>Function: <strong>CHAR/=</strong> <em>(char &amp;rest more-chars)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if no two of CHARs are the same character; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dGREATERP"></a>Function: <strong>CHAR-GREATERP</strong> <em>(char &amp;rest more-chars)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if the codes of CHARs are in strictly decreasing order; NIL
otherwise. For a lower-case character, the code of its upper-case equivalent
is used.
</p>
</dd></dl>
<dl>
<dt><a name="index-ALPHANUMERICP"></a>Function: <strong>ALPHANUMERICP</strong> <em>(char)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if CHAR is either numeric or alphabetic; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHAR_002dBITS"></a>Function: <strong>CHAR-BITS</strong> <em>(char)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the bits attribute (which is always 0 in GCL) of CHAR.
</p>
</dd></dl>
<dl>
<dt><a name="index-DIGIT_002dCHAR"></a>Function: <strong>DIGIT-CHAR</strong> <em>(digit &amp;optional (radix 10) (font 0))</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a character object that represents the DIGIT in the specified RADIX.
Returns NIL if no such character exists.
</p>
</dd></dl>
<dl>
<dt><a name="index-SET_002dCHAR_002dBIT"></a>Function: <strong>SET-CHAR-BIT</strong> <em>(char name newvalue)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a character just like CHAR except that the named bit is set or
cleared, according to whether NEWVALUE is non-NIL or NIL. This function
is useless in GCL.
</p>
</dd></dl>
<hr>
<div class="header">
<p>
Next: <a href="Lists.html#Lists" accesskey="n" rel="next">Lists</a>, Previous: <a href="Sequences-and-Arrays-and-Hash-Tables.html#Sequences-and-Arrays-and-Hash-Tables" accesskey="p" rel="prev">Sequences and Arrays and Hash Tables</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

212
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Command-Line.html Normal file
View file

@ -0,0 +1,212 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Command Line</title>
<meta name="description" content="GCL SI Manual: Command Line">
<meta name="keywords" content="GCL SI Manual: Command Line">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Operating-System.html#Operating-System" rel="up" title="Operating System">
<link href="Operating-System-Definitions.html#Operating-System-Definitions" rel="next" title="Operating System Definitions">
<link href="Operating-System.html#Operating-System" rel="prev" title="Operating System">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Command-Line"></a>
<div class="header">
<p>
Next: <a href="Operating-System-Definitions.html#Operating-System-Definitions" accesskey="n" rel="next">Operating System Definitions</a>, Previous: <a href="Operating-System.html#Operating-System" accesskey="p" rel="prev">Operating System</a>, Up: <a href="Operating-System.html#Operating-System" accesskey="u" rel="up">Operating System</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Command-Line-1"></a>
<h3 class="section">9.1 Command Line</h3>
<p>The variable si::*command-args* is set to the list of strings passed
in when gcl is invoked.
</p>
<p>Various flags are understood.
</p><dl compact="compact">
<dt><code>-eval</code>
<a name="index-_002deval"></a>
</dt>
<dd><p>Call read and then eval on the command argument following <code>-eval</code>
</p></dd>
<dt><code>-load</code>
<a name="index-_002dload"></a>
</dt>
<dd><p>Load the file whose pathname is specified after <code>-load</code>.
</p></dd>
<dt><code>-f</code>
<a name="index-_002df"></a>
</dt>
<dd><p>Replace si::*command-args* by the the list starting after <code>-f</code>.
Open the file following <code>-f</code> for input, skip the first line, and then
read and eval the rest of the forms in the file. This can be used
as with the shells to write small shell programs:
</p><div class="example">
<pre class="example">#!/usr/local/bin/gcl.exe -f
(format t &quot;hello world ~a~%&quot; (nth 1 si::*command-args*))
</pre></div>
<p>The value si::*command-args* will have the appropriate value.
Thus if the above 2 line file is made executable and called <samp>foo</samp>
then
</p><div class="example">
<pre class="example">tutorial% foo billy
hello world billy
</pre></div>
<p>NOTE: On many systems (eg SunOs) the first line of an executable script file
such as:
</p><div class="example">
<pre class="example">#!/usr/local/bin/gcl.exe -f
</pre></div>
<p>only reads the first 32 characters! So if your pathname where the executable
together with the &rsquo;-f&rsquo; amount to more than 32 characters the file will not
be recognized. Also the executable must be the actual large binary file,
[or a link to it],
and not just a <code>/bin/sh</code> script. In latter case the
<code>/bin/sh</code> interpreter would get invoked on the file.
</p>
<p>Alternately one could invoke the file <samp>foo</samp> without making it
executable:
</p><div class="example">
<pre class="example">tutorial% gcl -f foo &quot;from bill&quot;
hello world from bill
</pre></div>
<p>Finally perhaps the best way (why do we save the best for last..
I guess because we only figure it out after all the others..)
The following file <samp>myhello</samp> has 4 lines:
</p><div class="example">
<pre class="example">#!/bin/sh
#| Lisp will skip the next 2 lines on reading
exec gcl -f &quot;$0&quot; $&nbsp;|#
(format t &quot;hello world ~a~%&quot; (nth 1 si::*command-args*))
</pre></div>
<div class="example">
<pre class="example">marie% chmod a+x myhello
marie% myhello bill
hello world bill
</pre></div>
<p>The advantage of this method is that <samp>gcl</samp> can itself
be a shell script, which sets up environment and
so on. Also the normal path will be searched to find <samp>gcl</samp>
The disadvantage is that this would cause 2 invocations of <samp>sh</samp>
and one invocation of <samp>gcl</samp>. The plan using <samp>gcl.exe</samp>
bypasses the <samp>sh</samp> entirely. Inded invoking <samp>gcl.exe</samp> to
print <samp>hello world</samp> is faster on most systems than a similar
<samp>csh</samp> or <samp>bash</samp> script, but slightly slower than the old
<samp>sh</samp>.
</p>
</dd>
<dt><code>-batch</code>
<a name="index-_002dbatch"></a>
</dt>
<dd><p>Do not enter the command print loop. Useful if the other command line
arguments do something. Do not print the License and acknowledgement
information. Note if your program does print any License information,
it must print the GCL header information also.
</p></dd>
<dt><code>-dir</code>
<a name="index-_002ddir"></a>
</dt>
<dd><p>Directory where the executable binary that is running is located.
Needed by save and friends. This gets set as si::*system-directory*
</p></dd>
<dt><code>-libdir</code>
<a name="index-_002dlibdir"></a>
</dt>
<dd><div class="example">
<pre class="example"> -libdir <samp>/d/wfs/gcl-2.0/</samp>
</pre></div>
<p>would mean that the files like gcl-tk/tk.o would be found by
concatting the path to the libdir path, ie in
</p><div class="example">
<pre class="example"><samp>/d/wfs/gcl-2.0/gcl-tk/tk.o</samp>
</pre></div>
</dd>
<dt><code>-compile</code>
<a name="index-_002dcompile"></a>
</dt>
<dd><p>Invoke the compiler on the filename following <code>-compile</code>.
Other flags affect compilation.
</p></dd>
<dt><code>-o-file</code>
<a name="index-_002do_002dfile"></a>
</dt>
<dd><p>If nil follows <code>-o-file</code> then do not produce an <code>.o</code> file.
</p></dd>
<dt><code>-c-file</code>
<a name="index-_002dc_002dfile"></a>
</dt>
<dd><p>If <code>-c-file</code> is specified, leave the intermediate <code>.c</code> file there.
</p></dd>
<dt><code>-h-file</code>
<a name="index-_002dh_002dfile"></a>
</dt>
<dd><p>If <code>-h-file</code> is specified, leave the intermediate <code>.h</code> file there.
</p></dd>
<dt><code>-data-file</code>
<a name="index-_002ddata_002dfile"></a>
</dt>
<dd><p>If <code>-data-file</code> is specified, leave the intermediate <code>.data</code> file there.
</p></dd>
<dt><code>-system-p</code>
<a name="index-_002dsystem_002dp"></a>
</dt>
<dd><p>If <code>-system-p</code> is specified then invoke <code>compile-file</code> with the
<code>:system-p t</code> keyword argument, meaning that the C init function
will bear a name based on the name of the file, so that it may be invoked
by name by C code.
</p></dd>
</dl>
<hr>
<div class="header">
<p>
Next: <a href="Operating-System-Definitions.html#Operating-System-Definitions" accesskey="n" rel="next">Operating System Definitions</a>, Previous: <a href="Operating-System.html#Operating-System" accesskey="p" rel="prev">Operating System</a>, Up: <a href="Operating-System.html#Operating-System" accesskey="u" rel="up">Operating System</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

400
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Compilation.html Normal file
View file

@ -0,0 +1,400 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Compilation</title>
<meta name="description" content="GCL SI Manual: Compilation">
<meta name="keywords" content="GCL SI Manual: Compilation">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="Symbols.html#Symbols" rel="next" title="Symbols">
<link href="Special-Forms-and-Functions.html#Special-Forms-and-Functions" rel="prev" title="Special Forms and Functions">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Compilation"></a>
<div class="header">
<p>
Next: <a href="Symbols.html#Symbols" accesskey="n" rel="next">Symbols</a>, Previous: <a href="Special-Forms-and-Functions.html#Special-Forms-and-Functions" accesskey="p" rel="prev">Special Forms and Functions</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Compilation-1"></a>
<h2 class="chapter">7 Compilation</h2>
<dl>
<dt><a name="index-COMPILE"></a>Function: <strong>COMPILE</strong> <em>(name &amp;optional (definition nil))</em></dt>
<dd><p>Package:LISP
</p>
<p>If DEFINITION is NIL, NAME must be the name of a not-yet-compiled
function. In this case, COMPILE compiles the function, installs the compiled
function as the global function definition of NAME, and returns NAME.
If DEFINITION is non-NIL, it must be a lambda expression and NAME must be
a symbol. COMPILE compiles the lambda expression, installs the compiled
function as the function definition of NAME, and returns NAME.
There is only one exception for this: If NAME is NIL, then the compiled
function is not installed but is simply returned as the value of COMPILE.
In any case, COMPILE creates temporary files whose filenames are
&quot;gazonk***&quot;. By default, i.e. if :LEAVE-GAZONK is not supplied or is
NIL, these files are automatically deleted after compilation.
</p>
</dd></dl>
<dl>
<dt><a name="index-LINK"></a>Function: <strong>LINK</strong> <em>(files image &amp;optional post extra-libs (run-user-init t) &amp;aux raw init) </em></dt>
<dd><p>Package:LISP
</p>
<p>On systems where dlopen is used for relocations, one cannot make custom
images containing loaded binary object files simply by loading the files
and executing save-system. This function is provided for such cases.
</p>
<p>After compiling source files into objects, LINK can be called with a
list of binary and source FILES which would otherwise normally be
loaded in sequence before saving the image to IMAGE. LINK will use
the system C linker to link the binary files thus supplied with GCL&rsquo;s
objects, using EXTRA-LIBS as well if provided, and producing a
raw_IMAGE executable. This executable is then run to initialize first
GCL&rsquo;s objects, followed by the supplied files, in order, if
RUN-USER-INIT is set. In such a case, source files are loaded at
their position in the sequence. Any optional code which should be run
after file initialization can be supplied in the POST variable. The
image is then saved using save-system to IMAGE.
</p>
<p>This method of creating lisp images may also have the advantage that
all new object files are kept out of the lisp core and placed instead
in the final image&rsquo;s .text section. This should in principle reduce
the core size, speed up garbage collection, and forego any performance
penalty induced by data cache flushing on some machines.
</p>
<p>In both the RAW and SAVED image, any calls to LOAD binary object files
which have been specified in this list will bypass the normal load
procedure, and simply initialize the already linked in module. One
can rely on this feature by disabling RUN-USER-INIT, and instead
passing the normal build commands in POST. In the course of executing
this code, binary modules previously linked into the .text section of
the executable will be initialized at the same point at which they
would have normally been loaded into the lisp core, in the
executable&rsquo;s .data section. In this way, the user can choose to take
advantage of the aforementioned possible benefits of this linking
method in a relatively transparent way.
</p>
<p>All binary objects specified in FILES must have been compiled with
:SYSTEM-P set to T.
</p>
</dd></dl>
<dl>
<dt><a name="index-EVAL_002dWHEN"></a>Special Form: <strong>EVAL-WHEN</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(eval-when ({situation}*) {form}*)
</pre></div>
<p>A situation must be either COMPILE, LOAD, or EVAL. The interpreter evaluates
only when EVAL is specified. If COMPILE is specified, FORMs are evaluated
at compile time. If LOAD is specified, the compiler arranges so that FORMs
be evaluated when the compiled code is loaded.
</p>
</dd></dl>
<dl>
<dt><a name="index-COMPILE_002dFILE"></a>Function: <strong>COMPILE-FILE</strong> <em>(input-pathname &amp;key output-file (load nil) (message-file nil) ;GCL specific keywords: system-p c-debug c-file h-file data-file)</em></dt>
<dd><p>Package:LISP
</p>
<p>Compiles the file specified by INPUT-PATHNAME and generates a fasl file
specified by OUTPUT-FILE. If the filetype is not specified in INPUT-PATHNAME,
then &quot;.lsp&quot; is used as the default file type for the source file. :LOAD
specifies whether to load the generated fasl file after compilation.
:MESSAGE-FILE specifies the log file for the compiler messages. It defaults to
the value of the variable COMPILER:*DEFAULT-MESSAGE-FILE*. A non-NIL value of
COMPILER::*COMPILE-PRINT* forces the compiler to indicate the form currently
being compiled. More keyword parameters are accepted, depending on the
version. Most versions of GCL can receive :O-FILE, :C-FILE, :H-FILE, and
:DATA-FILE keyword parameters, with which you can control the intermediate
files generated by the GCL compiler. Also :C-DEBUG will pass the -g flag to
the C compiler.
</p>
<p>By top level forms in a file, we mean the value of *top-level-forms* after
doing (TF form) for each form read from a file. We define TF as follows:
</p>
<p>(defun TF (x)
(when (consp x)
(setq x (macroexpand x))
(when (consp x)
(cond ((member (car x) &rsquo;(progn eval-when))
(mapcar &rsquo;tf (cdr x)))
(t (push x *top-level-forms*))))))
</p>
<p>Among the common lisp special forms only DEFUN and DEFMACRO will cause actual
native machine code to be generated. The rest will be specially treated in an
init section of the .data file. This is done so that things like putprop,setq,
and many other forms would use up space which could not be usefully freed, if
we were to compile to native machine code. If you have other &lsquo;ordinary&rsquo; top
level forms which you need to have compiled fully to machine code you may
either set compiler::*COMPILE-ORDINARIES* to t, or put them inside a
</p>
<p>(PROGN &rsquo;COMPILE ...forms-which-need-to-be-compiled)
</p>
<p>The compiler will take each of them and make a temporary function which will be
compiled and invoked once. It is permissible to wrap a (PROGN &rsquo;COMPILE ..)
around the whole file. Currently this construction binds the
compiler::*COMPILE-ORDINARIES* flag to t. Setting this flag globally to a non
nil value to cause all top level forms to generate machine code. This might be
useful in a system such as PCL, where a number of top level lambda expressions
are given. Note that most common lisps will simply ignore the top level atom
&rsquo;compile, since it has no side effects.
</p>
<p>Defentry, clines, and defcfun also result in machine code being generated.
</p>
</dd></dl>
<a name="subsection-Evaluation-at-Compile-time"></a>
<h2 class="unnumbered">subsection Evaluation at Compile time</h2>
<p>In GCL the eval-when behaviour was changed in order to allow
more efficient init code, and also to bring it into line with the resolution
passed by the X3j13 committee. Evaluation at compile time is controlled by
placing eval-when special forms in the code, or by the value of the variable
compiler::*eval-when-defaults* [default value :defaults]. If that variable
has value :defaults, then the following hold:
</p>
<p>Eval&nbsp;at&nbsp;Compile&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Type&nbsp;of&nbsp;Top&nbsp;Level&nbsp;Form<!-- /@w --><br>
</p>
<dl compact="compact">
<dt>Partial:</dt>
<dd><p>defstructs, defvar, defparameter
</p></dd>
<dt>Full:</dt>
<dd><p>defmacro, defconstant, defsetf, define-setf-method,
deftype, package ops, proclaim
</p></dd>
<dt>None:</dt>
<dd><p>defun, others
</p></dd>
</dl>
<p>By &lsquo;partial&rsquo; we mean (see the X3J13 Common Lisp document
(doc/compile-file-handling-of-top-level-forms) for more detail), that functions
will not be defined, values will not be set, but other miscellaneous compiler
properties will be set: eg properties to inline expand defstruct accessors and
testers, defstruct properties allowing subsequent defstructs to include this
one, any type hierarch information, special variable information will be set up.
</p>
<p>Example:
</p><div class="example">
<pre class="example">(defun foo () 3)
(defstruct jo a b)
</pre></div>
<p>As a side effect of compiling these two forms, foo would not have its function
cell changed. Neither would jo-a, although it would gain a property which
allows it to expand inline to a structure access. Thus if it had a previous
definition (as commonly happens from previously loading the file), this previous
definition would not be touched, and could well be inconsistent with the
compiler properties. Unfortunately this is what the CL standard says to do,
and I am just trying to follow it.
</p>
<p>If you prefer a more intuitive scheme, of evaling all forms in the file, so
that there are no inconsistencies, (previous behaviour of AKCL) you may set
compiler::*eval-when-defaults* to &rsquo;(compile eval load).
</p>
<p>The variable compiler::*FASD-DATA* [default t] controls whether an ascii output
is used for the data section of the object file. The data section will be in
ascii if *fasd-data* is nil or if the system-p keyword is supplied to
compile-file and *fasd-data* is not eq to :system-p.
</p>
<p>The old GCL variable *compile-time-too* has disappeared.
</p>
<p>See OPTIMIZE on how to enable warnings of slow constructs.
</p>
<dl>
<dt><a name="index-PROCLAIM"></a>Function: <strong>PROCLAIM</strong> <em>(decl-spec)</em></dt>
<dd><p>Package:LISP
</p>
<p>Puts the declaration given by DECL-SPEC into effect globally. See the doc of
DECLARE for possible DECL-SPECs.
</p>
</dd></dl>
<dl>
<dt><a name="index-PROVIDE"></a>Function: <strong>PROVIDE</strong> <em>(module-name)</em></dt>
<dd><p>Package:LISP
</p>
<p>Adds the specified module to the list of modules maintained in *MODULES*.
</p>
</dd></dl>
<dl>
<dt><a name="index-COMPILED_002dFUNCTION_002dP"></a>Function: <strong>COMPILED-FUNCTION-P</strong> <em>(x)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if X is a compiled function; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-GPROF_002dSTART"></a>Function: <strong>GPROF-START</strong> <em>()</em></dt>
<dd><p>Package:SYSTEM
</p>
<p>GCL now has preliminary support for profiling with gprof, an
externally supplied profiling tool at the C level which typically
accompanies gcc. Support must be enabled at compile time with
&ndash;enable-gprof. This function starts the profiling timers and
counters.
</p>
</dd></dl>
<dl>
<dt><a name="index-GPROF_002dQUIT"></a>Function: <strong>GPROF-QUIT</strong> <em>()</em></dt>
<dd><p>Package:SYSTEM
</p>
<p>GCL now has preliminary support for profiling with gprof, an
externally supplied profiling tool at the C level which typically
accompanies gcc. Support must be enabled at compile time with
&ndash;enable-gprof. This function reports the profiling results in the
form of a call graph to standard output, and clears the profiling
arrays. Please note that lisp functions are not (yet) displayed with
their lisp names. Please see also the PROFILE function.
</p>
</dd></dl>
<dl>
<dt><a name="index-GPROF_002dSET"></a>Function: <strong>GPROF-SET</strong> <em>(begin end)</em></dt>
<dd><p>Package:SYSTEM
</p>
<p>GCL now has preliminary support for profiling with gprof, an
externally supplied profiling tool at the C level which typically
accompanies gcc. Support must be enabled at compile time with
&ndash;enable-gprof. This function sets the address range used by
GPROF-START in specifying the section of the running program which is
to be profiled. All subsequent calls to GPROF-START will use this new
address range. By default, the range is set to begin at the starting
address of the .text section, and to end at the current end of the
running core. These default values can be restored by calling
GPROF-SET with both argments set to 0.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aDEFAULT_002dSYSTEM_002dP_002a"></a>Variable: <strong>*DEFAULT-SYSTEM-P*</strong></dt>
<dd><p>Pakcage:COMPILER
Specifies the default setting of :SYSTEM-P used by COMPILE. Defaults to NIL.
</p></dd></dl>
<dl>
<dt><a name="index-_002aDEFAULT_002dC_002dFILE_002a"></a>Variable: <strong>*DEFAULT-C-FILE*</strong></dt>
<dd><p>Pakcage:COMPILER
Specifies the default setting of :C-FILE used by COMPILE. Defaults to NIL.
</p></dd></dl>
<dl>
<dt><a name="index-_002aDEFAULT_002dH_002dFILE_002a"></a>Variable: <strong>*DEFAULT-H-FILE*</strong></dt>
<dd><p>Pakcage:COMPILER
Specifies the default setting of :H-FILE used by COMPILE. Defaults to NIL.
</p></dd></dl>
<dl>
<dt><a name="index-_002aDEFAULT_002dDATA_002dFILE_002a"></a>Variable: <strong>*DEFAULT-DATA-FILE*</strong></dt>
<dd><p>Pakcage:COMPILER
Specifies the default setting of :DATA-FILE used by COMPILE. Defaults to NIL.
</p></dd></dl>
<dl>
<dt><a name="index-_002aFEATURES_002a"></a>Variable: <strong>*FEATURES*</strong></dt>
<dd><p>Package:LISP
List of symbols that name features of the current version of GCL.
These features are used to decide the read-time conditionalization facility
provided by &rsquo;#+&rsquo; and &rsquo;#-&rsquo; read macros. When the GCL reader encounters
</p><div class="example">
<pre class="example"> #+ feature-description form
</pre></div>
<p>it reads FORM in the usual manner if FEATURE-DESCRIPTION is true. Otherwise,
the reader just skips FORM.
</p><div class="example">
<pre class="example"> #- feature-description form
</pre></div>
<p>is equivalent to
</p><div class="example">
<pre class="example"> #- (not feature-description) form
</pre></div>
<p>A feature-description may be a symbol, which is true only when it is an
element of *FEATURES*. Or else, it must be one of the following:
</p><div class="example">
<pre class="example">(and feature-desciption-1 ... feature-desciption-n)
(or feature-desciption-1 ... feature-desciption-n)
(not feature-desciption)
</pre></div>
<p>The AND description is true only when all of its sub-descriptions are true.
The OR description is true only when at least one of its sub-descriptions is
true. The NOT description is true only when its sub-description is false.
</p>
</dd></dl>
<hr>
<div class="header">
<p>
Next: <a href="Symbols.html#Symbols" accesskey="n" rel="next">Symbols</a>, Previous: <a href="Special-Forms-and-Functions.html#Special-Forms-and-Functions" accesskey="p" rel="prev">Special Forms and Functions</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

236
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Compiler-Definitions.html Normal file
View file

@ -0,0 +1,236 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Compiler Definitions</title>
<meta name="description" content="GCL SI Manual: Compiler Definitions">
<meta name="keywords" content="GCL SI Manual: Compiler Definitions">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="next" title="Function and Variable Index">
<link href="Low-Level-X-Interface.html#Low-Level-X-Interface" rel="prev" title="Low Level X Interface">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Compiler-Definitions"></a>
<div class="header">
<p>
Next: <a href="Function-and-Variable-Index.html#Function-and-Variable-Index" accesskey="n" rel="next">Function and Variable Index</a>, Previous: <a href="Miscellaneous.html#Miscellaneous" accesskey="p" rel="prev">Miscellaneous</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Compiler-Definitions-1"></a>
<h2 class="chapter">20 Compiler Definitions</h2>
<dl>
<dt><a name="index-EMIT_002dFN"></a>Function: <strong>EMIT-FN</strong> <em>(turn-on)</em></dt>
<dd><p>Package:COMPILER
</p>
<p>If TURN-ON is t, the subsequent calls to COMPILE-FILE will
cause compilation of foo.lisp to emit a foo.fn as well as foo.o.
The .fn file contains cross referencing information as well as
information useful to the collection utilities in cmpnew/collectfn
This latter file must be manually loaded to call emit-fn.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aCMPINCLUDE_002dSTRING_002a"></a>Variable: <strong>*CMPINCLUDE-STRING*</strong></dt>
<dd><p>Package:COMPILER
If it is a string it holds the text of the cmpinclude.h file appropriate for
this version. Otherwise the usual #include of *cmpinclude* will be used. To
disable this feature set *cmpinclude-string* to NIL in the init-form.
</p>
</dd></dl>
<dl>
<dt><a name="index-EMIT_002dFN-1"></a>Function: <strong>EMIT-FN</strong> <em>(turn-on)</em></dt>
<dd><p>Package:COMPILER
</p>
<p>If TURN-ON is t, then subsequent calls to compile-file on a file foo.lisp
cause output of a file foo.fn. This .fn file contains lisp structures
describing the functions in foo.lisp. Some tools for analyzing this data base
are WHO-CALLS, LIST-UNDEFINED-FUNCTIONS, LIST-UNCALLED-FUNCTIONS, and
MAKE-PROCLAIMS.
</p>
<p>Usage:
(compiler::emit-fn t)
(compile-file &quot;foo1.lisp&quot;)
(compile-file &quot;foo2.lisp&quot;)
</p>
<p>This would create foo1.fn and foo2.fn. These may be loaded using LOAD. Each
time compile-file is called the data base is cleared. Immediately after the
compilation, the data base consists of data from the compilation. Thus if you
wished to find functions called but not defined in the current file, you could
do (list-undefined-functions), immediately following the compilation. If you
have a large system, you would load all the .fn files before using the above
tools.
</p>
</dd></dl>
<dl>
<dt><a name="index-MAKE_002dALL_002dPROCLAIMS"></a>Function: <strong>MAKE-ALL-PROCLAIMS</strong> <em>(&amp;rest directories)</em></dt>
<dd><p>Package:COMPILER
</p>
<p>For each D in DIRECTORIES all files in (directory D) are loaded.
</p>
<p>For example
(make-all-proclaims &quot;lsp/*.fn&quot; &quot;cmpnew/*.fn&quot;)
would load any files in lsp/*.fn and cmpnew/*.fn.
</p>
<p>[See EMIT-FN for details on creation of .fn files]
</p>
<p>Then calculations on the newly loaded .fn files are made, to determine
function proclamations. If number of values of a function cannot be
determined [for example because of a final funcall, or call of a function
totally unknown at this time] then return type * is assigned.
</p>
<p>Finally a file sys-proclaim.lisp is written out. This file contains function
proclamations.
</p>
<p>(load &quot;sys-proclaim.lisp&quot;)
(compile-file &quot;foo1.lisp&quot;)
(compile-file &quot;foo2.lisp&quot;)
</p>
</dd></dl>
<dl>
<dt><a name="index-MAKE_002dPROCLAIMS"></a>Function: <strong>MAKE-PROCLAIMS</strong> <em>(&amp;optional (stream *standard-output*))</em></dt>
<dd><p>Package:COMPILER
</p>
<p>Write to STREAM the function proclaims from the current data base. Usually a
number of .fn files are loaded prior to running this. See EMIT-FN for details
on how to collect this. Simply use LOAD to load in .fn files.
</p>
</dd></dl>
<dl>
<dt><a name="index-LIST_002dUNDEFINED_002dFUNCTIONS"></a>Function: <strong>LIST-UNDEFINED-FUNCTIONS</strong> <em>()</em></dt>
<dd><p>Package:COMPILER
</p>
<p>Return a list of all functions called but not defined, in the current data
base (see EMIT-FN).
</p>
<div class="example">
<pre class="example">Sample:
(compiler::emit-fn t)
(compile-file &quot;foo1.lisp&quot;)
(compiler::list-undefined-functions)
or
(mapcar 'load (directory &quot;*.fn&quot;)) (compiler::list-undefined-functions)
</pre></div>
</dd></dl>
<dl>
<dt><a name="index-WHO_002dCALLS"></a>Function: <strong>WHO-CALLS</strong> <em>(function-name)</em></dt>
<dd><p>Package:COMPILER
</p>
<p>List all functions in the data base [see emit-fn] which call FUNCTION-NAME.
</p>
</dd></dl>
<dl>
<dt><a name="index-LIST_002dUNCALLED_002dFUNCTIONS"></a>Function: <strong>LIST-UNCALLED-FUNCTIONS</strong> <em>()</em></dt>
<dd><p>Package:COMPILER
</p>
<p>Examine the current data base [see emit-fn] for any functions or macros which
are called but are not: fboundp, OR defined in the data base, OR having
special compiler optimizer properties which would eliminate an actual call.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aCC_002a"></a>Variable: <strong>*CC*</strong></dt>
<dd><p>Package:COMPILER
Has value a string which controls which C compiler is used by GCL.
Usually this string is obtained from the machine.defs file, but
may be reset by the user, to change compilers or add an include path.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aSPLIT_002dFILES_002a"></a>Variable: <strong>*SPLIT-FILES*</strong></dt>
<dd><p>Package:COMPILER
This affects the behaviour of compile-file, and is useful for cases where
the C compiler cannot handle large C files resulting from lisp compilation.
This scheme should allow arbitrarily long lisp files to be compiled.
</p>
<p>If the value [default NIL] is a positive integer, then the source file will
be compiled into several object files whose names have 0,1,2,.. prepended,
and which will be loaded by the main object file. File 0 will
contain compilation of top level forms thru position *split-files* in the
lisp source file, and file 1 the next forms, etc. Thus a 180k file
would probably result in three object files (plus the master object file
of the same name) if *split-files* was set to 60000.
The package information will be inserted in each file.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aCOMPILE_002dORDINARIES_002a"></a>Variable: <strong>*COMPILE-ORDINARIES*</strong></dt>
<dd><p>Package:COMPILER
If this has a non nil value [default = nil], then all top level
forms will be compiled into machine instructions. Otherwise
only defun&rsquo;s, defmacro&rsquo;s, and top level forms beginning
with (progn &rsquo;compile ...) will do so.
</p>
</dd></dl>
<hr>
<div class="header">
<p>
Next: <a href="Function-and-Variable-Index.html#Function-and-Variable-Index" accesskey="n" rel="next">Function and Variable Index</a>, Previous: <a href="Miscellaneous.html#Miscellaneous" accesskey="p" rel="prev">Miscellaneous</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

74
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Debugging.html Normal file
View file

@ -0,0 +1,74 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Debugging</title>
<meta name="description" content="GCL SI Manual: Debugging">
<meta name="keywords" content="GCL SI Manual: Debugging">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="Source-Level-Debugging-in-Emacs.html#Source-Level-Debugging-in-Emacs" rel="next" title="Source Level Debugging in Emacs">
<link href="Regular-Expressions.html#Regular-Expressions" rel="prev" title="Regular Expressions">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Debugging"></a>
<div class="header">
<p>
Next: <a href="Miscellaneous.html#Miscellaneous" accesskey="n" rel="next">Miscellaneous</a>, Previous: <a href="System-Definitions.html#System-Definitions" accesskey="p" rel="prev">System Definitions</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Debugging-1"></a>
<h2 class="chapter">18 Debugging</h2>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Source-Level-Debugging-in-Emacs.html#Source-Level-Debugging-in-Emacs" accesskey="1">Source Level Debugging in Emacs</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Low-Level-Debug-Functions.html#Low-Level-Debug-Functions" accesskey="2">Low Level Debug Functions</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

170
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Doc.html Normal file
View file

@ -0,0 +1,170 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Doc</title>
<meta name="description" content="GCL SI Manual: Doc">
<meta name="keywords" content="GCL SI Manual: Doc">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="Type.html#Type" rel="next" title="Type">
<link href="User-Interface.html#User-Interface" rel="prev" title="User Interface">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Doc"></a>
<div class="header">
<p>
Next: <a href="Type.html#Type" accesskey="n" rel="next">Type</a>, Previous: <a href="User-Interface.html#User-Interface" accesskey="p" rel="prev">User Interface</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Doc-1"></a>
<h2 class="chapter">13 Doc</h2>
<dl>
<dt><a name="index-APROPOS"></a>Function: <strong>APROPOS</strong> <em>(string &amp;optional (package nil))</em></dt>
<dd><p>Package:LISP
</p>
<p>Prints those symbols whose print-names contain STRING as substring.
If PACKAGE is non-NIL, then only the specified package is searched.
</p>
</dd></dl>
<dl>
<dt><a name="index-INFO"></a>Function: <strong>INFO</strong> <em>(string &amp;optional (list-of-info-files *default-info-files*))</em></dt>
<dd><p>PACKAGE:SI
</p>
<p>Find all documentation about STRING in LIST-OF-INFO-FILES. The search
is done for STRING as a substring of a node name, or for STRING in the
indexed entries in the first index for each info file. Typically that
should be a variable and function definition index, if the info file is
about a programming language. If the windowing system is connected,
then a choice box is offered and double clicking on an item brings up
its documentation.
</p>
<p>Otherwise a list of choices is offered and the user may select some of
these choices.
</p>
<p>list-of-info-files is of the form
</p><div class="example">
<pre class="example"> (&quot;gcl-si.info&quot; &quot;gcl-tk.info&quot; &quot;gcl.info&quot;)
</pre></div>
<p>The above list is the default value of *default-info-files*,
a variable in the SI package. To find these files in the file
system, the search path *info-paths* is consulted as is the master
info directory <samp>dir</samp>.
</p>
<p>see *Index *default-info-files*:: and *Index *info-paths*::.
For example
</p><div class="example">
<pre class="example">(info &quot;defun&quot;)
0: DEFUN :(gcl-si.info)Special Forms and Functions.
1: (gcl.info)defun.
Enter n, all, none, or multiple choices eg 1 3 : 1
Info from file /home/wfs/gcl-doc/gcl.info:
defun [Macro]
---------------------------------------------------------------------------
`Defun' function-name lambda-list [[{declaration}* | documentation]]
...
</pre></div>
<p>would list the node <code>(gcl.info)defun</code>.
That is the node entitled <code>defun</code> from the info file gcl.info. That
documentation is based on the ANSI common lisp standard. The choice
</p><div class="example">
<pre class="example">DEFUN :(gcl-si.info)Special Forms and Functions.
</pre></div>
<p>refers to the documentation on DEFUN from the info file gcl-si.info in
the node <i>Special Forms And Functions</i>. This is an index reference
and only the part of the node which refers to <code>defun</code> will be
printed.
</p>
<div class="example">
<pre class="example">(info &quot;factor&quot; '(&quot;maxima.info&quot;))
</pre></div>
<p>would search the maxima info files index and nodes for <code>factor</code>.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002ainfo_002dpaths_002a"></a>Variable: <strong>*info-paths*</strong></dt>
<dd><p>Package SI:
</p>
<p>A list of strings such as
</p><div class="example">
<pre class="example"> '(&quot;&quot; &quot;/usr/info/&quot; &quot;/usr/local/lib/info/&quot; &quot;/usr/local/info/&quot;
&quot;/usr/local/gnu/info/&quot; )
</pre></div>
<p>saying where to look for the info files. It is used implicitly
by <code>info</code>, see *Index info::.
</p>
<p>Looking for maxima.info would look for the file
maxima.info in all the directories listed in *info-paths*. If nto found
then it would look for <samp>dir</samp> in the *info-paths* directories,
and if it were found it would look in the <samp>dir</samp> for a menu item
such as
</p>
<div class="example">
<pre class="example">* maxima: (/home/wfs/maxima-5.0/info/maxima.info).
</pre></div>
<p>If such an entry exists then the directory there would be used for the
purpose of finding <code>maxima.info</code>
</p>
</dd></dl>
<hr>
<div class="header">
<p>
Next: <a href="Type.html#Type" accesskey="n" rel="next">Type</a>, Previous: <a href="User-Interface.html#User-Interface" accesskey="p" rel="prev">User Interface</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

74
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Environment.html Normal file
View file

@ -0,0 +1,74 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Environment</title>
<meta name="description" content="GCL SI Manual: Environment">
<meta name="keywords" content="GCL SI Manual: Environment">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Miscellaneous.html#Miscellaneous" rel="up" title="Miscellaneous">
<link href="Inititialization.html#Inititialization" rel="next" title="Inititialization">
<link href="Miscellaneous.html#Miscellaneous" rel="prev" title="Miscellaneous">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Environment"></a>
<div class="header">
<p>
Next: <a href="Inititialization.html#Inititialization" accesskey="n" rel="next">Inititialization</a>, Previous: <a href="Miscellaneous.html#Miscellaneous" accesskey="p" rel="prev">Miscellaneous</a>, Up: <a href="Miscellaneous.html#Miscellaneous" accesskey="u" rel="up">Miscellaneous</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Environment-1"></a>
<h3 class="section">19.1 Environment</h3>
<p>The environment in GCL which is passed to macroexpand and
other functions requesting an environment, should be a
list of 3 lists. The first list looks like ((v1 val1) (v2 val2) ..)
where vi are variables and vali are their values.
The second is a list of ((fname1 . fbody1) (fname2 . fbody2) ...)
where fbody1 is either (macro lambda-list lambda-body) or
(lambda-list lambda-body) depending on whether this is a macro
or a function. The third list contains tags and blocks.
</p>
</body>
</html>

1240
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Function-and-Variable-Index.html Normal file
View file

File diff suppressed because it is too large Load diff

385
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/GCL-Specific.html Normal file
View file

@ -0,0 +1,385 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: GCL Specific</title>
<meta name="description" content="GCL SI Manual: GCL Specific">
<meta name="keywords" content="GCL SI Manual: GCL Specific">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="Bignums.html#Bignums" rel="next" title="Bignums">
<link href="Type.html#Type" rel="prev" title="Type">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="GCL-Specific"></a>
<div class="header">
<p>
Next: <a href="C-Interface.html#C-Interface" accesskey="n" rel="next">C Interface</a>, Previous: <a href="Type.html#Type" accesskey="p" rel="prev">Type</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="GCL-Specific-1"></a>
<h2 class="chapter">15 GCL Specific</h2>
<dl>
<dt><a name="index-SYSTEM"></a>Function: <strong>SYSTEM</strong> <em>(string)</em></dt>
<dd><p>Package:LISP
</p>
<p>GCL specific: Executes a Shell command as if STRING is an input to the
Shell. Not all versions of GCL support this function. At least on
POSIX systems, this call should return two integers represeting the
exit status and any possible terminating signal respectively.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aTMP_002dDIR_002a"></a>Variable: <strong>*TMP-DIR*</strong></dt>
<dd><p>Package:COMPILER
GCL specific: Directory in which temporary &ldquo;gazonk&rdquo; files used by the
compiler are to be created.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aIGNORE_002dMAXIMUM_002dPAGES_002a"></a>Variable: <strong>*IGNORE-MAXIMUM-PAGES*</strong></dt>
<dd><p>Package:SI
GCL specific: Tells the GCL memory manager whether (non-NIL) or not (NIL) it
should expand memory whenever the maximum allocatable pages have been used
up.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aOPTIMIZE_002dMAXIMUM_002dPAGES_002a"></a>Variable: <strong>*OPTIMIZE-MAXIMUM-PAGES*</strong></dt>
<dd><p>Package:SI
</p>
<p>GCL specific: Tells the GCL memory manager whether to attempt to
adjust the maximum allowable pages for each type to approximately
optimize the garbage collection load in the current process. Defaults
to T. Set to NIL if you care more about memory usage than runtime.
</p>
</dd></dl>
<dl>
<dt><a name="index-MACHINE_002dVERSION"></a>Function: <strong>MACHINE-VERSION</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a string that identifies the machine version of the machine
on which GCL is currently running.
</p>
</dd></dl>
<dl>
<dt><a name="index-BY"></a>Function: <strong>BY</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>GCL specific: Exits from GCL.
</p>
</dd></dl>
<dl>
<dt><a name="index-DEFCFUN"></a>Macro: <strong>DEFCFUN</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(defcfun header n {element}*)
</pre></div>
<p>GCL specific: Defines a C-language function which calls Lisp functions
and/or handles Lisp objects. HEADER gives the header of the C
function as a string. Non-negative-integer is the number of the main
stack entries used by the C function, primarily for protecting Lisp
objects from being garbage-collected. Each ELEMENT may give a C code
fragment as a string, or it may be a list
((symbol {arg}*) {place}*)
which, when executed, calls the Lisp function named by SYMBOL with the
specified arguments and saves the value(s) to the specified places.
The DEFCFUN form has the above meanings only after compiled; The GCL
interpreter simply ignores this form.
</p>
<p>An example which defines a C function list2 of two arguments, but which
calls the &rsquo;lisp&rsquo; function CONS by name, and refers to the constant &rsquo;NIL.
Note to be loaded by <code>load</code> the function should be static.
</p>
<p>(defCfun &quot;static object list2(x,y) object x,y;&quot; 0
&quot;object z;&quot;
(&rsquo;NIL z)
((CONS y z) z)
((CONS x z) z)
&quot;return(z);&quot;
)
</p>
<p>In lisp the operations in the body would be
(setq z &rsquo;nil)
(setq z (cons y z))
(setq z (cons x z))
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">
(defCfun header non-negative-integer
{ string
| ( function-symbol { value }* )
| (( function-symbol { value }* ) { place }* ) })
value:
place:
{ C-expr | ( C-type C-expr ) }
C-function-name:
C-expr:
{ string | symbol }
C-type:
{ object | int | char | float | double }
</pre></div>
</dd></dl>
<dl>
<dt><a name="index-CLINES"></a>Macro: <strong>CLINES</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(clines {string}*)
</pre></div>
<p>GCL specific: The GCL compiler embeds STRINGs into the intermediate C
language code. The interpreter ignores this form.
</p>
</dd></dl>
<dl>
<dt><a name="index-ALLOCATE"></a>Function: <strong>ALLOCATE</strong> <em>(type number &amp;optional (really-allocate nil))</em></dt>
<dd><p>Package:LISP
</p>
<p>GCL specific: Sets the maximum number of pages for the type class of the
GCL implementation type TYPE to NUMBER. If REALLY-ALLOCATE is given a
non-NIL value, then the specified number of pages will be allocated
immediately.
</p>
</dd></dl>
<dl>
<dt><a name="index-GBC"></a>Function: <strong>GBC</strong> <em>(x)</em></dt>
<dd><p>Package:LISP
</p>
<p>GCL specific: Invokes the garbage collector (GC) with the collection level
specified by X. NIL as the argument causes GC to collect cells only. T as
the argument causes GC to collect everything.
</p>
</dd></dl>
<dl>
<dt><a name="index-SAVE"></a>Function: <strong>SAVE</strong> <em>(pathname)</em></dt>
<dd><p>Package:LISP
</p>
<p>GCL specific: Saves the current GCL core image into a program file specified
by PATHNAME. This function depends on the version of GCL. The function
si::save-system is to be preferred in almost all circumstances. Unlike
save, it makes the relocatable section permanent, and causes no future gc of
currently loaded .o files.
</p>
</dd></dl>
<dl>
<dt><a name="index-HELP_002a"></a>Function: <strong>HELP*</strong> <em>(string &amp;optional (package 'lisp))</em></dt>
<dd><p>Package:LISP
</p>
<p>GCL specific: Prints the documentation associated with those symbols in the
specified package whose print names contain STRING as substring. STRING may
be a symbol, in which case the print-name of that symbol is used. If PACKAGE
is NIL, then all packages are searched.
</p>
</dd></dl>
<dl>
<dt><a name="index-DEFLA"></a>Macro: <strong>DEFLA</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(defla name lambda-list {decl | doc}* {form}*)
</pre></div>
<p>GCL specific: Used to DEFine Lisp Alternative. For the interpreter, DEFLA is
equivalent to DEFUN, but the compiler ignores this form.
</p>
</dd></dl>
<dl>
<dt><a name="index-PROCLAMATION"></a>Function: <strong>PROCLAMATION</strong> <em>(decl-spec)</em></dt>
<dd><p>Package:LISP
</p>
<p>GCL specific: Returns T if the specified declaration is globally in effect;
NIL otherwise. See the doc of DECLARE for possible DECL-SPECs.
</p>
</dd></dl>
<dl>
<dt><a name="index-DEFENTRY"></a>Macro: <strong>DEFENTRY</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(defentry name arg-types c-function)
</pre></div>
<p>GCL specific: The compiler defines a Lisp function whose body consists of a
calling sequence to the C language function specified by C-FUNCTION. The
interpreter ignores this form. The ARG-TYPES specifies the C types of the
arguments which C-FUNCTION requires. The list of allowed types is (object
char int float double string). Code will be produced to coerce from a lisp
object to the appropriate type before passing the argument to the C-FUNCTION.
The c-function should be of the form (c-result-type c-fname) where
c-result-type is a member of (void object char int float double string).
c-fname may be a symbol (in which case it will be downcased) or a string. If
c-function is not a list, then (object c-function) is assumed. In order
for C code to be loaded in by <code>load</code> you should declare any
variables and functions to be static. If you will link them in
at build time, of course you are allowed to define new externals.
</p>
<div class="example">
<pre class="example"> Sample usage:
--File begin-----
;; JOE takes X a lisp string and Y a fixnum and returns a character.
(clines &quot;#include \&quot;foo.ch\&quot;&quot;)
(defentry joe (string int) (char &quot;our_c_fun&quot;))
---File end------
---File foo.ch---
/* C function for extracting the i'th element of a string */
static char our_c_fun(p,i)
char *p;
int i;
{
return p[i];
}
-----File end---
</pre></div>
<p>One must be careful of storage allocation issues when passing a string.
If the C code invokes storage allocation (either by calling <code>malloc</code>
or <code>make_cons</code> etc), then there is a possibility of a garbage
collection, so that if the string passed was not constructed with
<code>:static t</code> when its array was constructed, then it could move.
If the C function may allocate storage, then you should pass a copy:
</p><div class="example">
<pre class="example">(defun safe-c-string (x)
(let* ((n (length x))
(a (make-array (+ n 1) :element-type 'string-char
:static t :fill-pointer n)))
(si::copy-array-portion x y 0 0 n)
(setf (aref a n) (code-char 0)))
a)
</pre></div>
</dd></dl>
<dl>
<dt><a name="index-COPY_002dARRAY_002dPORTION"></a>Function: <strong>COPY-ARRAY-PORTION</strong> <em>(x,y,i1,i2,n1)</em></dt>
<dd><p>Package:SI
Copy elements from X to Y starting at X[i1] to Y[i2] and doing N1
elements if N1 is supplied otherwise, doing the length of X - I1
elements. If the types of the arrays are not the same, this has
implementation dependent results.
</p></dd></dl>
<dl>
<dt><a name="index-BYE"></a>Function: <strong>BYE</strong> <em>( &amp;optional (exit-status 0))</em></dt>
<dd><p>Package:LISP
</p>
<p>GCL specific: Exits from GCL with exit-status.
</p>
</dd></dl>
<dl>
<dt><a name="index-USE_002dFAST_002dLINKS"></a>Function: <strong>USE-FAST-LINKS</strong> <em>(turn-on)</em></dt>
<dd><p>Package:LISP
</p>
<p>GCL specific: If TURN-ON is not nil, the fast link mechanism is enabled,
so that ordinary function calls will not appear in the invocation stack,
and calls will be much faster. This is the default. If you anticipate
needing to see a stack trace in the debugger, then you should turn this
off.
</p>
</dd></dl>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Bignums.html#Bignums" accesskey="1">Bignums</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
<hr>
<div class="header">
<p>
Next: <a href="C-Interface.html#C-Interface" accesskey="n" rel="next">C Interface</a>, Previous: <a href="Type.html#Type" accesskey="p" rel="prev">Type</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

72
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Inititialization.html Normal file
View file

@ -0,0 +1,72 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Inititialization</title>
<meta name="description" content="GCL SI Manual: Inititialization">
<meta name="keywords" content="GCL SI Manual: Inititialization">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Miscellaneous.html#Miscellaneous" rel="up" title="Miscellaneous">
<link href="Low-Level-X-Interface.html#Low-Level-X-Interface" rel="next" title="Low Level X Interface">
<link href="Environment.html#Environment" rel="prev" title="Environment">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Inititialization"></a>
<div class="header">
<p>
Next: <a href="Low-Level-X-Interface.html#Low-Level-X-Interface" accesskey="n" rel="next">Low Level X Interface</a>, Previous: <a href="Environment.html#Environment" accesskey="p" rel="prev">Environment</a>, Up: <a href="Miscellaneous.html#Miscellaneous" accesskey="u" rel="up">Miscellaneous</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Initialization"></a>
<h3 class="section">19.2 Initialization</h3>
<p>If the file init.lsp exists in the current directory, it is
loaded at startup. The first argument passed to the executable image
should be the system directory. Normally this would be gcl/unixport.
This directory is stored in the si::*system-directory* variable. If
the file sys-init.lsp exists in the system directory, it is loaded
before init.lsp. See also si::*TOP-LEVEL-HOOK*.
</p>
</body>
</html>

229
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Iteration-and-Tests.html Normal file
View file

@ -0,0 +1,229 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Iteration and Tests</title>
<meta name="description" content="GCL SI Manual: Iteration and Tests">
<meta name="keywords" content="GCL SI Manual: Iteration and Tests">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="User-Interface.html#User-Interface" rel="next" title="User Interface">
<link href="Structures.html#Structures" rel="prev" title="Structures">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Iteration-and-Tests"></a>
<div class="header">
<p>
Next: <a href="User-Interface.html#User-Interface" accesskey="n" rel="next">User Interface</a>, Previous: <a href="Structures.html#Structures" accesskey="p" rel="prev">Structures</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Iteration-and-Tests-1"></a>
<h2 class="chapter">11 Iteration and Tests</h2>
<dl>
<dt><a name="index-DO_002dEXTERNAL_002dSYMBOLS"></a>Macro: <strong>DO-EXTERNAL-SYMBOLS</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(do-external-symbols (var [package [result-form]])
{decl}* {tag | statement}*)
</pre></div>
<p>Executes STATEMENTs once for each external symbol in the PACKAGE (which
defaults to the current package), with VAR bound to the current symbol.
Then evaluates RESULT-FORM (which defaults to NIL) and returns the value(s).
</p>
</dd></dl>
<dl>
<dt><a name="index-DO_002a"></a>Special Form: <strong>DO*</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(do* ({(var [init [step]])}*) (endtest {result}*)
{decl}* {tag | statement}*)
</pre></div>
<p>Just like DO, but performs variable bindings and assignments in serial, just
like LET* and SETQ do.
</p>
</dd></dl>
<dl>
<dt><a name="index-DO_002dALL_002dSYMBOLS"></a>Macro: <strong>DO-ALL-SYMBOLS</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(do-all-symbols (var [result-form]) {decl}* {tag | statement}*)
</pre></div>
<p>Executes STATEMENTs once for each symbol in each package, with VAR bound to
the current symbol. Then evaluates RESULT-FORM (which defaults to NIL) and
returns the value(s).
</p>
</dd></dl>
<dl>
<dt><a name="index-YES_002dOR_002dNO_002dP"></a>Function: <strong>YES-OR-NO-P</strong> <em>(&amp;optional (format-string nil) &amp;rest args)</em></dt>
<dd><p>Package:LISP
</p>
<p>Asks the user a question whose answer is either &rsquo;YES&rsquo; or &rsquo;NO&rsquo;. If FORMAT-
STRING is non-NIL, then FRESH-LINE operation is performed, a message is
printed as if FORMAT-STRING and ARGs were given to FORMAT, and then a prompt
&quot;(Yes or No)&quot; is printed. Otherwise, no prompt will appear.
</p>
</dd></dl>
<dl>
<dt><a name="index-MAPHASH"></a>Function: <strong>MAPHASH</strong> <em>#'hash-table</em></dt>
<dd><p>Package:LISP
</p>
<p>For each entry in HASH-TABLE, calls FUNCTION on the key and value of the
entry; returns NIL.
</p>
</dd></dl>
<dl>
<dt><a name="index-MAPCAR"></a>Function: <strong>MAPCAR</strong> <em>(fun list &amp;rest more-lists)</em></dt>
<dd><p>Package:LISP
</p>
<p>Applies FUN to successive cars of LISTs and returns the results as a list.
</p>
</dd></dl>
<dl>
<dt><a name="index-DOLIST"></a>Special Form: <strong>DOLIST</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(dolist (var listform [result]) {decl}* {tag | statement}*)
</pre></div>
<p>Executes STATEMENTs, with VAR bound to each member of the list value of
LISTFORM. Then returns the value(s) of RESULT (which defaults to NIL).
</p>
</dd></dl>
<dl>
<dt><a name="index-EQ"></a>Function: <strong>EQ</strong> <em>(x y)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if X and Y are the same identical object; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-EQUALP"></a>Function: <strong>EQUALP</strong> <em>(x y)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if X and Y are EQUAL, if they are characters and satisfy CHAR-EQUAL,
if they are numbers and have the same numerical value, or if they have
components that are all EQUALP. Returns NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-EQUAL"></a>Function: <strong>EQUAL</strong> <em>(x y)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if X and Y are EQL or if they are of the same type and corresponding
components are EQUAL. Returns NIL otherwise. Strings and bit-vectors are
EQUAL if they are the same length and have identical components. Other
arrays must be EQ to be EQUAL.
</p>
</dd></dl>
<dl>
<dt><a name="index-DO_002dSYMBOLS"></a>Macro: <strong>DO-SYMBOLS</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(do-symbols (var [package [result-form]]) {decl}* {tag |
statement}*)
</pre></div>
<p>Executes STATEMENTs once for each symbol in the PACKAGE (which defaults to
the current package), with VAR bound to the current symbol. Then evaluates
RESULT-FORM (which defaults to NIL) and returns the value(s).
</p>
</dd></dl>
<dl>
<dt><a name="index-LOOP"></a>Special Form: <strong>LOOP</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(loop {form}*)
</pre></div>
<p>Executes FORMs repeatedly until exited by a THROW or RETURN. The FORMs are
surrounded by an implicit NIL block.
</p>
</dd></dl>
<hr>
<div class="header">
<p>
Next: <a href="User-Interface.html#User-Interface" accesskey="n" rel="next">User Interface</a>, Previous: <a href="Structures.html#Structures" accesskey="p" rel="prev">Structures</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

1075
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Lists.html Normal file
View file

File diff suppressed because it is too large Load diff

84
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Low-Level-Debug-Functions.html Normal file
View file

@ -0,0 +1,84 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Low Level Debug Functions</title>
<meta name="description" content="GCL SI Manual: Low Level Debug Functions">
<meta name="keywords" content="GCL SI Manual: Low Level Debug Functions">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Debugging.html#Debugging" rel="up" title="Debugging">
<link href="Miscellaneous.html#Miscellaneous" rel="next" title="Miscellaneous">
<link href="Source-Level-Debugging-in-Emacs.html#Source-Level-Debugging-in-Emacs" rel="prev" title="Source Level Debugging in Emacs">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Low-Level-Debug-Functions"></a>
<div class="header">
<p>
Previous: <a href="Source-Level-Debugging-in-Emacs.html#Source-Level-Debugging-in-Emacs" accesskey="p" rel="prev">Source Level Debugging in Emacs</a>, Up: <a href="Debugging.html#Debugging" accesskey="u" rel="up">Debugging</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Low-Level-Debug-Functions-1"></a>
<h3 class="section">18.2 Low Level Debug Functions</h3>
<p>Use the following functions to directly access GCL stacks.
</p><div class="example">
<pre class="example">(SI:VS i) Returns the i-th entity in VS.
(SI:IHS-VS i) Returns the VS index of the i-th entity in IHS.
(SI:IHS-FUN i) Returns the function of the i-th entity in IHS.
(SI:FRS-VS i) Returns the VS index of the i-th entity in FRS.
(SI:FRS-BDS i) Returns the BDS index of the i-th entity in FRS.
(SI:FRS-IHS i) Returns the IHS index of the i-th entity in FRS.
(SI:BDS-VAR i) Returns the symbol of the i-th entity in BDS.
(SI:BDS-VAL i) Returns the value of the i-th entity in BDS.
(SI:SUPER-GO i tag)
Jumps to the specified tag established by the TAGBODY frame at
FRS[i]. Both arguments are evaluated. If FRS[i] happens to be
a non-TAGBODY frame, then (THROW (SI:IHS-TAG i) (VALUES)) is
performed.
</pre></div>
</body>
</html>

79
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Low-Level-X-Interface.html Normal file
View file

@ -0,0 +1,79 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Low Level X Interface</title>
<meta name="description" content="GCL SI Manual: Low Level X Interface">
<meta name="keywords" content="GCL SI Manual: Low Level X Interface">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Miscellaneous.html#Miscellaneous" rel="up" title="Miscellaneous">
<link href="Compiler-Definitions.html#Compiler-Definitions" rel="next" title="Compiler Definitions">
<link href="Inititialization.html#Inititialization" rel="prev" title="Inititialization">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Low-Level-X-Interface"></a>
<div class="header">
<p>
Previous: <a href="Inititialization.html#Inititialization" accesskey="p" rel="prev">Inititialization</a>, Up: <a href="Miscellaneous.html#Miscellaneous" accesskey="u" rel="up">Miscellaneous</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Low-Level-X-Interface-1"></a>
<h3 class="section">19.3 Low Level X Interface</h3>
<p>A sample program for drawing things on X windows from lisp
is included in the file gcl/lsp/littleXlsp.lsp
</p>
<p>That routine invokes the corresponding C routines in XLIB.
So in order to use it you must &lsquo;faslink&rsquo; in the X routines.
Directions are given at the beginning of the lisp file,
for either building them into the image or using faslink.
</p>
<p>This program is also a good tutorial on invoking C from lisp.
</p>
<p>See also defentry and faslink.
</p>
</body>
</html>

74
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Miscellaneous.html Normal file
View file

@ -0,0 +1,74 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Miscellaneous</title>
<meta name="description" content="GCL SI Manual: Miscellaneous">
<meta name="keywords" content="GCL SI Manual: Miscellaneous">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="Environment.html#Environment" rel="next" title="Environment">
<link href="Low-Level-Debug-Functions.html#Low-Level-Debug-Functions" rel="prev" title="Low Level Debug Functions">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Miscellaneous"></a>
<div class="header">
<p>
Next: <a href="Compiler-Definitions.html#Compiler-Definitions" accesskey="n" rel="next">Compiler Definitions</a>, Previous: <a href="Debugging.html#Debugging" accesskey="p" rel="prev">Debugging</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Miscellaneous-1"></a>
<h2 class="chapter">19 Miscellaneous</h2>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Environment.html#Environment" accesskey="1">Environment</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Inititialization.html#Inititialization" accesskey="2">Inititialization</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Low-Level-X-Interface.html#Low-Level-X-Interface" accesskey="3">Low Level X Interface</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

1560
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Numbers.html Normal file
View file

File diff suppressed because it is too large Load diff

419
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Operating-System-Definitions.html Normal file
View file

@ -0,0 +1,419 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Operating System Definitions</title>
<meta name="description" content="GCL SI Manual: Operating System Definitions">
<meta name="keywords" content="GCL SI Manual: Operating System Definitions">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Operating-System.html#Operating-System" rel="up" title="Operating System">
<link href="Structures.html#Structures" rel="next" title="Structures">
<link href="Command-Line.html#Command-Line" rel="prev" title="Command Line">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Operating-System-Definitions"></a>
<div class="header">
<p>
Previous: <a href="Command-Line.html#Command-Line" accesskey="p" rel="prev">Command Line</a>, Up: <a href="Operating-System.html#Operating-System" accesskey="u" rel="up">Operating System</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Operating-System-Definitions-1"></a>
<h3 class="section">9.2 Operating System Definitions</h3>
<dl>
<dt><a name="index-GET_002dDECODED_002dTIME"></a>Function: <strong>GET-DECODED-TIME</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the current time in decoded time format. Returns nine values: second,
minute, hour, date, month, year, day-of-week, daylight-saving-time-p, and
time-zone.
</p>
</dd></dl>
<dl>
<dt><a name="index-HOST_002dNAMESTRING"></a>Function: <strong>HOST-NAMESTRING</strong> <em>(pathname)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the host part of PATHNAME as a string.
</p>
</dd></dl>
<dl>
<dt><a name="index-RENAME_002dFILE"></a>Function: <strong>RENAME-FILE</strong> <em>(file new-name)</em></dt>
<dd><p>Package:LISP
</p>
<p>Renames the file FILE to NEW-NAME. FILE may be a string, a pathname, or
a stream.
</p>
</dd></dl>
<dl>
<dt><a name="index-FILE_002dAUTHOR"></a>Function: <strong>FILE-AUTHOR</strong> <em>(file)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the author name of the specified file, as a string.
FILE may be a string or a stream
</p>
</dd></dl>
<dl>
<dt><a name="index-PATHNAME_002dHOST"></a>Function: <strong>PATHNAME-HOST</strong> <em>(pathname)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the host slot of PATHNAME.
</p>
</dd></dl>
<dl>
<dt><a name="index-FILE_002dPOSITION"></a>Function: <strong>FILE-POSITION</strong> <em>(file-stream &amp;optional position)</em></dt>
<dd><p>Package:LISP
</p>
<p>Sets the file pointer of the specified file to POSITION, if POSITION is given.
Otherwise, returns the current file position of the specified file.
</p>
</dd></dl>
<dl>
<dt><a name="index-DECODE_002dUNIVERSAL_002dTIME"></a>Function: <strong>DECODE-UNIVERSAL-TIME</strong> <em>(universal-time &amp;optional (timezone -9))</em></dt>
<dd><p>Package:LISP
</p>
<p>Converts UNIVERSAL-TIME into a decoded time at the TIMEZONE.
Returns nine values: second, minute, hour, date, month (1 - 12), year,
day-of-week (0 - 6), daylight-saving-time-p, and time-zone.
TIMEZONE in GCL defaults to 6, the time zone of Austin, Texas.
</p>
</dd></dl>
<dl>
<dt><a name="index-USER_002dHOMEDIR_002dPATHNAME"></a>Function: <strong>USER-HOMEDIR-PATHNAME</strong> <em>(&amp;optional host)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the home directory of the logged in user as a pathname. HOST
is ignored.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aMODULES_002a"></a>Variable: <strong>*MODULES*</strong></dt>
<dd><p>Package:LISP
A list of names of the modules that have been loaded into GCL.
</p>
</dd></dl>
<dl>
<dt><a name="index-SHORT_002dSITE_002dNAME"></a>Function: <strong>SHORT-SITE-NAME</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a string that identifies the physical location of the current GCL.
</p>
</dd></dl>
<dl>
<dt><a name="index-DIRECTORY"></a>Function: <strong>DIRECTORY</strong> <em>(name)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a list of files that match NAME. NAME may be a string, a pathname,
or a file stream.
</p>
</dd></dl>
<dl>
<dt><a name="index-SOFTWARE_002dVERSION"></a>Function: <strong>SOFTWARE-VERSION</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a string that identifies the software version of the software
under which GCL is currently running.
</p>
</dd></dl>
<dl>
<dt><a name="index-INTERNAL_002dTIME_002dUNITS_002dPER_002dSECOND"></a>Constant: <strong>INTERNAL-TIME-UNITS-PER-SECOND</strong></dt>
<dd><p>Package:LISP
The number of internal time units that fit into a second.
</p>
</dd></dl>
<dl>
<dt><a name="index-ENOUGH_002dNAMESTRING"></a>Function: <strong>ENOUGH-NAMESTRING</strong> <em>(pathname &amp;optional (defaults *default-pathname-defaults*))</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a string which uniquely identifies PATHNAME with respect to
DEFAULTS.
</p>
</dd></dl>
<dl>
<dt><a name="index-REQUIRE"></a>Function: <strong>REQUIRE</strong> <em>(module-name &amp;optional (pathname))</em></dt>
<dd><p>Package:LISP
</p>
<p>If the specified module is not present, then loads the appropriate file(s).
PATHNAME may be a single pathname or it may be a list of pathnames.
</p>
</dd></dl>
<dl>
<dt><a name="index-ENCODE_002dUNIVERSAL_002dTIME"></a>Function: <strong>ENCODE-UNIVERSAL-TIME</strong> <em>(second minute hour date month year &amp;optional (timezone ))</em></dt>
<dd><p>Package:LISP
</p>
<p>Does the inverse operation of DECODE-UNIVERSAL-TIME.
</p>
</dd></dl>
<dl>
<dt><a name="index-LISP_002dIMPLEMENTATION_002dVERSION"></a>Function: <strong>LISP-IMPLEMENTATION-VERSION</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a string that tells you when the current GCL implementation is
brought up.
</p>
</dd></dl>
<dl>
<dt><a name="index-MACHINE_002dINSTANCE"></a>Function: <strong>MACHINE-INSTANCE</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a string that identifies the machine instance of the machine
on which GCL is currently running.
</p>
</dd></dl>
<dl>
<dt><a name="index-ROOM"></a>Function: <strong>ROOM</strong> <em>(&amp;optional (x t))</em></dt>
<dd><p>Package:LISP
</p>
<p>Displays information about storage allocation in the following format.
</p>
<ul class="no-bullet">
<li> for each type class
<ul class="no-bullet">
<li> the number of pages so-far allocated for the type class
</li><li> the maximum number of pages for the type class
</li><li> the percentage of used cells to cells so-far allocated
</li><li> the number of times the garbage collector has been called to
collect cells of the type class
</li><li> the implementation types that belongs to the type class
</li></ul>
</li><li> the number of pages actually allocated for contiguous blocks
</li><li> the maximum number of pages for contiguous blocks
</li><li> the number of times the garbage collector has been called to collect
contiguous blocks
</li><li> the number of pages in the hole
</li><li> the maximum number of pages for relocatable blocks
</li><li> the number of times the garbage collector has been called to collect
relocatable blocks
</li><li> the total number of pages allocated for cells
</li><li> the total number of pages allocated
</li><li> the number of available pages
</li><li> the number of pages GCL can use.
<p>The number of times the garbage collector has been called is not shown,
if the number is zero. The optional X is ignored.
</p></li></ul>
</dd></dl>
<dl>
<dt><a name="index-GET_002dUNIVERSAL_002dTIME"></a>Function: <strong>GET-UNIVERSAL-TIME</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the current time as a single integer in universal time format.
</p>
</dd></dl>
<dl>
<dt><a name="index-GET_002dINTERNAL_002dRUN_002dTIME"></a>Function: <strong>GET-INTERNAL-RUN-TIME</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the run time in the internal time format. This is useful for
finding CPU usage. If the operating system allows, a second value
containing CPU usage of child processes is returned.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aDEFAULT_002dPATHNAME_002dDEFAULTS_002a"></a>Variable: <strong>*DEFAULT-PATHNAME-DEFAULTS*</strong></dt>
<dd><p>Package:LISP
The default pathname-defaults pathname.
</p>
</dd></dl>
<dl>
<dt><a name="index-LONG_002dSITE_002dNAME"></a>Function: <strong>LONG-SITE-NAME</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a string that identifies the physical location of the current GCL.
</p>
</dd></dl>
<dl>
<dt><a name="index-DELETE_002dFILE"></a>Function: <strong>DELETE-FILE</strong> <em>(file)</em></dt>
<dd><p>Package:LISP
Deletes FILE.
</p>
</dd></dl>
<dl>
<dt><a name="index-GET_002dINTERNAL_002dREAL_002dTIME"></a>Function: <strong>GET-INTERNAL-REAL-TIME</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the real time in the internal time format. This is useful for
finding elapsed time.
</p>
</dd></dl>
<dl>
<dt><a name="index-MACHINE_002dTYPE"></a>Function: <strong>MACHINE-TYPE</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a string that identifies the machine type of the machine
on which GCL is currently running.
</p>
</dd></dl>
<dl>
<dt><a name="index-TIME"></a>Macro: <strong>TIME</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(time form)
</pre></div>
<p>Evaluates FORM and outputs timing statistics on *TRACE-OUTPUT*.
</p>
</dd></dl>
<dl>
<dt><a name="index-SOFTWARE_002dTYPE"></a>Function: <strong>SOFTWARE-TYPE</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a string that identifies the software type of the software
under which GCL is currently running.
</p>
</dd></dl>
<dl>
<dt><a name="index-LISP_002dIMPLEMENTATION_002dTYPE"></a>Function: <strong>LISP-IMPLEMENTATION-TYPE</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a string that tells you that you are using a version of GCL.
</p>
</dd></dl>
<dl>
<dt><a name="index-SLEEP"></a>Function: <strong>SLEEP</strong> <em>(n)</em></dt>
<dd><p>Package:LISP
</p>
<p>This function causes execution to be suspended for N seconds. N may
be any non-negative, non-complex number.
</p>
</dd></dl>
<dl>
<dt><a name="index-BREAK_002dON_002dFLOATING_002dPOINT_002dEXCEPTIONS"></a>Function: <strong>BREAK-ON-FLOATING-POINT-EXCEPTIONS</strong> <em>(&amp;key division-by-zero</em></dt>
<dd><p>floating-point-invalid-operation
floating-point-overflow
floating-point-underflow
floating-point-inexact)
Package:SI
</p>
<p>Break on the specified IEEE floating point error conditions. With no
arguments, report the exceptions currently trapped. Disable the break
by setting the key to nil, e.g.
</p>
<p>&gt; (break-on-floaing-point-exceptions :division-by-zero t)
(DIVISION-BY-ZERO)
</p>
<p>&gt; (break-on-floaing-point-exceptions)
(DIVISION-BY-ZERO)
</p>
<p>&gt; (break-on-floaing-point-exceptions :division-by-zero nil)
NIL
</p>
<p>On some of the most common platforms, the offending instruction will be
disassembled, and the register arguments looked up in the saved context
and reported in as operands. Within the error handler, addresses may be
disassembled, and other registers inspected, using the functions defined
in gcl_fpe.lsp.
</p>
</dd></dl>
<hr>
<div class="header">
<p>
Previous: <a href="Command-Line.html#Command-Line" accesskey="p" rel="prev">Command Line</a>, Up: <a href="Operating-System.html#Operating-System" accesskey="u" rel="up">Operating System</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

72
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Operating-System.html Normal file
View file

@ -0,0 +1,72 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Operating System</title>
<meta name="description" content="GCL SI Manual: Operating System">
<meta name="keywords" content="GCL SI Manual: Operating System">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="Command-Line.html#Command-Line" rel="next" title="Command Line">
<link href="Symbols.html#Symbols" rel="prev" title="Symbols">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Operating-System"></a>
<div class="header">
<p>
Next: <a href="Structures.html#Structures" accesskey="n" rel="next">Structures</a>, Previous: <a href="Symbols.html#Symbols" accesskey="p" rel="prev">Symbols</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Operating-System-1"></a>
<h2 class="chapter">9 Operating System</h2>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Command-Line.html#Command-Line" accesskey="1">Command Line</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Operating-System-Definitions.html#Operating-System-Definitions" accesskey="2">Operating System Definitions</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

211
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Regular-Expressions.html Normal file
View file

@ -0,0 +1,211 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Regular Expressions</title>
<meta name="description" content="GCL SI Manual: Regular Expressions">
<meta name="keywords" content="GCL SI Manual: Regular Expressions">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="System-Definitions.html#System-Definitions" rel="up" title="System Definitions">
<link href="Debugging.html#Debugging" rel="next" title="Debugging">
<link href="System-Definitions.html#System-Definitions" rel="prev" title="System Definitions">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Regular-Expressions"></a>
<div class="header">
<p>
Previous: <a href="System-Definitions.html#System-Definitions" accesskey="p" rel="prev">System Definitions</a>, Up: <a href="System-Definitions.html#System-Definitions" accesskey="u" rel="up">System Definitions</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Regular-Expressions-1"></a>
<h3 class="section">17.1 Regular Expressions</h3>
<p>The function <code>string-match</code> (*Index string-match::) is used to
match a regular expression against a string. If the variable
<code>*case-fold-search*</code> is not nil, case is ignored in the match.
To determine the extent of the match use *Index match-beginning:: and
*Index match-end::.
</p>
<p>Regular expressions are implemented using Henry Spencer&rsquo;s package
(thank you Henry!), and much of the description of regular expressions
below is copied verbatim from his manual entry. Code for delimited
searches, case insensitive searches, and speedups to allow fast
searching of long files was contributed by W. Schelter. The speedups
use an adaptation by Schelter of the Boyer and Moore string search
algorithm to the case of branched regular expressions. These allow
such expressions as &rsquo;not_there|really_not&rsquo; to be searched for 30 times
faster than in GNU emacs (1995), and 200 times faster than in the
original Spencer method. Expressions such as [a-u]bcdex get a speedup
of 60 and 194 times respectively. This is based on searching a string
of 50000 characters (such as the file tk.lisp).
</p>
<ul>
<li> A regular expression is a string containing zero or more <i>branches</i> which are separated by <code>|</code>. A match of the regular expression against a string is simply a match of the string with one of the branches.
</li><li> Each branch consists of zero or more <i>pieces</i>, concatenated. A matching
string must contain an initial substring matching the first piece, immediately
followed by a second substring matching the second piece and so on.
</li><li> Each piece is an <i>atom</i> optionally followed by <code>+</code>, <code>*</code>, or <code>?</code>.
</li><li> An atom followed by <code>+</code> matches a sequence of 1 or more matches of the atom.
</li><li> An atom followed by <code>*</code> matches a sequence of 0 or more matches of the atom.
</li><li> An atom followed by <code>?</code> matches a match of the atom, or the null string.
</li><li> An atom is
<ul class="no-bullet">
<li>- a regular expression in parentheses matching a match for the regular expression
</li><li>- a <i>range</i> see below
</li><li>- a <code>.</code> matching any single character
</li><li>- a <code>^</code> matching the null string at the beginning of the input string
</li><li>- a <code>$</code> matching the null string at the end of the input string
</li><li>- a <code>\</code> followed by a single character matching that character
</li><li>- a single character with no other significance
(matching that character).
</li></ul>
</li><li> A <i>range</i> is a sequence of characters enclosed in <code>[]</code>.
It normally matches any single character from the sequence.
<ul class="no-bullet">
<li>- If the sequence begins with <code>^</code>,
it matches any single character <i>not</i> from the rest of the sequence.
</li><li>- If two characters in the sequence are separated by <code>-</code>, this is shorthand
for the full list of ASCII characters between them
(e.g. <code>[0-9]</code> matches any decimal digit).
</li><li>- To include a literal <code>]</code> in the sequence, make it the first character
(following a possible <code>^</code>).
</li><li>- To include a literal <code>-</code>, make it the first or last character.
</li></ul>
</li></ul>
<a name="Ordering-Multiple-Matches"></a>
<h4 class="unnumberedsubsec">Ordering Multiple Matches</h4>
<p>In general there may be more than one way to match a regular expression
to an input string. For example, consider the command
</p>
<div class="example">
<pre class="example"> (string-match &quot;(a*)b*&quot; &quot;aabaaabb&quot;)
</pre></div>
<p>Considering only the rules given so far, the value of (list-matches 0 1)
might be <code>(&quot;aabb&quot; &quot;aa&quot;)</code> or <code>(&quot;aaab&quot; &quot;aaa&quot;)</code> or <code>(&quot;ab&quot; &quot;a&quot;)</code>
or any of several other combinations.
To resolve this potential ambiguity <b>string-match</b> chooses among
alternatives using the rule <i>first then longest</i>.
In other words, it considers the possible matches in order working
from left to right across the input string and the pattern, and it
attempts to match longer pieces of the input string before shorter
ones. More specifically, the following rules apply in decreasing
order of priority:
</p><ul class="no-bullet">
<li> [1]
If a regular expression could match two different parts of an input string
then it will match the one that begins earliest.
</li><li> [2]
If a regular expression contains <b>|</b> operators then the leftmost
matching sub-expression is chosen.
</li><li> [3]
In <b>*</b><span class="roman">, </span><b>+</b><span class="roman">, and </span><b>?</b> constructs, longer matches are chosen
in preference to shorter ones.
</li><li> [4]
In sequences of expression components the components are considered
from left to right.
</li></ul>
<p>In the example from above, <b>(a*)b*</b><span class="roman"> matches </span><b>aab</b><span class="roman">: the </span><b>(a*)</b>
portion of the pattern is matched first and it consumes the leading
<b>aa</b><span class="roman">; then the </span><b>b*</b> portion of the pattern consumes the
next <b>b</b>. Or, consider the following example:
</p>
<div class="example">
<pre class="example"> (string-match &quot;(ab|a)(b*)c&quot; &quot;xabc&quot;) ==&gt; 1
(list-matches 0 1 2 3) ==&gt; (&quot;abc&quot; &quot;ab&quot; &quot;&quot; NIL)
(match-beginning 0) ==&gt; 1
(match-end 0) ==&gt; 4
(match-beginning 1) ==&gt; 1
(match-end 1) ==&gt; 3
(match-beginning 2) ==&gt; 3
(match-end 2) ==&gt; 3
(match-beginning 3) ==&gt; -1
(match-end 3) ==&gt; -1
</pre></div>
<p>In the above example the return value of <code>1</code> (which is <code>&gt; -1</code>)
indicates that a match was found. The entire match runs from
1 to 4.
Rule 4 specifies that <b>(ab|a)</b> gets first shot at the input
string and Rule 2 specifies that the <b>ab</b> sub-expression
is checked before the <b>a</b> sub-expression.
Thus the <b>b</b><span class="roman"> has already been claimed before the </span><b>(b*)</b>
component is checked and <b>(b*)</b> must match an empty string.
</p>
<p>The special characters in the string <code>&quot;\()[]+.*|^$?&quot;</code>,
must be quoted, if a simple string search is desired. The function
re-quote-string is provided for this purpose.
</p><div class="example">
<pre class="example">(re-quote-string &quot;*standard*&quot;) ==&gt; &quot;\\*standard\\*&quot;
(string-match (re-quote-string &quot;*standard*&quot;) &quot;X *standard* &quot;)
==&gt; 2
(string-match &quot;*standard*&quot; &quot;X *standard* &quot;)
Error: Regexp Error: ?+* follows nothing
</pre></div>
<p>Note there is actually just one <code>\</code> before the <code>*</code>
but the printer makes two so that the string can be read, since
<code>\</code> is also the lisp quote character. In the last example
an error is signalled since the special character <code>*</code> must
follow an atom if it is interpreted as a regular expression.
</p>
<hr>
<div class="header">
<p>
Previous: <a href="System-Definitions.html#System-Definitions" accesskey="p" rel="prev">System Definitions</a>, Up: <a href="System-Definitions.html#System-Definitions" accesskey="u" rel="up">System Definitions</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

1162
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Sequences-and-Arrays-and-Hash-Tables.html Normal file
View file

File diff suppressed because it is too large Load diff

170
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Source-Level-Debugging-in-Emacs.html Normal file
View file

@ -0,0 +1,170 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Source Level Debugging in Emacs</title>
<meta name="description" content="GCL SI Manual: Source Level Debugging in Emacs">
<meta name="keywords" content="GCL SI Manual: Source Level Debugging in Emacs">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Debugging.html#Debugging" rel="up" title="Debugging">
<link href="Low-Level-Debug-Functions.html#Low-Level-Debug-Functions" rel="next" title="Low Level Debug Functions">
<link href="Debugging.html#Debugging" rel="prev" title="Debugging">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Source-Level-Debugging-in-Emacs"></a>
<div class="header">
<p>
Next: <a href="Low-Level-Debug-Functions.html#Low-Level-Debug-Functions" accesskey="n" rel="next">Low Level Debug Functions</a>, Previous: <a href="Debugging.html#Debugging" accesskey="p" rel="prev">Debugging</a>, Up: <a href="Debugging.html#Debugging" accesskey="u" rel="up">Debugging</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Source-Level-Debugging-in-Emacs-1"></a>
<h3 class="section">18.1 Source Level Debugging in Emacs</h3>
<p>In emacs load (load &quot;dbl.el&quot;) from the gcl/doc directory.
[ It also requires gcl.el from that directory. Your system
administrator should do make in the doc directory, so that
these files are copied to the standard location.]
</p>
<p>OVERVIEW:
</p>
<p>Lisp files loaded with si::nload will have source line information about
them recorded. Break points may be set, and functions stepped. Source code
will be automatically displayed in the other window, with a little arrow beside
the current line. The backtrace (command :bt) will show line information and
you will get automatic display of the source as you move up and down the stack.
</p>
<p>FUNCTIONS:
break points which have been set.
si::nload (file)
load a lisp file collecting source line information.
</p>
<p>si::break-function (function &amp;optional line absolute)
set up a breakpoint for FUNCTION at LINE relative to start or ABSOLUTE
</p>
<p>EMACS COMMANDS:
M-x dbl makes a dbl buffer, suitable for running an inferior gcl.
It has special keybindings for stepping and viewing sources. You may
start your favorite gcl program in the dbl shell buffer.
</p>
<p>Inferior Dbl Mode:
Major mode for interacting with an inferior Dbl process.
The following commands are available:
</p>
<p>C-c l dbl-find-line
</p>
<p>ESC d dbl-:down
ESC u dbl-:up
ESC c dbl-:r
ESC n dbl-:next
ESC i dbl-:step
ESC s dbl-:step
</p>
<p>M-x dbl-display-frame displays in the other window
the last line referred to in the dbl buffer.
</p>
<p>ESC i and ESC n in the dbl window,
call dbl to step and next and then update the other window
with the current file and position.
</p>
<p>If you are in a source file, you may select a point to break
at, by doing C-x SPC.
</p>
<p>Commands:
Many commands are inherited from shell mode.
Additionally we have:
</p>
<p>M-x dbl-display-frame display frames file in other window
ESC i advance one line in program
ESC n advance one line in program (skip over calls).
M-x send-dbl-command used for special printing of an arg at the current point.
C-x SPACE sets break point at current line.
</p>
<p>&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;&mdash;-
</p>
<p>When visiting a lisp buffer (if gcl.el is loaded in your emacs) the command
c-m-x evaluates the current defun into the process running in the other window.
Line information will be kept. This line information allows you to set break
points at a given line (by typing C-x \space on the line in the source file
where you want the break to occur. Once stopped within a function you may
single step with M-s. This moves one line at a time in the source code,
displaying a little arrow beside your current position. M-c is like M-s,
except that function invocations are skipped over, rather than entered into.
M-c continues execution.
</p>
<p>Keywords typed at top level, in the debug loop have
a special meaning:
</p><ul class="no-bullet">
<li> :delete [n1] [n2] .. &ndash; delete all break points or just n1,n2
</li><li> :disable [n1] [n2] .. &ndash; disable all break points or just n1,n2
</li><li> :enable [n1] [n2] .. &ndash; enable all break points or just n1,n2
</li><li> :info [:bkpt] &ndash;print information about
</li><li> :break [fun] [line] &ndash; break at the current location, or if
fun is supplied in fun. Break at the beginning unless a
line offset from the beginning of fun is supplied.
</li><li> :fr [n] go to frame n When in frame n, if the frame is interpreted,
typing the name of locals, will print their values. If it is compiled
you must use (si::loc j) to print &lsquo;locj&rsquo;. Autodisplay of the source
will take place if it is interpreted and the line can be determined.
</li><li> :up [n] go up n frames from the current frame.
</li><li> :down [n] go down n frames
</li><li> :bt [n] back trace starting at the current frame and going to top level
If n is specified show only n frames.
</li><li> :r If stopped in a function resume. If at top level in the dbl
loop, exit and resume an outer loop.
</li><li> :q quit the computation back to top level dbl loop.
</li><li> :step step to the next line with line information
</li><li> :next step to the next line with line information skipping over function
invocations.
</li></ul>
<p>Files: debug.lsp dbl.el gcl.el
</p>
<hr>
<div class="header">
<p>
Next: <a href="Low-Level-Debug-Functions.html#Low-Level-Debug-Functions" accesskey="n" rel="next">Low Level Debug Functions</a>, Previous: <a href="Debugging.html#Debugging" accesskey="p" rel="prev">Debugging</a>, Up: <a href="Debugging.html#Debugging" accesskey="u" rel="up">Debugging</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

1279
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Special-Forms-and-Functions.html Normal file
View file

File diff suppressed because it is too large Load diff

1174
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Streams-and-Reading.html Normal file
View file

File diff suppressed because it is too large Load diff

108
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Structures.html Normal file
View file

@ -0,0 +1,108 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Structures</title>
<meta name="description" content="GCL SI Manual: Structures">
<meta name="keywords" content="GCL SI Manual: Structures">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="Iteration-and-Tests.html#Iteration-and-Tests" rel="next" title="Iteration and Tests">
<link href="Operating-System-Definitions.html#Operating-System-Definitions" rel="prev" title="Operating System Definitions">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Structures"></a>
<div class="header">
<p>
Next: <a href="Iteration-and-Tests.html#Iteration-and-Tests" accesskey="n" rel="next">Iteration and Tests</a>, Previous: <a href="Operating-System.html#Operating-System" accesskey="p" rel="prev">Operating System</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Structures-1"></a>
<h2 class="chapter">10 Structures</h2>
<dl>
<dt><a name="index-DEFSTRUCT"></a>Macro: <strong>DEFSTRUCT</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(defstruct
{name | (name {:conc-name | (:conc-name prefix-string) |
:constructor | (:constructor symbol [lambda-list]) |
:copier | (:copier symbol) |
:predicate | (:predicate symbol) |
(:include symbol) |
(:print-function function) |
(:type {vector | (vector type) | list}) |
:named | (:static { nil | t})
(:initial-offset number)}*)}
[doc]
{slot-name |
(slot-name [default-value-form] {:type type | :read-only flag}*) }*
)
</pre></div>
<p>Defines a structure. The doc-string DOC, if supplied, is saved as a STRUCTURE
doc and can be retrieved by (documentation &rsquo;NAME &rsquo;structure).
STATIC is gcl specific and makes the body non relocatable.
</p>
<p>See the files misc/rusage.lsp misc/cstruct.lsp, for examples of making
a lisp structure correspond to a C structure.
</p>
</dd></dl>
<dl>
<dt><a name="index-HELP"></a>Function: <strong>HELP</strong> <em>(&amp;optional symbol)</em></dt>
<dd><p>Package:LISP
</p>
<p>GCL specific: Prints the documentation associated with SYMBOL. With no
argument, this function prints the greeting message to GCL beginners.
</p>
</dd></dl>
</body>
</html>

580
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Symbols.html Normal file
View file

@ -0,0 +1,580 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Symbols</title>
<meta name="description" content="GCL SI Manual: Symbols">
<meta name="keywords" content="GCL SI Manual: Symbols">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="Operating-System.html#Operating-System" rel="next" title="Operating System">
<link href="Compilation.html#Compilation" rel="prev" title="Compilation">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Symbols"></a>
<div class="header">
<p>
Next: <a href="Operating-System.html#Operating-System" accesskey="n" rel="next">Operating System</a>, Previous: <a href="Compilation.html#Compilation" accesskey="p" rel="prev">Compilation</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Symbols-1"></a>
<h2 class="chapter">8 Symbols</h2>
<dl>
<dt><a name="index-GENSYM"></a>Function: <strong>GENSYM</strong> <em>(&amp;optional (x nil))</em></dt>
<dd><p>Package:LISP
</p>
<p>Creates and returns a new uninterned symbol whose name is a prefix string
(defaults to &quot;G&quot;), followed by a decimal number. The number is incremented
by each call to GENSYM. X, if an integer, resets the counter. If X is a
string, it becomes the new prefix.
</p>
</dd></dl>
<dl>
<dt><a name="index-KEYWORDP"></a>Function: <strong>KEYWORDP</strong> <em>(x)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if X is a symbol and it belongs to the KEYWORD package; NIL
otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-REMPROP"></a>Function: <strong>REMPROP</strong> <em>(symbol indicator)</em></dt>
<dd><p>Package:LISP
</p>
<p>Look on property list of SYMBOL for property with specified
INDICATOR. If found, splice this indicator and its value out of
the plist, and return T. If not found, returns NIL with no side effects.
</p>
</dd></dl>
<dl>
<dt><a name="index-SYMBOL_002dPACKAGE"></a>Function: <strong>SYMBOL-PACKAGE</strong> <em>(symbol)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the contents of the package cell of the symbol SYMBOL.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aPACKAGE_002a"></a>Variable: <strong>*PACKAGE*</strong></dt>
<dd><p>Package:LISP
The current package.
</p>
</dd></dl>
<dl>
<dt><a name="index-SHADOWING_002dIMPORT"></a>Function: <strong>SHADOWING-IMPORT</strong> <em>(symbols &amp;optional (package *package*))</em></dt>
<dd><p>Package:LISP
</p>
<p>Imports SYMBOLS into PACKAGE, disregarding any name conflict. If a symbol
of the same name is already present, then it is uninterned. SYMBOLS must
be a list of symbols or a symbol.
</p>
</dd></dl>
<dl>
<dt><a name="index-REMF"></a>Macro: <strong>REMF</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(remf place indicator)
</pre></div>
<p>PLACE may be any place expression acceptable to SETF, and is expected
to hold a property list or NIL. This list is destructively altered to
remove the property specified by INDICATOR. Returns T if such a
property was present; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-MAKUNBOUND"></a>Function: <strong>MAKUNBOUND</strong> <em>(symbol)</em></dt>
<dd><p>Package:LISP
</p>
<p>Makes empty the value slot of SYMBOL. Returns SYMBOL.
</p>
</dd></dl>
<dl>
<dt><a name="index-USE_002dPACKAGE"></a>Function: <strong>USE-PACKAGE</strong> <em>(packages-to-use &amp;optional (package *package*))</em></dt>
<dd><p>Package:LISP
</p>
<p>Adds all packages in PACKAGE-TO-USE list to the use list for PACKAGE so that
the external symbols of the used packages are available as internal symbols
in PACKAGE.
</p>
</dd></dl>
<dl>
<dt><a name="index-MAKE_002dSYMBOL"></a>Function: <strong>MAKE-SYMBOL</strong> <em>(string)</em></dt>
<dd><p>Package:LISP
</p>
<p>Creates and returns a new uninterned symbol whose print name is STRING.
</p>
</dd></dl>
<dl>
<dt><a name="index-PSETQ"></a>Special Form: <strong>PSETQ</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(psetq {var form}*)
</pre></div>
<p>Similar to SETQ, but evaluates all FORMs first, and then assigns each value to
the corresponding VAR. Returns NIL always.
</p>
</dd></dl>
<dl>
<dt><a name="index-PACKAGE_002dUSED_002dBY_002dLIST"></a>Function: <strong>PACKAGE-USED-BY-LIST</strong> <em>(package)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the list of packages that use PACKAGE.
</p>
</dd></dl>
<dl>
<dt><a name="index-SYMBOLP"></a>Function: <strong>SYMBOLP</strong> <em>(x)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if X is a symbol; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-NIL"></a>Constant: <strong>NIL</strong></dt>
<dd><p>Package:LISP
Holds NIL.
</p>
</dd></dl>
<dl>
<dt><a name="index-SET"></a>Function: <strong>SET</strong> <em>(symbol value)</em></dt>
<dd><p>Package:LISP
</p>
<p>Assigns the value of VALUE to the dynamic variable named by SYMBOL, and
returns the value assigned.
</p>
</dd></dl>
<dl>
<dt><a name="index-SETQ"></a>Special Form: <strong>SETQ</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(setq {var form}*)
</pre></div>
<p>VARs are not evaluated and must be symbols. Assigns the value of the first
FORM to the first VAR, then assigns the value of the second FORM to the second
VAR, and so on. Returns the last value assigned.
</p>
</dd></dl>
<dl>
<dt><a name="index-UNUSE_002dPACKAGE"></a>Function: <strong>UNUSE-PACKAGE</strong> <em>(packages-to-unuse &amp;optional (package *package*))</em></dt>
<dd><p>Package:LISP
</p>
<p>Removes PACKAGES-TO-UNUSE from the use list for PACKAGE.
</p>
</dd></dl>
<dl>
<dt><a name="index-T"></a>Constant: <strong>T</strong></dt>
<dd><p>Package:LISP
Holds T.
</p>
</dd></dl>
<dl>
<dt><a name="index-PACKAGE_002dUSE_002dLIST"></a>Function: <strong>PACKAGE-USE-LIST</strong> <em>(package)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the list of packages used by PACKAGE.
</p>
</dd></dl>
<dl>
<dt><a name="index-LIST_002dALL_002dPACKAGES"></a>Function: <strong>LIST-ALL-PACKAGES</strong> <em>()</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a list of all existing packages.
</p>
</dd></dl>
<dl>
<dt><a name="index-COPY_002dSYMBOL"></a>Function: <strong>COPY-SYMBOL</strong> <em>(symbol &amp;optional (copy-props nil))</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a new uninterned symbol with the same print name as SYMBOL.
If COPY-PROPS is NIL, the function, the variable, and the property slots
of the new symbol have no value. Otherwise, these slots are given the
values of the corresponding slots of SYMBOL.
</p>
</dd></dl>
<dl>
<dt><a name="index-SYMBOL_002dPLIST"></a>Function: <strong>SYMBOL-PLIST</strong> <em>(symbol)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the property list of SYMBOL.
</p>
</dd></dl>
<dl>
<dt><a name="index-SYMBOL_002dNAME"></a>Function: <strong>SYMBOL-NAME</strong> <em>(symbol)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the print name of the symbol SYMBOL.
</p>
</dd></dl>
<dl>
<dt><a name="index-FIND_002dSYMBOL"></a>Function: <strong>FIND-SYMBOL</strong> <em>(name &amp;optional (package *package*))</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the symbol named NAME in
PACKAGE. If such a symbol is found, then the second value is :INTERN,
:EXTERNAL, or :INHERITED to indicate how the symbol is accessible. If
no symbol is found then both values are NIL.
</p>
</dd></dl>
<dl>
<dt><a name="index-SHADOW"></a>Function: <strong>SHADOW</strong> <em>(symbols &amp;optional (package *package*))</em></dt>
<dd><p>Package:LISP
</p>
<p>Creates an internal symbol in PACKAGE with the same name as each of the
specified SYMBOLS. SYMBOLS must be a list of symbols or a symbol.
</p>
</dd></dl>
<dl>
<dt><a name="index-FBOUNDP"></a>Function: <strong>FBOUNDP</strong> <em>(symbol)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if SYMBOL has a global function definition or if SYMBOL names a
special form or a macro; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-MACRO_002dFUNCTION"></a>Function: <strong>MACRO-FUNCTION</strong> <em>(symbol)</em></dt>
<dd><p>Package:LISP
</p>
<p>If SYMBOL globally names a macro, then returns the expansion function.
Returns NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-IN_002dPACKAGE"></a>Function: <strong>IN-PACKAGE</strong> <em>(package-name &amp;key (nicknames nil) (use '(lisp)))</em></dt>
<dd><p>Package:LISP
</p>
<p>Sets *PACKAGE* to the package with PACKAGE-NAME, creating the package if
it does not exist. If the package already exists then it is modified
to agree with USE and NICKNAMES arguments. Any new nicknames are added
without removing any old ones not specified. If any package in the USE list
is not currently used, then it is added to the use list.
</p>
</dd></dl>
<dl>
<dt><a name="index-MAKE_002dPACKAGE"></a>Function: <strong>MAKE-PACKAGE</strong> <em>(package-name &amp;key (nicknames nil) (use '(lisp)))</em></dt>
<dd><p>Package:LISP
</p>
<p>Makes a new package having the specified PACKAGE-NAME and NICKNAMES. The
package will inherit all external symbols from each package in the USE list.
</p>
</dd></dl>
<dl>
<dt><a name="index-PACKAGE_002dSHADOWING_002dSYMBOLS"></a>Function: <strong>PACKAGE-SHADOWING-SYMBOLS</strong> <em>(package)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the list of symbols that have been declared as shadowing symbols
in PACKAGE.
</p>
</dd></dl>
<dl>
<dt><a name="index-INTERN"></a>Function: <strong>INTERN</strong> <em>(name &amp;optional (package *package*))</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a symbol having the specified name, creating it if necessary.
Returns as the second value one of the symbols :INTERNAL, :EXTERNAL,
:INHERITED, and NIL.
</p>
</dd></dl>
<dl>
<dt><a name="index-EXPORT"></a>Function: <strong>EXPORT</strong> <em>(symbols &amp;optional (package *package*))</em></dt>
<dd><p>Package:LISP
</p>
<p>Makes SYMBOLS external symbols of PACKAGE. SYMBOLS must be a list of symbols
or a symbol.
</p>
</dd></dl>
<dl>
<dt><a name="index-PACKAGEP"></a>Function: <strong>PACKAGEP</strong> <em>(x)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if X is a package; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-SYMBOL_002dFUNCTION"></a>Function: <strong>SYMBOL-FUNCTION</strong> <em>(symbol)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the current global function definition named by SYMBOL.
</p>
</dd></dl>
<dl>
<dt><a name="index-SYMBOL_002dVALUE"></a>Function: <strong>SYMBOL-VALUE</strong> <em>(symbol)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the current value of the dynamic (special) variable named by SYMBOL.
</p>
</dd></dl>
<dl>
<dt><a name="index-BOUNDP"></a>Function: <strong>BOUNDP</strong> <em>(symbol)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if the global variable named by SYMBOL has a value; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-DOCUMENTATION"></a>Function: <strong>DOCUMENTATION</strong> <em>(symbol doc-type)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the doc-string of DOC-TYPE for SYMBOL; NIL if none exists.
Possible doc-types are:
FUNCTION (special forms, macros, and functions)
VARIABLE (dynamic variables, including constants)
TYPE (types defined by DEFTYPE)
STRUCTURE (structures defined by DEFSTRUCT)
SETF (SETF methods defined by DEFSETF, DEFINE-SETF-METHOD, and
DEFINE-MODIFY-MACRO)
All built-in special forms, macros, functions, and variables have their
doc-strings.
</p>
</dd></dl>
<dl>
<dt><a name="index-GENTEMP"></a>Function: <strong>GENTEMP</strong> <em>(&amp;optional (prefix &quot;t&quot;) (package *package*))</em></dt>
<dd><p>Package:LISP
</p>
<p>Creates a new symbol interned in the package PACKAGE with the given PREFIX.
</p>
</dd></dl>
<dl>
<dt><a name="index-RENAME_002dPACKAGE"></a>Function: <strong>RENAME-PACKAGE</strong> <em>(package new-name &amp;optional (new-nicknames nil))</em></dt>
<dd><p>Package:LISP
</p>
<p>Replaces the old name and nicknames of PACKAGE with NEW-NAME and
NEW-NICKNAMES.
</p>
</dd></dl>
<dl>
<dt><a name="index-UNINTERN"></a>Function: <strong>UNINTERN</strong> <em>(symbol &amp;optional (package *package*))</em></dt>
<dd><p>Package:LISP
</p>
<p>Makes SYMBOL no longer present in PACKAGE. Returns T if SYMBOL was present;
NIL otherwise. If PACKAGE is the home package of SYMBOL, then makes SYMBOL
uninterned.
</p>
</dd></dl>
<dl>
<dt><a name="index-UNEXPORT"></a>Function: <strong>UNEXPORT</strong> <em>(symbols &amp;optional (package *package*))</em></dt>
<dd><p>Package:LISP
</p>
<p>Makes SYMBOLS no longer accessible as external symbols in PACKAGE. SYMBOLS
must be a list of symbols or a symbol.
</p>
</dd></dl>
<dl>
<dt><a name="index-PACKAGE_002dNICKNAMES"></a>Function: <strong>PACKAGE-NICKNAMES</strong> <em>(package)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns as a list the nickname strings for the specified PACKAGE.
</p>
</dd></dl>
<dl>
<dt><a name="index-IMPORT"></a>Function: <strong>IMPORT</strong> <em>(symbols &amp;optional (package *package*))</em></dt>
<dd><p>Package:LISP
</p>
<p>Makes SYMBOLS internal symbols of PACKAGE. SYMBOLS must be a list of symbols
or a symbol.
</p>
</dd></dl>
<dl>
<dt><a name="index-GET"></a>Function: <strong>GET</strong> <em>(symbol indicator &amp;optional (default nil))</em></dt>
<dd><p>Package:LISP
</p>
<p>Looks on the property list of SYMBOL for the specified INDICATOR. If this
is found, returns the associated value. Otherwise, returns DEFAULT.
</p>
</dd></dl>
<dl>
<dt><a name="index-FIND_002dALL_002dSYMBOLS"></a>Function: <strong>FIND-ALL-SYMBOLS</strong> <em>(string-or-symbol)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns a list of all symbols that have the specified name.
</p>
</dd></dl>
<dl>
<dt><a name="index-FMAKUNBOUND"></a>Function: <strong>FMAKUNBOUND</strong> <em>(symbol)</em></dt>
<dd><p>Package:LISP
</p>
<p>Discards the global function definition named by SYMBOL. Returns SYMBOL.
</p>
</dd></dl>
<dl>
<dt><a name="index-PACKAGE_002dNAME"></a>Function: <strong>PACKAGE-NAME</strong> <em>(package)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the string that names the specified PACKAGE.
</p>
</dd></dl>
<dl>
<dt><a name="index-FIND_002dPACKAGE"></a>Function: <strong>FIND-PACKAGE</strong> <em>(name)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the specified package if it already exists; NIL otherwise. NAME may
be a string that is the name or nickname of the package. NAME may also be
a symbol, in which case the symbol&rsquo;s print name is used.
</p>
</dd></dl>
<dl>
<dt><a name="index-APROPOS_002dLIST"></a>Function: <strong>APROPOS-LIST</strong> <em>(string &amp;optional (package nil))</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns, as a list, all symbols whose print-names contain STRING as substring.
If PACKAGE is non-NIL, then only the specified package is searched.
</p>
</dd></dl>
<hr>
<div class="header">
<p>
Next: <a href="Operating-System.html#Operating-System" accesskey="n" rel="next">Operating System</a>, Previous: <a href="Compilation.html#Compilation" accesskey="p" rel="prev">Compilation</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

1159
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/System-Definitions.html Normal file
View file

File diff suppressed because it is too large Load diff

197
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/Type.html Normal file
View file

@ -0,0 +1,197 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Type</title>
<meta name="description" content="GCL SI Manual: Type">
<meta name="keywords" content="GCL SI Manual: Type">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="GCL-Specific.html#GCL-Specific" rel="next" title="GCL Specific">
<link href="Doc.html#Doc" rel="prev" title="Doc">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Type"></a>
<div class="header">
<p>
Next: <a href="GCL-Specific.html#GCL-Specific" accesskey="n" rel="next">GCL Specific</a>, Previous: <a href="Doc.html#Doc" accesskey="p" rel="prev">Doc</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Type-1"></a>
<h2 class="chapter">14 Type</h2>
<dl>
<dt><a name="index-COERCE"></a>Function: <strong>COERCE</strong> <em>(x type)</em></dt>
<dd><p>Package:LISP
</p>
<p>Coerces X to an object of the type TYPE.
</p>
</dd></dl>
<dl>
<dt><a name="index-TYPE_002dOF"></a>Function: <strong>TYPE-OF</strong> <em>(x)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns the type of X.
</p>
</dd></dl>
<dl>
<dt><a name="index-CONSTANTP"></a>Function: <strong>CONSTANTP</strong> <em>(symbol)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if the variable named by SYMBOL is a constant; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-TYPEP"></a>Function: <strong>TYPEP</strong> <em>(x type)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if X is of the type TYPE; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-COMMONP"></a>Function: <strong>COMMONP</strong> <em>(x)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if X is a Common Lisp object; NIL otherwise.
</p>
</dd></dl>
<dl>
<dt><a name="index-SUBTYPEP"></a>Function: <strong>SUBTYPEP</strong> <em>(type1 type2)</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns T if TYPE1 is a subtype of TYPE2; NIL otherwise. If it could not
determine, then returns NIL as the second value. Otherwise, the second value
is T.
</p>
</dd></dl>
<dl>
<dt><a name="index-CHECK_002dTYPE"></a>Macro: <strong>CHECK-TYPE</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(check-type place typespec [string])
</pre></div>
<p>Signals an error, if the contents of PLACE are not of the specified type.
</p>
</dd></dl>
<dl>
<dt><a name="index-ASSERT"></a>Macro: <strong>ASSERT</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(assert test-form [({place}*) [string {arg}*]])
</pre></div>
<p>Signals an error if the value of TEST-FORM is NIL. STRING is an format string
used as the error message. ARGs are arguments to the format string.
</p>
</dd></dl>
<dl>
<dt><a name="index-DEFTYPE"></a>Macro: <strong>DEFTYPE</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(deftype name lambda-list {decl | doc}* {form}*)
</pre></div>
<p>Defines a new type-specifier abbreviation in terms of an &rsquo;expansion&rsquo; function
(lambda lambda-list1 {decl}* {form}*)
where lambda-list1 is identical to LAMBDA-LIST except that all optional
parameters with no default value specified in LAMBDA-LIST defaults to the
symbol &rsquo;*&rsquo;, but not to NIL. When the type system of GCL encounters a
type specifier (NAME arg1 ... argn), it calls the expansion function with
the arguments arg1 ... argn, and uses the returned value instead of the
original type specifier. When the symbol NAME is used as a type specifier,
the expansion function is called with no argument. The doc-string DOC, if
supplied, is saved as the TYPE doc of NAME, and is retrieved by
(documentation &rsquo;NAME &rsquo;type).
</p>
</dd></dl>
<dl>
<dt><a name="index-DYNAMIC_002dEXTENT"></a>Declaration: <strong>DYNAMIC-EXTENT</strong></dt>
<dd><p>Package:LISP
Declaration to allow locals to be cons&rsquo;d on the C stack.
For example
(defun foo (&amp;rest l) (declare (:dynamic-extent l)) ...)
will cause l to be a list formed on the C stack of the foo function
frame.
Of course passing L out as a value of foo will cause havoc.
(setq x (make-list n))
(setq x (cons a b))
(setq x (list a b c ..))
also are handled on the stack, for dynamic-extent x.
</p>
</dd></dl>
<hr>
<div class="header">
<p>
Next: <a href="GCL-Specific.html#GCL-Specific" accesskey="n" rel="next">GCL Specific</a>, Previous: <a href="Doc.html#Doc" accesskey="p" rel="prev">Doc</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

485
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/User-Interface.html Normal file
View file

@ -0,0 +1,485 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: User Interface</title>
<meta name="description" content="GCL SI Manual: User Interface">
<meta name="keywords" content="GCL SI Manual: User Interface">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="Doc.html#Doc" rel="next" title="Doc">
<link href="Iteration-and-Tests.html#Iteration-and-Tests" rel="prev" title="Iteration and Tests">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="User-Interface"></a>
<div class="header">
<p>
Next: <a href="Doc.html#Doc" accesskey="n" rel="next">Doc</a>, Previous: <a href="Iteration-and-Tests.html#Iteration-and-Tests" accesskey="p" rel="prev">Iteration and Tests</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="User-Interface-1"></a>
<h2 class="chapter">12 User Interface</h2>
<dl>
<dt><a name="index-_002d-1"></a>Special Variable: <strong>-</strong></dt>
<dd><p>Package:LISP
Holds the top-level form that GCL is currently evaluating.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002d"></a>Function: <strong>-</strong> <em>(number &amp;rest more-numbers)</em></dt>
<dd><p>Package:LISP
</p>
<p>Subtracts the second and all subsequent NUMBERs from the first NUMBER.
With one arg, negates it.
</p>
</dd></dl>
<dl>
<dt><a name="index-UNTRACE"></a>Macro: <strong>UNTRACE</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(untrace {function-name}*)
</pre></div>
<p>Removes tracing from the specified functions. With no FUNCTION-NAMEs,
untraces all functions.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002a_002a_002a"></a>Variable: <strong>***</strong></dt>
<dd><p>Package:LISP
Gets the previous value of ** when GCL evaluates a top-level form.
</p>
</dd></dl>
<dl>
<dt><a name="index-MAKE_002dSTRING_002dINPUT_002dSTREAM-1"></a>Function: <strong>MAKE-STRING-INPUT-STREAM</strong> <em>(string &amp;optional (start 0) (end (length string)))</em></dt>
<dd><p>Package:LISP
</p>
<p>Returns an input stream which will supply the characters of String between
Start and End in order.
</p>
</dd></dl>
<dl>
<dt><a name="index-STEP"></a>Macro: <strong>STEP</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(step form)
</pre></div>
<p>Evaluates FORM in the single-step mode and returns the value.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aBREAK_002dENABLE_002a"></a>Variable: <strong>*BREAK-ENABLE*</strong></dt>
<dd><p>Package:LISP
GCL specific: When an error occurrs, control enters to the break loop only
if the value of this variable is non-NIL.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002f-1"></a>Special Variable: <strong>/</strong></dt>
<dd><p>Package:LISP
Holds a list of the values of the last top-level form.
</p>
</dd></dl>
<dl>
<dt><a name="index-DESCRIBE"></a>Function: <strong>DESCRIBE</strong> <em>(x)</em></dt>
<dd><p>Package:LISP
</p>
<p>Prints a description of the object X.
</p>
</dd></dl>
<dl>
<dt><a name="index-ED"></a>Function: <strong>ED</strong> <em>(&amp;optional x)</em></dt>
<dd><p>Package:LISP
</p>
<p>Invokes the editor. The action depends on the version of GCL.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aDEBUG_002dIO_002a"></a>Variable: <strong>*DEBUG-IO*</strong></dt>
<dd><p>Package:LISP
Holds the I/O stream used by the GCL debugger.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aBREAK_002dON_002dWARNINGS_002a"></a>Variable: <strong>*BREAK-ON-WARNINGS*</strong></dt>
<dd><p>Package:LISP
When the function WARN is called, control enters to the break loop only
if the value of this varialbe is non-NIL.
</p>
</dd></dl>
<dl>
<dt><a name="index-CERROR"></a>Function: <strong>CERROR</strong> <em>(continue-format-string error-format-string &amp;rest args)</em></dt>
<dd><p>Package:LISP
</p>
<p>Signals a correctable error.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002a_002a"></a>Variable: <strong>**</strong></dt>
<dd><p>Package:LISP
Gets the previous value of * when GCL evaluates a top-level form.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002b_002b_002b"></a>Special Variable: <strong>+++</strong></dt>
<dd><p>Package:LISP
Gets the previous value of ++ when GCL evaluates a top-level form.
</p>
</dd></dl>
<dl>
<dt><a name="index-INSPECT"></a>Function: <strong>INSPECT</strong> <em>(x)</em></dt>
<dd><p>Package:LISP
</p>
<p>Shows the information about the object X in an interactive manner
</p>
</dd></dl>
<dl>
<dt><a name="index-_002f_002f"></a>Special Variable: <strong>//</strong></dt>
<dd><p>Package:LISP
Gets the previous value of / when GCL evaluates a top-level form.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aTRACE_002dOUTPUT_002a"></a>Variable: <strong>*TRACE-OUTPUT*</strong></dt>
<dd><p>Package:LISP
The trace output stream.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002b_002b"></a>Special Variable: <strong>++</strong></dt>
<dd><p>Package:LISP
Gets the previous value of + when GCL evaluates a top-level form.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002aERROR_002dOUTPUT_002a"></a>Variable: <strong>*ERROR-OUTPUT*</strong></dt>
<dd><p>Package:LISP
Holds the output stream for error messages.
</p>
</dd></dl>
<dl>
<dt><a name="index-DRIBBLE"></a>Function: <strong>DRIBBLE</strong> <em>(&amp;optional pathname)</em></dt>
<dd><p>Package:LISP
</p>
<p>If PATHNAME is given, begins to record the interaction to the specified file.
If PATHNAME is not given, ends the recording.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002a-1"></a>Variable: <strong>*</strong></dt>
<dd><p>Package:LISP
Holds the value of the last top-level form.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002f_002f_002f"></a>Special Variable: <strong>///</strong></dt>
<dd><p>Package:LISP
Gets the previous value of // when GCL evaluates a top-level form.
</p>
</dd></dl>
<dl>
<dt><a name="index-WARN"></a>Function: <strong>WARN</strong> <em>(format-string &amp;rest args)</em></dt>
<dd><p>Package:LISP
</p>
<p>Formats FORMAT-STRING and ARGs to *ERROR-OUTPUT* as a warning message.
</p>
</dd></dl>
<dl>
<dt><a name="index-BREAK"></a>Function: <strong>BREAK</strong> <em>(&amp;optional (format-string nil) &amp;rest args)</em></dt>
<dd><p>Package:LISP
</p>
<p>Enters a break loop. If FORMAT-STRING is non-NIL, formats FORMAT-STRING
and ARGS to *ERROR-OUTPUT* before entering a break loop.
Typing :HELP at the break loop will list the break-loop commands.
</p>
</dd></dl>
<dl>
<dt><a name="index-_002b-1"></a>Special Variable: <strong>+</strong></dt>
<dd><p>Package:LISP
Holds the last top-level form.
</p>
</dd></dl>
<dl>
<dt><a name="index-TRACE"></a>Macro: <strong>TRACE</strong></dt>
<dd><p>Package:LISP
</p>
<p>Syntax:
</p><div class="example">
<pre class="example">(trace {function-name}*)
</pre></div>
<p>Traces the specified functions. With no FUNCTION-NAMEs, returns a list of
functions currently being traced.
</p>
<p>Additional Keywords are allowed in GCL with the
syntax (trace {fn | (fn {:kw form}*)}*)
</p>
<p>For each FN naming a function, traces that function. Each :KW should
be one of the ones listed below, and FORM should have the
corresponding form. No :KW may be given more than once for the same
FN. Returns a list of all FNs now traced which weren&rsquo;t already
traced.
</p>
<p>EXAMPLE (Try this with your favorite factorial function FACT):
</p>
<div class="example">
<pre class="example">;; print entry args and exit values
(trace FACT)
;; Break coming out of FACT if the value is bigger than 1000.
(trace (fact :exit
(progn
(if (&gt; (car values) 1000)(break &quot;big result&quot;))
(car values))))
;; Hairy example:
;;make arglist available without the si:: prefix
(import 'si::arglist)
(trace (fact
:DECLARATIONS
((in-string &quot;Here comes input: &quot;)
(out-string &quot;Here comes output: &quot;)
all-values
(silly (+ 3 4)))
:COND
(equal (rem (car arglist) 2) 0)
:ENTRY
(progn
(cond
((equal (car arglist) 8)
(princ &quot;Entering FACT on input 8!! &quot;)
(setq out-string &quot;Here comes output from inside (FACT 8): &quot;))
(t
(princ in-string)))
(car arglist))
:EXIT
(progn
(setq all-values (cons (car values) all-values))
(princ out-string)
(when (equal (car arglist) 8)
;; reset out-string
(setq out-string &quot;Here comes output: &quot;))
(cons 'fact values))
:ENTRYCOND
(not (= (car arglist) 6))
:EXITCOND
(not (= (car values) (* 6 (car arglist))))
:DEPTH
5))
</pre></div>
<p>Syntax is <code>:keyword</code> <i>form1</i> <code>:keyword</code> <i>form2</i> ...
</p>
<dl compact="compact">
<dt><code>:declarations</code></dt>
<dd><div class="example">
<pre class="example">DEFAULT: NIL
</pre></div>
<p>FORM is ((var1 form1 )(var2 form2 )...), where
the var_i are symbols distinct from each other and from
all symbols which are similarly declared for currently
traced functions. Each form is evaluated immediately.
Upon any invocation of a traced function when not already
inside a traced function call, each var is bound to
that value of form .
</p>
</dd>
<dt><code>:COND</code></dt>
<dd><div class="example">
<pre class="example">DEFAULT: T
</pre></div>
<p>Here, FORM is any Lisp form to be evaluated (by EVAL)
upon entering a call of FN, in the environment where si::ARGLIST
is bound to the current list of arguments of FN. Note that
even if the evaluation of FORM changes the value of SI::ARGLIST
(e.g. by evaluation of (SETQ si::ARGLIST ...)), the list of
arguments passed to FN is unchanged. Users may alter args passed
by destructively modifying the list structure of SI::ARGLIST
however. The call is traced
(thus invoking the :ENTRYCOND and :EXITCOND forms, at least)
if and only if FORM does not evaluate to NIL.
</p>
</dd>
<dt><code>:ENTRYCOND</code></dt>
<dd><div class="example">
<pre class="example">DEFAULT: T
</pre></div>
<p>This is evaluated (by EVAL) if the :COND form evaluates to
non-NIL, both in an environment where SI::ARGLIST is bound to the
current list of arguments of FN. If non-NIL, the :ENTRY form
is then evaluated and printed with the trace &quot;prompt&quot;.
</p>
</dd>
<dt><code>:ENTRY</code></dt>
<dd><div class="example">
<pre class="example">DEFAULT: (CONS (QUOTE x) SI::ARGLIST),
</pre></div>
<p>where x is the symbol we call FN
If the :COND and :ENTRYCOND forms evaluate to non-NIL,
then the trace &quot;prompt&quot; is printed and then this FORM is
evaluated (by EVAL) in an environment where SI::ARGLIST is bound
to the current list of arguments of FN. The result is then
printed.
</p>
</dd>
<dt><code>:EXITCOND</code></dt>
<dd><div class="example">
<pre class="example">DEFAULT: T
</pre></div>
<p>This is evaluated (by EVAL) in the environment described
below for the :EXIT form. The :EXIT form is then evaluated
and printed with the &quot;prompt&quot; if and only if the result here
is non-NIL.
</p>
</dd>
<dt><code>:EXIT</code></dt>
<dd><div class="example">
<pre class="example">DEFAULT: (CONS (QUOTE x) VALUES),
</pre></div>
<p>where x is the symbol we call FN
Upon exit from tracing a given call, this FORM is
evaluated (after the appropriate trace &quot;prompt&quot; is printed),
using EVAL in an environment where SI::ARGLIST is bound to the
current list of arguments of FN and VALUES is bound to the
list of values returned by FN (recalling that Common Lisp
functions may return multiple values).
</p>
</dd>
<dt><code>:DEPTH</code></dt>
<dd><div class="example">
<pre class="example">DEFAULT: No depth limit
</pre></div>
<p>FORM is simply a positive integer specifying the maximum
nesting of traced calls of FN, i.e. of calls of FN in which
the :COND form evaluated to non-NIL. For calls of FN in
which this limit is exceeded, even the :COND form is not
evaluated, and the call is not traced.
</p>
</dd>
</dl>
</dd></dl>
<hr>
<div class="header">
<p>
Next: <a href="Doc.html#Doc" accesskey="n" rel="next">Doc</a>, Previous: <a href="Iteration-and-Tests.html#Iteration-and-Tests" accesskey="p" rel="prev">Iteration and Tests</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

160
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-doc/index.html Normal file
View file

@ -0,0 +1,160 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL SI Manual: Top</title>
<meta name="description" content="GCL SI Manual: Top">
<meta name="keywords" content="GCL SI Manual: Top">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Function-and-Variable-Index.html#Function-and-Variable-Index" rel="index" title="Function and Variable Index">
<link href="Function-and-Variable-Index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="http://www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/dir/index.html" rel="up" title="(dir)">
<link href="Numbers.html#Numbers" rel="next" title="Numbers">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Top"></a>
<div class="header">
<p>
Next: <a href="Numbers.html#Numbers" accesskey="n" rel="next">Numbers</a>, Previous: <a href="http://www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/dir/index.html" accesskey="p" rel="prev">(dir)</a>, Up: <a href="http://www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/dir/index.html" accesskey="u" rel="up">(dir)</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="SEC_Top"></a>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Numbers.html#Numbers" accesskey="1">Numbers</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Sequences-and-Arrays-and-Hash-Tables.html#Sequences-and-Arrays-and-Hash-Tables" accesskey="2">Sequences and Arrays and Hash Tables</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Characters.html#Characters" accesskey="3">Characters</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Lists.html#Lists" accesskey="4">Lists</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Streams-and-Reading.html#Streams-and-Reading" accesskey="5">Streams and Reading</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Special-Forms-and-Functions.html#Special-Forms-and-Functions" accesskey="6">Special Forms and Functions</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Compilation.html#Compilation" accesskey="7">Compilation</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Symbols.html#Symbols" accesskey="8">Symbols</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Operating-System.html#Operating-System" accesskey="9">Operating System</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Structures.html#Structures">Structures</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Iteration-and-Tests.html#Iteration-and-Tests">Iteration and Tests</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="User-Interface.html#User-Interface">User Interface</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Doc.html#Doc">Doc</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Type.html#Type">Type</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="GCL-Specific.html#GCL-Specific">GCL Specific</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="C-Interface.html#C-Interface">C Interface</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="System-Definitions.html#System-Definitions">System Definitions</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Debugging.html#Debugging">Debugging</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Miscellaneous.html#Miscellaneous">Miscellaneous</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Compiler-Definitions.html#Compiler-Definitions">Compiler Definitions</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Function-and-Variable-Index.html#Function-and-Variable-Index">Function and Variable Index</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><th colspan="3" align="left" valign="top"><pre class="menu-comment">
&mdash; The Detailed Node Listing &mdash;
Operating System
</pre></th></tr><tr><td align="left" valign="top">&bull; <a href="Command-Line.html#Command-Line">Command Line</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Operating-System-Definitions.html#Operating-System-Definitions">Operating System Definitions</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><th colspan="3" align="left" valign="top"><pre class="menu-comment">
GCL Specific
</pre></th></tr><tr><td align="left" valign="top">&bull; <a href="Bignums.html#Bignums">Bignums</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><th colspan="3" align="left" valign="top"><pre class="menu-comment">
C Interface
</pre></th></tr><tr><td align="left" valign="top">&bull; <a href="Available-Symbols.html#Available-Symbols">Available Symbols</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><th colspan="3" align="left" valign="top"><pre class="menu-comment">
System Definitions
</pre></th></tr><tr><td align="left" valign="top">&bull; <a href="Regular-Expressions.html#Regular-Expressions">Regular Expressions</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><th colspan="3" align="left" valign="top"><pre class="menu-comment">
Debugging
</pre></th></tr><tr><td align="left" valign="top">&bull; <a href="Source-Level-Debugging-in-Emacs.html#Source-Level-Debugging-in-Emacs">Source Level Debugging in Emacs</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Low-Level-Debug-Functions.html#Low-Level-Debug-Functions">Low Level Debug Functions</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><th colspan="3" align="left" valign="top"><pre class="menu-comment">
Miscellaneous
</pre></th></tr><tr><td align="left" valign="top">&bull; <a href="Environment.html#Environment">Environment</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Inititialization.html#Inititialization">Inititialization</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Low-Level-X-Interface.html#Low-Level-X-Interface">Low Level X Interface</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
<hr>
<div class="header">
<p>
Next: <a href="Numbers.html#Numbers" accesskey="n" rel="next">Numbers</a>, Previous: <a href="http://www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/dir/index.html" accesskey="p" rel="prev">(dir)</a>, Up: <a href="http://www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/dir/index.html" accesskey="u" rel="up">(dir)</a> &nbsp; [<a href="Function-and-Variable-Index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Function-and-Variable-Index.html#Function-and-Variable-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

160
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/Argument-Lists.html Normal file
View file

@ -0,0 +1,160 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL TK Manual: Argument Lists</title>
<meta name="description" content="GCL TK Manual: Argument Lists">
<meta name="keywords" content="GCL TK Manual: Argument Lists">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="wm.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="General.html#General" rel="up" title="General">
<link href="Lisp-Functions-Invoked-from-Graphics.html#Lisp-Functions-Invoked-from-Graphics" rel="next" title="Lisp Functions Invoked from Graphics">
<link href="Return-Values.html#Return-Values" rel="prev" title="Return Values">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Argument-Lists"></a>
<div class="header">
<p>
Next: <a href="Lisp-Functions-Invoked-from-Graphics.html#Lisp-Functions-Invoked-from-Graphics" accesskey="n" rel="next">Lisp Functions Invoked from Graphics</a>, Previous: <a href="Return-Values.html#Return-Values" accesskey="p" rel="prev">Return Values</a>, Up: <a href="General.html#General" accesskey="u" rel="up">General</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
<hr>
<a name="Argument-Lists-1"></a>
<h3 class="section">1.5 Argument Lists</h3>
<a name="Widget-Functions"></a>
<h4 class="subsection">1.5.1 Widget Functions</h4>
<p>The rule is that the first argument for a widget function is a keyword,
called the <i>option</i>. The pattern of the remaining arguments depends
completely
on the <i>option</i> argument. Thus
</p>
<div class="example">
<pre class="example">(.hello <i>option</i> ?arg1? ?arg2? ...)
</pre></div>
<p>One <i>option</i> which is permitted for every widget function is
<code>:configure</code>. The argument pattern following it is the same
keyword/value pair list which is used in widget creation. For a
<code>button</code> widget, the other valid options are <code>:deactivate</code>,
<code>:flash</code>, and <code>:invoke</code>. To find these, since
<code>.hello</code> was constructed with the <code>button</code> constructor, you
should see See <a href="button.html#button">button</a>.
The argument pattern for other options depends completely on the option
and the widget function.
For example if <code>.scrollbar</code> is a scroll bar window, then the option
<code>:set</code> must be followed by 4 numeric arguments, which indicate how
the scrollbar should be displayed, see See <a href="scrollbar.html#scrollbar">scrollbar</a>.
</p>
<div class="example">
<pre class="example">(.scrollbar :set a1 a2 a3 a4)
</pre></div>
<p>If on the other hand <code>.scale</code> is a scale (see <a href="scale.html#scale">scale</a>), then we have
</p>
<div class="example">
<pre class="example">(.scale :set a1 )
</pre></div>
<p>only one numeric argument should be supplied, in order to position the
scale.
</p>
<a name="Widget-Constructor-Argument-Lists"></a>
<h4 class="subsection">1.5.2 Widget Constructor Argument Lists</h4>
<p>These are
</p>
<div class="example">
<pre class="example">(widget-constructor <i>pathname</i> :keyword1 value1 :keyword2 value2 ...)
</pre></div>
<p>to create the widget whose name is <i>pathname</i>. The possible keywords
allowed are specified in the corresponding section of See <a href="Widgets.html#Widgets">Widgets</a>.
</p>
<a name="Concatenation-Using-_0060_003a_0027-in-Argument-List"></a>
<h4 class="subsection">1.5.3 Concatenation Using &lsquo;:&rsquo; in Argument List</h4>
<p>What has been said so far about arguments is not quite true. A
special string concatenation construction is allowed in argument lists
for widgets, widget constructors and control functions.
</p>
<p>First we introduce the function <code>tk-conc</code> which takes an arbitrary
number of arguments, which may be symbols, strings or numbers, and
concatenates these into a string. The print names of symbols are
converted to lower case, and package names are ignored.
</p>
<div class="example">
<pre class="example">(tk-conc &quot;a&quot; 1 :b 'cd &quot;e&quot;) ==&gt; &quot;a1bcde&quot;
</pre></div>
<p>One could use <code>tk-conc</code> to construct arguments for widget
functions. But even though <code>tk-conc</code> has been made quite
efficient, it still would involve the creation of a string. The
<code>:</code> construct avoids this. In a call to a widget function,
a widget constructor, or a control function you may remove the call to
<code>tk-conc</code> and place <code>:</code> in between each of its arguments.
Those functions are able to understand this and treat the extra
arguments as if they were glued together in one string, but without
the extra cost of actually forming that string.
</p>
<div class="example">
<pre class="example">(tk-conc a b c .. w) &lt;==&gt; a : b : c : ... w
(setq i 10)
(.hello :configure :text i : &quot; pies&quot;)
(.hello :configure :text (tk-conc i &quot; pies&quot;))
(.hello :configure :text (format nil &quot;~a pies&quot; i))
</pre></div>
<p>The last three examples would all result in the text string being
<code>&quot;10 pies&quot;</code>, but the first method is the most efficient.
That call will be made with no string or cons creation. The
<b>GC Monitor</b> example, is written in such a way that there is no
creation of <code>cons</code> or <code>string</code> types during normal operation.
This is particularly useful in that case, since one is trying to
monitor usage of conses by other programs, not its own usage.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Lisp-Functions-Invoked-from-Graphics.html#Lisp-Functions-Invoked-from-Graphics" accesskey="n" rel="next">Lisp Functions Invoked from Graphics</a>, Previous: <a href="Return-Values.html#Return-Values" accesskey="p" rel="prev">Return Values</a>, Up: <a href="General.html#General" accesskey="u" rel="up">General</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
</body>
</html>

163
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/Common-Features-of-Widgets.html Normal file
View file

@ -0,0 +1,163 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL TK Manual: Common Features of Widgets</title>
<meta name="description" content="GCL TK Manual: Common Features of Widgets">
<meta name="keywords" content="GCL TK Manual: Common Features of Widgets">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="wm.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="General.html#General" rel="up" title="General">
<link href="Return-Values.html#Return-Values" rel="next" title="Return Values">
<link href="Getting-Started.html#Getting-Started" rel="prev" title="Getting Started">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Common-Features-of-Widgets"></a>
<div class="header">
<p>
Next: <a href="Return-Values.html#Return-Values" accesskey="n" rel="next">Return Values</a>, Previous: <a href="Getting-Started.html#Getting-Started" accesskey="p" rel="prev">Getting Started</a>, Up: <a href="General.html#General" accesskey="u" rel="up">General</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
<hr>
<a name="Common-Features-of-Widgets-1"></a>
<h3 class="section">1.3 Common Features of Widgets</h3>
<p>A <i>widget</i> is a lisp symbol which has a function binding. The
first argument is always a keyword and is called the <i>option</i>.
The argument pattern for the remaining arguments depends on the
<i>option</i>. The most common <i>option</i> is <code>:configure</code> in
which case the remaining arguments are alternating keyword/value
pairs, with the same keywords being permitted as at the creation
of the widget.
</p>
<p>A <i>widget</i> is created by means of a <i>widget constructor</i>, of
which there are currently 15, each of them appearing as the title of a
section in <a href="Widgets.html#Widgets">Widgets</a>. They live in the <code>&quot;TK&quot;</code> package, and for
the moment we will assume we have switched to this package. Thus for
example <code>button</code> is such a widget constructor function. Of course
this is lisp, and you can make your own widget constructors, but when
you do so it is a good idea to follow the standard argument patterns
that are outlined in this section.
</p>
<div class="example">
<pre class="example">(button '.hello)
==&gt; .HELLO
</pre></div>
<p>creates a <i>widget</i> whose name is <code>.hello</code>. There is a parent child
hierarchy among widgets which is implicit in the name used for the
widget. This is much like the pathname structure on a Unix or Dos
file system, except that <code>'.'</code> is used as the separator rather
than a <code>/</code> or <code>\</code>. For this reason the widget instances
are sometimes referred to as <i>pathnames</i>. A child of the
parent widget <code>.hello</code> might be called <code>.hello.joe</code>, and
a child of this last might be <code>.hello.joe.bar</code>. The parent of
everyone is called <code>.</code> . Multiple top level windows are created
using the <code>toplevel</code> command (see <a href="toplevel.html#toplevel">toplevel</a>).
</p>
<p>The widget constructor functions take keyword and value pairs, which
allow you to specify attributes at the time of creation:
</p>
<div class="example">
<pre class="example">(button '.hello :text &quot;Hello World&quot; :width 20)
==&gt;.HELLO
</pre></div>
<p>indicating that we want the text in the button window to be
<code>Hello World</code> and the width of the window to be 20 characters
wide. Other types of windows allow specification in centimeters
<code>2c</code>, or in inches (<code>2i</code>) or in millimeters <code>2m</code>
or in pixels <code>2</code>. But text windows usually have their
dimensions specified as multiples of a character width and height.
This latter concept is called a grid.
</p>
<p>Once the window has been created, if you want to change the
text you do NOT do:
</p><div class="example">
<pre class="example">(button '.hello :text &quot;Bye World&quot; :width 20)
</pre></div>
<p>This would be in error, because the window .hello already exists.
You would either have to first call
</p>
<div class="example">
<pre class="example">(destroy '.hello)
</pre></div>
<p>But usually you just want to change an attribute. <code>.hello</code> is
actually a function, as we mentioned earlier, and it is this function
that you use:
</p>
<div class="example">
<pre class="example">(.hello :configure :text &quot;Bye World&quot;)
</pre></div>
<p>This would simply change the text, and not change where the window had
been placed on the screen (if it had), or how it had been packed
into the window hierarchy. Here the argument <code>:configure</code> is
called an <i>option</i>, and it specifies which types of keywords can
follow it. For example
</p>
<div class="example">
<pre class="example">(.hello :flash)
</pre></div>
<p>is also valid, but in this case the <code>:text</code> keyword is not permitted
after flash. If it were, then it would mean something else besides
what it means in the above. For example one might have defined
</p>
<div class="example">
<pre class="example">(.hello :flash :text &quot;PUSH ME&quot;)
</pre></div>
<p>so here the same keyword <code>:text</code> would mean something else, eg
to flash a subliminal message on the screen.
</p>
<p>We often refer to calls to the widget functions
as messages. One reason for this is that they actually turn into
messages to the graphics process <samp>gcltksrv</samp>. To actually see these
messages you can do
</p><div class="example">
<pre class="example">(debugging t).
</pre></div>
<hr>
<div class="header">
<p>
Next: <a href="Return-Values.html#Return-Values" accesskey="n" rel="next">Return Values</a>, Previous: <a href="Getting-Started.html#Getting-Started" accesskey="p" rel="prev">Getting Started</a>, Up: <a href="General.html#General" accesskey="u" rel="up">General</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
</body>
</html>

117
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/Control.html Normal file
View file

@ -0,0 +1,117 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL TK Manual: Control</title>
<meta name="description" content="GCL TK Manual: Control">
<meta name="keywords" content="GCL TK Manual: Control">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="wm.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="after.html#after" rel="next" title="after">
<link href="toplevel.html#toplevel" rel="prev" title="toplevel">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Control"></a>
<div class="header">
<p>
Previous: <a href="Widgets.html#Widgets" accesskey="p" rel="prev">Widgets</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
<hr>
<a name="Control-1"></a>
<h2 class="chapter">3 Control</h2>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="after.html#after" accesskey="1">after</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="bind.html#bind" accesskey="2">bind</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="destroy.html#destroy" accesskey="3">destroy</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="tk_002ddialog.html#tk_002ddialog" accesskey="4">tk-dialog</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="exit.html#exit" accesskey="5">exit</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="focus.html#focus" accesskey="6">focus</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="grab.html#grab" accesskey="7">grab</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="tk_002dlistbox_002dsingle_002dselect.html#tk_002dlistbox_002dsingle_002dselect" accesskey="8">tk-listbox-single-select</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="lower.html#lower" accesskey="9">lower</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="tk_002dmenu_002dbar.html#tk_002dmenu_002dbar">tk-menu-bar</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="option.html#option">option</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="options.html#options">options</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="pack_002dold.html#pack_002dold">pack-old</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="pack.html#pack">pack</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="place.html#place">place</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="raise.html#raise">raise</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="selection.html#selection">selection</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="send.html#send">send</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="tk.html#tk">tk</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="tkerror.html#tkerror">tkerror</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="tkvars.html#tkvars">tkvars</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="tkwait.html#tkwait">tkwait</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="update.html#update">update</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="winfo.html#winfo">winfo</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="wm.html#wm">wm</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

83
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/General.html Normal file
View file

@ -0,0 +1,83 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL TK Manual: General</title>
<meta name="description" content="GCL TK Manual: General">
<meta name="keywords" content="GCL TK Manual: General">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="wm.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="Introduction.html#Introduction" rel="next" title="Introduction">
<link href="index.html#Top" rel="prev" title="Top">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="General"></a>
<div class="header">
<p>
Next: <a href="Widgets.html#Widgets" accesskey="n" rel="next">Widgets</a>, Previous: <a href="index.html#Top" accesskey="p" rel="prev">Top</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
<hr>
<a name="General-1"></a>
<h2 class="chapter">1 General</h2>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Introduction.html#Introduction" accesskey="1">Introduction</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Getting-Started.html#Getting-Started" accesskey="2">Getting Started</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Common-Features-of-Widgets.html#Common-Features-of-Widgets" accesskey="3">Common Features of Widgets</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Return-Values.html#Return-Values" accesskey="4">Return Values</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Argument-Lists.html#Argument-Lists" accesskey="5">Argument Lists</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Lisp-Functions-Invoked-from-Graphics.html#Lisp-Functions-Invoked-from-Graphics" accesskey="6">Lisp Functions Invoked from Graphics</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Linked-Variables.html#Linked-Variables" accesskey="7">Linked Variables</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="tkconnect.html#tkconnect" accesskey="8">tkconnect</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

96
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/Getting-Started.html Normal file
View file

@ -0,0 +1,96 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL TK Manual: Getting Started</title>
<meta name="description" content="GCL TK Manual: Getting Started">
<meta name="keywords" content="GCL TK Manual: Getting Started">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="wm.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="General.html#General" rel="up" title="General">
<link href="Common-Features-of-Widgets.html#Common-Features-of-Widgets" rel="next" title="Common Features of Widgets">
<link href="Introduction.html#Introduction" rel="prev" title="Introduction">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Getting-Started"></a>
<div class="header">
<p>
Next: <a href="Common-Features-of-Widgets.html#Common-Features-of-Widgets" accesskey="n" rel="next">Common Features of Widgets</a>, Previous: <a href="Introduction.html#Introduction" accesskey="p" rel="prev">Introduction</a>, Up: <a href="General.html#General" accesskey="u" rel="up">General</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
<hr>
<a name="Getting-Started-1"></a>
<h3 class="section">1.2 Getting Started</h3>
<p>Once <b>GCL</b> has been properly installed you should be able to do the
following simple example:
</p>
<div class="example">
<pre class="example">(in-package &quot;TK&quot;)
(tkconnect)
(button '.hello :text &quot;Hello World&quot; :command '(print &quot;hi&quot;))
==&gt;.HELLO
(pack '.hello)
</pre></div>
<p>We first switched to the &quot;TK&quot; package, so that functions like button
and pack would be found.
After doing the tkconnect, a window should appear on your screen, see See <a href="tkconnect.html#tkconnect">tkconnect</a>.
The invocation of the function <code>button</code> creates a new function
called <code>.hello</code> which is a <i>widget function</i>. It is then
made visible in the window by using the <code>pack</code> function.
</p>
<p>You may now click on the little window, and you should see the command
executed in your lisp. Thus &quot;hi&quot; should be printed in the lisp
window. This will happen whether or not you have a job running in
the lisp, that is lisp will be interrupted and your command will run,
and then return the control to your program.
</p>
<p>The function <code>button</code> is called a widget constructor, and the
function <code>.hello</code> is called a widget. If you have managed to
accomplish the above, then <b>GCL</b> is probably installed correctly, and you
can graduate to the next section! If you dont like reading but prefer
to look at demos and code, then you should look in the demos directory,
where you will find a number of examples. A monitor for the garbage
collector (mkgcmonitor), a demonstration of canvas widgets (mkitems),
a sample listbox with scrolling (mklistbox).
</p>
</body>
</html>

91
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/Introduction.html Normal file
View file

@ -0,0 +1,91 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL TK Manual: Introduction</title>
<meta name="description" content="GCL TK Manual: Introduction">
<meta name="keywords" content="GCL TK Manual: Introduction">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="wm.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="General.html#General" rel="up" title="General">
<link href="Getting-Started.html#Getting-Started" rel="next" title="Getting Started">
<link href="General.html#General" rel="prev" title="General">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Introduction"></a>
<div class="header">
<p>
Next: <a href="Getting-Started.html#Getting-Started" accesskey="n" rel="next">Getting Started</a>, Previous: <a href="General.html#General" accesskey="p" rel="prev">General</a>, Up: <a href="General.html#General" accesskey="u" rel="up">General</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
<hr>
<a name="Introduction-1"></a>
<h3 class="section">1.1 Introduction</h3>
<p><b>GCL-TK</b> is a windowing interface for <b>GNU Common Lisp</b>. It provides the
functionality of the <b>TK</b> widget set, which in turn implements a widget
set which has the look and feel of <b>Motif</b>.
</p>
<p>The interface allows the user to draw graphics, get input from menus,
make regions mouse sensitive, and bind lisp commands to regions. It
communicates over a socket with a <samp>gcltksrv</samp> process, which speaks to the
display via the <b>TK</b> library. The displaying process may run on
a machine which is closer to the display, and so involves less
communication. It also may remain active even though the lisp is
involved in a separate user computation. The display server can, however,
interrupt the lisp at will, to inquire about variables and run
commands.
</p>
<p>The user may also interface with existing <code>TCL/TK</code> programs,
binding some buttons, or tracking some objects.
</p>
<p>The size of the program is moderate. In its current form it adds only
about 45K bytes to the lisp image, and the <samp>gcltksrv</samp> program uses shared
libraries, and is on the order of 150Kbytes on a sparc.
</p>
<p>This chapter describes some of the common features of the command
structure of widgets, and of control functions. The actual functions
for construction of windows
are discussed in <a href="Widgets.html#Widgets">Widgets</a>, and more general functions
for making them appear, lowering them, querying about them in <a href="Control.html#Control">Control</a>.
</p>
</body>
</html>

161
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/Linked-Variables.html Normal file
View file

@ -0,0 +1,161 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL TK Manual: Linked Variables</title>
<meta name="description" content="GCL TK Manual: Linked Variables">
<meta name="keywords" content="GCL TK Manual: Linked Variables">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="wm.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="General.html#General" rel="up" title="General">
<link href="tkconnect.html#tkconnect" rel="next" title="tkconnect">
<link href="Lisp-Functions-Invoked-from-Graphics.html#Lisp-Functions-Invoked-from-Graphics" rel="prev" title="Lisp Functions Invoked from Graphics">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Linked-Variables"></a>
<div class="header">
<p>
Next: <a href="tkconnect.html#tkconnect" accesskey="n" rel="next">tkconnect</a>, Previous: <a href="Lisp-Functions-Invoked-from-Graphics.html#Lisp-Functions-Invoked-from-Graphics" accesskey="p" rel="prev">Lisp Functions Invoked from Graphics</a>, Up: <a href="General.html#General" accesskey="u" rel="up">General</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
<hr>
<a name="Linked-Variables-1"></a>
<h3 class="section">1.7 Linked Variables</h3>
<p>It is possible to link lisp variables to <b>TK</b> variables. In general
when the <b>TK</b> variable is changed, by for instance clicking on a
radiobutton, the linked lisp variable will be changed. Conversely
changing the lisp variable will be noticed by the <b>TK</b> graphics side, if
one does the assignment in lisp using <code>setk</code> instead of
<code>setq</code>.
</p>
<div class="example">
<pre class="example">(button '.hello :textvariable '*message* :text &quot;hi there&quot;)
(pack '.hello)
</pre></div>
<p>This causes linking of the global variable <code>*message*</code> in lisp
to a corresponding variable in <b>TK</b>. Moreover the message that is in
the button <code>.hello</code> will be whatever the value of this global
variable is (so long as the <b>TK</b> side is notified of the change!).
</p>
<p>Thus if one does
</p>
<div class="example">
<pre class="example">(setk *message* &quot;good bye&quot;)
</pre></div>
<p>then the button will change to have <i>good bye</i> as its text.
The lisp macro <code>setk</code> expands into
</p>
<div class="example">
<pre class="example">(prog1 (setf *message* &quot;good bye&quot;) (notice-text-variables))
</pre></div>
<p>which does the assignment, and then goes thru the linked variables
checking for those that have changed, and updating the <b>TK</b> side should
there be any. Thus if you have a more complex program which might
have done the assignment of your global variable, you may include
the call to <code>notice-text-variables</code> at the end, to assure that
the graphics side knows about the changes.
</p>
<p>A variable which is linked using the keyword <code>:textvariable</code> is
always a variable containing a string.
</p>
<p>However it is possible to have other types of variables.
</p>
<div class="example">
<pre class="example">(checkbutton '.checkbutton1 :text &quot;A button&quot; :variable '(boolean *joe*))
(checkbutton '.checkbutton2 :text &quot;A button&quot; :variable '*joe*)
(checkbutton '.checkbutton3 :text &quot;Debugging&quot; :variable '(t *debug*)
:onvalue 100 :offvalue -1)
</pre></div>
<p>The first two examples are the same in that the default variable type
for a checkbutton is <code>boolean</code>. Notice that the specification of a
variable type is by <code>(<i>type</i> variable)</code>. The types which are
permissible are those which have coercion-fucntions, See <a href="Return-Values.html#Return-Values">Return Values</a>. In the first example a variable <code>*joe*</code> will be linked, and
its default initial value will be set to nil, since the default initial
state of the check button is off, and the default off value is nil.
Actually on the <b>TK</b> side, the corresponding boolean values are <code>&quot;1&quot;</code>
and <code>&quot;0&quot;</code>, but the <code>boolean</code> type makes these become <code>t</code>
and <code>nil</code>.
</p>
<p>In the third example the variable *debug* may have any lisp value (here
<i>type</i> is <code>t</code>). The initial value will be made to be <code>-1</code>,
since the checkbutton is off. Clicking on <code>.checkbutton3</code> will
result in the value of <code>*debug*</code> being changed to 100, and the light
in the button will be toggled to on, See <a href="checkbutton.html#checkbutton">checkbutton</a>. You may
set the variable to be another value besides 100.
</p>
<p>You may also call
</p>
<div class="example">
<pre class="example">(link-text-variable '*joe* 'boolean)
</pre></div>
<p>to cause the linking of a variable named *joe*. This is done
automatically
whenever the variable is specified after one of the keys
</p>
<div class="example">
<pre class="example">:variable :textvariable.
</pre></div>
<p>Just as one must be cautious about using global variables in lisp, one
must be cautious in making such linked variables. In particular note
that the <b>TK</b> side, uses variables for various purposes. If you make a
checkbutton with pathname <code>.a.b.c</code> then unless you specify a
<code>:variable</code> option, the variable <code>c</code> will become associated to
the <b>TK</b> value of the checkbutton. We do NOT link this variable by
default, feeling that one might inadvertently alter global variables,
and that they would not typically use the lisp convention of being of
the form <code>*c*</code>. You must specify the <code>:variable</code> option, or
call <code>link-variable</code>.
</p>
<hr>
<div class="header">
<p>
Next: <a href="tkconnect.html#tkconnect" accesskey="n" rel="next">tkconnect</a>, Previous: <a href="Lisp-Functions-Invoked-from-Graphics.html#Lisp-Functions-Invoked-from-Graphics" accesskey="p" rel="prev">Lisp Functions Invoked from Graphics</a>, Up: <a href="General.html#General" accesskey="u" rel="up">General</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
</body>
</html>

212
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/Lisp-Functions-Invoked-from-Graphics.html Normal file
View file

@ -0,0 +1,212 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL TK Manual: Lisp Functions Invoked from Graphics</title>
<meta name="description" content="GCL TK Manual: Lisp Functions Invoked from Graphics">
<meta name="keywords" content="GCL TK Manual: Lisp Functions Invoked from Graphics">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="wm.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="General.html#General" rel="up" title="General">
<link href="Linked-Variables.html#Linked-Variables" rel="next" title="Linked Variables">
<link href="Argument-Lists.html#Argument-Lists" rel="prev" title="Argument Lists">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Lisp-Functions-Invoked-from-Graphics"></a>
<div class="header">
<p>
Next: <a href="Linked-Variables.html#Linked-Variables" accesskey="n" rel="next">Linked Variables</a>, Previous: <a href="Argument-Lists.html#Argument-Lists" accesskey="p" rel="prev">Argument Lists</a>, Up: <a href="General.html#General" accesskey="u" rel="up">General</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
<hr>
<a name="Lisp-Functions-Invoked-from-Graphics-1"></a>
<h3 class="section">1.6 Lisp Functions Invoked from Graphics</h3>
<p>It is possible to make certain areas of a window mouse sensitive,
or to run commands on reception of certain events such as keystrokes,
while the focus is in a certain window. This is done by having
a lisp function invoked or some lisp form evaluated. We shall
refer to such a lisp function or form as a <em>command</em>.
</p>
<p>For example
</p>
<div class="example">
<pre class="example">(button '.button :text &quot;Hello&quot; :command '(print &quot;hi&quot;))
(button '.jim :text &quot;Call Jim&quot; :command 'call-jim)
</pre></div>
<p>In the first case when the window <code>.button</code> is clicked on, the
word &quot;hi&quot; will be printed in the lisp to standard output. In the
second case <code>call-jim</code> will be funcalled with no arguments.
</p>
<p>A command must be one of the following three types. What happens
depends on which type it is:
</p>
<dl compact="compact">
<dt>&lsquo;<samp>function</samp>&rsquo;</dt>
<dd><p>If the value satisfies <code>functionp</code> then it will be called with
a number of arguments which is dependent on the way it was bound,
to graphics.
</p></dd>
<dt>&lsquo;<samp>string</samp>&rsquo;</dt>
<dd><p>If the command is a string, then it is passed directly to <b>TCL/TK</b>
for evaluation on that side. Lisp will not be required for the
evaluation when the command is invoked.
</p></dd>
<dt>&lsquo;<samp>lisp form</samp>&rsquo;</dt>
<dd><p>Any other lisp object is regarded as a lisp form to be eval&rsquo;d, and
this will be done when the command is invoked.
</p></dd>
</dl>
<p>The following keywords accept as their value a command:
</p>
<div class="example">
<pre class="example"> :command
:yscroll :yscrollcommand
:xscroll :xscrollcommand
:scrollcommand
:bind
</pre></div>
<p>and in addition <code>bind</code> takes a command as its third argument,
see See <a href="bind.html#bind">bind</a>.
</p>
<p>Below we give three different examples using the 3 possibilities for
a command: functionp, string, and lisp form. They all accomplish
exactly the same thing.
For given a frame <code>.frame</code> we could construct a listbox
in it as:
</p>
<div class="example">
<pre class="example">(listbox '.frame.listbox :yscroll 'joe)
</pre></div>
<p>Then whenever the listbox view position changes, or text is inserted,
so that something changes, the function <code>joe</code> will be invoked with 4
arguments giving the totalsize of the text, maximum number of units
the window can display, the index of the top unit, and finally the
index of the bottom unit. What these arguments are is specific
to the widget <code>listbox</code> and is documented See <a href="listbox.html#listbox">listbox</a>.
</p>
<p><code>joe</code> might be used to do anything, but a common usage is to have
<code>joe</code> alter the position of some other window, such as a scroll
bar window. Indeed if <code>.scrollbar</code> is a scrollbar then
the function
</p>
<div class="example">
<pre class="example">(defun joe (a b c d)
(.scrollbar :set a b c d))
</pre></div>
<p>would look after sizing the scrollbar appropriately for the percentage
of the window visible, and positioning it.
</p>
<p>A second method of accomplishing this identical, using a string (the
second type of command),
</p>
<div class="example">
<pre class="example">(listbox '.frame.listbox :yscroll &quot;.scrollbar set&quot;)
</pre></div>
<p>and this will not involve a call back to lisp. It uses the fact that
the <b>TK</b> graphics side understands the window name <code>.scrollbar</code> and
that it takes the <i>option</i> <code>set</code>. Note that it does not get
the <code>:</code> before the keyword in this case.
</p>
<p>In the case of a command which is a <i>lisp form</i> but is not installed
via <code>bind</code> or <code>:bind</code>, then the form will be installed as
</p>
<div class="example">
<pre class="example">#'(lambda (&amp;rest *arglist*) <i>lisp-form</i>)
</pre></div>
<p>where the <i>lisp-form</i> might wish to access the elements of the special
variable <code>*arglist*</code>. Most often this list will be empty, but for
example if the command was setup for <code>.scale</code> which is a <i>scale</i>,
then the command will be supplied one argument which is the new numeric
value which is the scale position. A third way of accomplishing the
scrollbar setting using a lisp form is:
</p>
<div class="example">
<pre class="example">(listbox '.frame.listbox :yscroll '(apply '.scrollbar :set *arglist*))
</pre></div>
<p>The <code>bind</code> command and <code>:bind</code> keyword, have an additional
wrinkle, see See <a href="bind.html#bind">bind</a>. These are associated to an event in a
particular window, and the lisp function or form to be evaled must have
access to that information. For example the x y position, the window
name, the key pressed, etc. This is done via <i>percent symbols</i> which
are specified, see See <a href="bind.html#bind">bind</a>.
</p>
<div class="example">
<pre class="example">(bind &quot;Entry&quot; &quot;&lt;Control-KeyPress&gt;&quot; '(emacs-move %W %A ))
</pre></div>
<p>will cause the function emacs-move to be be invoked whenever a control
key is pressed (unless there are more key specific or window specific
bindings of said key). It will be invoked with two arguments, the
first %W indicating the window in which it was invoked, and the second
being a string which is the ascii keysym which was pressed at the same
time as the control key.
</p>
<p>These <i>percent constructs</i> are only permitted in commands which are
invoked via <code>bind</code> or <code>:bind</code>. The lisp form which is passed
as the command, is searched for the percent constructs, and then a
function
</p>
<div class="example">
<pre class="example">#'(lambda (%W %A) (emacs-move %W %A))
</pre></div>
<p>will be invoked with two arguments, which will be supplied by the
<b>TK</b> graphics server, at the time the command is invoked. The
<code>*arglist*</code> construct is not available for these commands.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Linked-Variables.html#Linked-Variables" accesskey="n" rel="next">Linked Variables</a>, Previous: <a href="Argument-Lists.html#Argument-Lists" accesskey="p" rel="prev">Argument Lists</a>, Up: <a href="General.html#General" accesskey="u" rel="up">General</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
</body>
</html>

181
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/Return-Values.html Normal file
View file

@ -0,0 +1,181 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL TK Manual: Return Values</title>
<meta name="description" content="GCL TK Manual: Return Values">
<meta name="keywords" content="GCL TK Manual: Return Values">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="wm.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="General.html#General" rel="up" title="General">
<link href="Argument-Lists.html#Argument-Lists" rel="next" title="Argument Lists">
<link href="Common-Features-of-Widgets.html#Common-Features-of-Widgets" rel="prev" title="Common Features of Widgets">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Return-Values"></a>
<div class="header">
<p>
Next: <a href="Argument-Lists.html#Argument-Lists" accesskey="n" rel="next">Argument Lists</a>, Previous: <a href="Common-Features-of-Widgets.html#Common-Features-of-Widgets" accesskey="p" rel="prev">Common Features of Widgets</a>, Up: <a href="General.html#General" accesskey="u" rel="up">General</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
<hr>
<a name="Return-Values-1"></a>
<h3 class="section">1.4 Return Values</h3>
<a name="Widget-Constructor-Return-Values"></a>
<h4 class="subsection">1.4.1 Widget Constructor Return Values</h4>
<p>On successful completion, the widget constructor functions return the
symbol passed in as the first argument. It will now have a functional
binding. It is an error to pass in a symbol which already corresponds
to a widget, without first calling the <code>destroy</code> command. On failure,
an error is signalled.
</p>
<a name="Widget-Return-Values"></a>
<h4 class="subsection">1.4.2 Widget Return Values</h4>
<p>The <i>widget</i> functions themselves, do not normally return any value.
Indeed the lisp process does not wait for them to return, but merely
dispatches the commands, such as to change the text in themselves.
Sometimes however you either wish to wait, in order to synchronize, or
you wish to see if your command fails or succeeds. You request values
by passing the keyword :return and a value indicating the type.
</p>
<div class="example">
<pre class="example">(.hello :configure :text &quot;Bye World&quot; :return 'string)
==&gt; &quot;&quot;
==&gt; T
</pre></div>
<p>the empty string is returned as first value, and the second value
<code>T</code> indicates that the new text value was successfully set. LISP
will not continue until the tkclsrv process indicates back that the
function call has succeeded. While waiting of course LISP will continue
to process other graphics events which arrive, since otherwise a
deadlock would arise: the user for instance might click on a mouse, just after
we had decided to wait for a return value from the <code>.hello</code> function.
More generally a user program may be running in <b>GCL</b> and be interrupted
to receive and act on communications from the <samp>gcltksrv</samp>
process. If an error occurred then the second return value of the
lisp function will be NIL. In this case the first value, the string
is usually an informative message about the type of error.
</p>
<p>A special variable <code>tk::*break-on-errors*</code> which if not
<code>nil</code>, requests that that <b>LISP</b> signal an error when a message
is received indicating a function failed. Whenever a command fails,
whether a return value was requested or not, <samp>gcltksrv</samp> returns a
message indicating failure. The default is to not go into the
debugger. When debugging your windows it may be convenient however to
set this variable to <code>T</code> to track down incorrect messages.
</p>
<p>The <samp>gcltksrv</samp> process always returns strings as values.
If <code>:return</code> <i>type</i> is specified, then conversion to <i>type</i>
is accomplished by calling
</p>
<div class="example">
<pre class="example">(coerce-result <i>return-string</i> <i>type</i>)
</pre></div>
<p>Here <i>type</i> must be a symbol with a <code>coercion-functions</code>
property.
The builtin return types which may be requested are:
</p>
<dl compact="compact">
<dt><code>T</code></dt>
<dd><p>in which case
the string passed back from the <samp>gcltksrv</samp> process, will be read by the
lisp reader.
</p></dd>
<dt><code>number</code></dt>
<dd><p>the string is converted to a number using the current *read-base*
</p></dd>
<dt><code>list-strings</code></dt>
<dd>
<div class="example">
<pre class="example">(coerce-result &quot;a b {c d} e&quot; 'list-strings)
==&gt; (&quot;a&quot; &quot;b&quot; &quot;c d&quot; &quot;e&quot;)
</pre></div>
</dd>
<dt><code>boolean</code></dt>
<dd><p>(coerce-result &quot;1&quot; &rsquo;boolean)
==&gt; T
(coerce-result &quot;0&quot; &rsquo;boolean)
==&gt; NIL
</p></dd>
</dl>
<p>The above symbols are in the <code>TK</code> or <code>LISP</code> package.
It would be possible to add new types just as the <code>:return t</code>
is done:
</p>
<div class="example">
<pre class="example">(setf (get 't 'coercion-functions)
(cons #'(lambda (x) (our-read-from-string x 0))
#'(lambda (x) (format nil &quot;~s&quot; x))))
</pre></div>
<p>The <code>coercion-functions</code> property of a symbol, is a cons whose
<code>car</code> is the coercion form from a string to some possibly different
lisp object, and whose <code>cdr</code> is a function which builds a string
to send to the graphics server. Often the two functions are inverse
functions one of the other up to equal.
</p>
<a name="Control-Function-Return-Values"></a>
<h4 class="subsection">1.4.3 Control Function Return Values</h4>
<p>The <i>control</i> funcions (see <a href="Control.html#Control">Control</a>) do not return a value
or wait unless requested to do so, using the <code>:return</code> keyword.
The types and method of specification are the same as for the
Widget Functions in the previous section.
</p>
<div class="example">
<pre class="example">(winfo :width '.hello :return 'number)
==&gt; 120
</pre></div>
<p>indicates that the <code>.hello</code> button is actually 120 pixels
wide.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Argument-Lists.html#Argument-Lists" accesskey="n" rel="next">Argument Lists</a>, Previous: <a href="Common-Features-of-Widgets.html#Common-Features-of-Widgets" accesskey="p" rel="prev">Common Features of Widgets</a>, Up: <a href="General.html#General" accesskey="u" rel="up">General</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
</body>
</html>

97
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/Widgets.html Normal file
View file

@ -0,0 +1,97 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL TK Manual: Widgets</title>
<meta name="description" content="GCL TK Manual: Widgets">
<meta name="keywords" content="GCL TK Manual: Widgets">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="wm.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html#Top" rel="up" title="Top">
<link href="button.html#button" rel="next" title="button">
<link href="tkconnect.html#tkconnect" rel="prev" title="tkconnect">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Widgets"></a>
<div class="header">
<p>
Next: <a href="Control.html#Control" accesskey="n" rel="next">Control</a>, Previous: <a href="General.html#General" accesskey="p" rel="prev">General</a>, Up: <a href="index.html#Top" accesskey="u" rel="up">Top</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
<hr>
<a name="Widgets-1"></a>
<h2 class="chapter">2 Widgets</h2>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="button.html#button" accesskey="1">button</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="listbox.html#listbox" accesskey="2">listbox</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="scale.html#scale" accesskey="3">scale</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="canvas.html#canvas" accesskey="4">canvas</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="menu.html#menu" accesskey="5">menu</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="scrollbar.html#scrollbar" accesskey="6">scrollbar</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="checkbutton.html#checkbutton" accesskey="7">checkbutton</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="menubutton.html#menubutton" accesskey="8">menubutton</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="text.html#text" accesskey="9">text</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="entry.html#entry">entry</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="message.html#message">message</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="frame.html#frame">frame</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="label.html#label">label</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="radiobutton.html#radiobutton">radiobutton</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="toplevel.html#toplevel">toplevel</a>:</td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

97
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/after.html Normal file
View file

@ -0,0 +1,97 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL TK Manual: after</title>
<meta name="description" content="GCL TK Manual: after">
<meta name="keywords" content="GCL TK Manual: after">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="wm.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Control.html#Control" rel="up" title="Control">
<link href="bind.html#bind" rel="next" title="bind">
<link href="Control.html#Control" rel="prev" title="Control">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="after"></a>
<div class="header">
<p>
Next: <a href="bind.html#bind" accesskey="n" rel="next">bind</a>, Previous: <a href="Control.html#Control" accesskey="p" rel="prev">Control</a>, Up: <a href="Control.html#Control" accesskey="u" rel="up">Control</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
<hr>
<a name="after-1"></a>
<h3 class="section">3.1 after</h3>
<p>after - Execute a command after a time delay
</p><a name="Synopsis-15"></a>
<h4 class="unnumberedsubsec">Synopsis</h4>
<p><b>after </b><i>ms </i><span class="roman">?</span><i>arg1 arg2 arg3 ...</i>?
</p>
<a name="Description-12"></a>
<h4 class="unnumberedsubsec">Description</h4>
<p>This command is used to delay execution of the program or to execute
a command in background after a delay. The <i>ms</i> argument gives
a time in milliseconds.
If <i>ms</i><span class="roman"> is the only argument to </span><b>after</b>
then the command sleeps for <i>ms</i> milliseconds and returns.
While the command is sleeping the application does not respond to
X events and other events.
</p>
<p>If additional arguments are
present after <i>ms</i>, then a Tcl command is formed by concatenating
all the additional arguments in the same fashion as the <b>concat</b>
command. <b>After</b> returns immediately but arranges for the command
to be executed <i>ms</i> milliseconds later in background.
The command will be executed at global level (outside the context
of any Tcl procedure).
If an error occurs while executing the delayed command then the
<b>tkerror</b> mechanism is used to report the error.
</p>
<p>The <b>after</b> command always returns an empty string.
</p>
<p>See <a href="tkerror.html#tkerror">tkerror</a>.
</p>
<a name="Keywords-15"></a>
<h4 class="unnumberedsubsec">Keywords</h4>
<p>delay, sleep, time
</p>
</body>
</html>

490
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/bind.html Normal file
View file

@ -0,0 +1,490 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL TK Manual: bind</title>
<meta name="description" content="GCL TK Manual: bind">
<meta name="keywords" content="GCL TK Manual: bind">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="wm.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Control.html#Control" rel="up" title="Control">
<link href="destroy.html#destroy" rel="next" title="destroy">
<link href="after.html#after" rel="prev" title="after">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="bind"></a>
<div class="header">
<p>
Next: <a href="destroy.html#destroy" accesskey="n" rel="next">destroy</a>, Previous: <a href="after.html#after" accesskey="p" rel="prev">after</a>, Up: <a href="Control.html#Control" accesskey="u" rel="up">Control</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
<hr>
<a name="bind-1"></a>
<h3 class="section">3.2 bind</h3>
<p>bind \- Arrange for X events to invoke Tcl commands
</p><a name="Synopsis-16"></a>
<h4 class="unnumberedsubsec">Synopsis</h4>
<br><p><b>bind</b><i>&nbsp;windowSpec</i><!-- /@w --><br>
<br><b>bind</b><i>&nbsp;windowSpec&nbsp;sequence</i><!-- /@w --><br>
<br><b>bind</b><i>&nbsp;windowSpec&nbsp;sequence&nbsp;command</i><!-- /@w --><br>
<b>bind</b><i> windowSpec sequence </i><b>+</b><i>command</i>
</p>
<a name="Description-13"></a>
<h4 class="unnumberedsubsec">Description</h4>
<p>If all three arguments are specified, <b>bind</b> will
arrange for <i>command</i> (a Tcl
command) to be executed whenever the sequence of events given
by <i>sequence</i><span class="roman"> occurs in the window(s) identified by </span><i>windowSpec</i>.
If <i>command</i> is prefixed with a &ldquo;+&rdquo;, then it is appended to
any existing binding for <i>sequence</i><span class="roman">; otherwise </span><i>command</i> replaces
the existing binding, if any. If <i>command</i>
is an empty string then the current binding for <i>sequence</i>
is destroyed, leaving <i>sequence</i> unbound. In all of the cases
where a <i>command</i><span class="roman"> argument is provided, </span><b>bind</b> returns
an empty string.
</p>
<p>If <i>sequence</i><span class="roman"> is specified without a </span><i>command</i>, then the
command currently bound to <i>sequence</i> is returned, or
an empty string if there is no binding for <i>sequence</i>. If
neither <i>sequence</i><span class="roman"> nor </span><i>command</i> is specified, then the
return value is a list whose elements are all the sequences
for which there exist bindings for <i>windowSpec</i>.
</p>
<p>The <i>windowSpec</i> argument selects which window(s) the binding
applies to.
It may have one of three forms.
If <i>windowSpec</i> is the path name for a window, then the binding
applies to that particular window.
If <i>windowSpec</i> is the name of a class of widgets, then the
binding applies to all widgets in that class.
Lastly, <i>windowSpec</i><span class="roman"> may have the value </span><b>all</b>, in which case
the binding applies to all windows in the application.
</p>
<p>The <i>sequence</i> argument specifies a sequence of one or more
event patterns, with optional white space between the patterns. Each
event pattern may
take either of two forms. In the simplest case it is a single
printing ASCII character, such as <b>a</b><span class="roman"> or </span><b>[</b>. The character
may not be a space character or the character <b>&lt;</b>. This form of
pattern matches a <b>KeyPress</b> event for the particular
character. The second form of pattern is longer but more general.
It has the following syntax:
</p>
<div class="example">
<pre class="example"><b>&lt;</b><i>modifier-modifier-type-detail</i><b>&gt;</b>
</pre></div>
<p>The entire event pattern is surrounded by angle brackets.
Inside the angle brackets are zero or more modifiers, an event
type, and an extra piece of information (<i>detail</i>) identifying
a particular button or keysym. Any of the fields may be omitted,
as long as at least one of <i>type</i><span class="roman"> and </span><i>detail</i> is present.
The fields must be separated by white space or dashes.
</p>
<p>Modifiers may consist of any of the values in the following list:
</p>
<div class="example">
<pre class="example">Control Any
Shift Double
Lock Triple
Button1, B1 Mod1, M1, Meta, M
Button2, B2 Mod2, M2, Alt
Button3, B3 Mod3, M3
Button4, B4 Mod4, M4
Button5, B5 Mod5, M5
</pre></div>
<p>Where more than one value is listed, separated by commas, the values
are equivalent. All of the modifiers except <b>Any</b>,
<b>Double</b><span class="roman">, and </span><b>Triple</b> have
the obvious X meanings. For example, <b>Button1</b> requires that
button 1 be depressed when the event occurs. Under normal conditions
the button and modifier state at the time of the event must
match exactly those specified in the <b>bind</b> command. If
no modifiers are specified, then events will match only if no modifiers
are present. If the <b>Any</b> modifier is specified, then additional
modifiers may be present besides those specified explicitly. For
example, if button 1 is pressed while the shift and control keys
are down, the specifier <b>&lt;Any-Control-Button-1&gt;</b> will match
the event, but the specifier <b>&lt;Control-Button-1&gt;</b> will not.
</p>
<p>The <b>Double</b><span class="roman"> and </span><b>Triple</b> modifiers are a convenience
for specifying double mouse clicks and other repeated
events. They cause a particular event pattern to be
repeated 2 or 3 times, and also place a time and space requirement
on the sequence: for a sequence of events to match a <b>Double</b>
or <b>Triple</b> pattern, all of the events must occur close together
in time and without substantial mouse motion in between.
For example, <b>&lt;Double-Button-1&gt;</b>
is equivalent to <b>&lt;Button-1&gt;&lt;Button-1&gt;</b> with the extra
time and space requirement.
</p>
<p>The <i>type</i> field may be any of the standard X event types, with a
few extra abbreviations. Below is a list of all the valid types;
where two name appear together, they are synonyms.
</p>
<div class="example">
<pre class="example">ButtonPress, Button Expose Leave
ButtonRelease FocusIn Map
Circulate FocusOut Property
CirculateRequest Gravity Reparent
Colormap Keymap ResizeRequest
Configure KeyPress, Key Unmap
ConfigureRequest KeyRelease Visibility
Destroy MapRequest
Enter Motion
</pre></div>
<p>The last part of a long event specification is <i>detail</i>. In the
case of a <b>ButtonPress</b><span class="roman"> or </span><b>ButtonRelease</b> event, it is the
number of a button (1-5). If a button number is given, then only an
event on that particular button will match; if no button number is
given, then an event on any button will match. Note: giving a
specific button number is different than specifying a button modifier;
in the first case, it refers to a button being pressed or released,
while in the second it refers to some other button that is already
depressed when the matching event occurs. If a button
number is given then <i>type</i> may be omitted: if will default
to <b>ButtonPress</b><span class="roman">. For example, the specifier </span><b>&lt;1&gt;</b>
is equivalent to <b>&lt;ButtonPress-1&gt;</b>.
</p>
<p>If the event type is <b>KeyPress</b><span class="roman"> or </span><b>KeyRelease</b>, then
<i>detail</i> may be specified in the form of an X keysym. Keysyms
are textual specifications for particular keys on the keyboard;
they include all the alphanumeric ASCII characters (e.g. &ldquo;a&rdquo; is
the keysym for the ASCII character &ldquo;a&rdquo;), plus descriptions for
non-alphanumeric characters (&ldquo;comma&rdquo; is the keysym for the comma
character), plus descriptions for all the non-ASCII keys on the
keyboard (&ldquo;Shift_L&rdquo; is the keysm for the left shift key, and
&ldquo;F1&rdquo; is the keysym for the F1 function key, if it exists). The
complete list of keysyms is not presented here; it should be
available in other X documentation. If necessary, you can use the
<b>%K</b> notation described below to print out the keysym name for
an arbitrary key. If a keysym <i>detail</i> is given, then the
<i>type</i><span class="roman"> field may be omitted; it will default to </span><b>KeyPress</b>.
For example, <b>&lt;Control-comma&gt;</b> is equivalent to
<b>&lt;Control-KeyPress-comma&gt;</b><span class="roman">. If a keysym </span><i>detail</i> is specified
then the <b>Shift</b> modifier need not be specified and will be
ignored if specified: each keysym already implies a particular
state for the shift key.
</p>
<p>The <i>command</i><span class="roman"> argument to </span><b>bind</b> is a Tcl command string,
which will be executed whenever the given event sequence occurs.
<i>Command</i> will be executed in the same interpreter that the
<b>bind</b><span class="roman"> command was executed in. If </span><i>command</i> contains
any <b>%</b> characters, then the command string will not be
executed directly. Instead, a new command string will be
generated by replacing each <b>%</b>, and the character following
it, with information from the current event. The replacement
depends on the character following the <b>%</b>, as defined in the
list below. Unless otherwise indicated, the
replacement string is the decimal value of the given field from
the current event.
Some of the substitutions are only valid for
certain types of events; if they are used for other types of events
the value substituted is undefined.
</p>
<dl compact="compact">
<dt><b>%%</b></dt>
<dd><p>Replaced with a single percent.
</p></dd>
<dt><b>|%#|</b></dt>
<dd><p>The number of the last client request processed by the server
(the <i>serial</i> field from the event). Valid for all event
types.
</p></dd>
<dt><b>|%a|</b></dt>
<dd><p>The <i>above</i> field from the event.
Valid only for <b>ConfigureNotify</b> events.
</p></dd>
<dt><b>|%b|</b></dt>
<dd><p>The number of the button that was pressed or released. Valid only
for <b>ButtonPress</b><span class="roman"> and </span><b>ButtonRelease</b> events.
</p></dd>
<dt><b>|%c|</b></dt>
<dd><p>The <i>count</i><span class="roman"> field from the event. Valid only for </span><b>Expose</b>,
<b>GraphicsExpose</b><span class="roman">, and </span><b>MappingNotify</b> events.
</p></dd>
<dt><b>|%d|</b></dt>
<dd><p>The <i>detail</i><span class="roman"> field from the event. The </span><b>|%d|</b> is replaced by
a string identifying the detail. For <b>EnterNotify</b>,
<b>LeaveNotify</b><span class="roman">, </span><b>FocusIn</b><span class="roman">, and </span><b>FocusOut</b> events,
the string will be one of the following:
</p>
<div class="example">
<pre class="example">NotifyAncestor NotifyNonlinearVirtual
NotifyDetailNone NotifyPointer
NotifyInferior NotifyPointerRoot
NotifyNonlinear NotifyVirtual
</pre></div>
<p>For <b>ConfigureRequest</b> events, the substituted string will be
one of the following:
</p>
<div class="example">
<pre class="example">Above Opposite
Below TopIf
BottomIf
</pre></div>
<p>For events other than these, the substituted string is undefined.
.RE
</p></dd>
<dt><b>|%f|</b></dt>
<dd><p>The <i>focus</i><span class="roman"> field from the event (</span><b>0</b><span class="roman"> or </span><b>1</b>). Valid only
for <b>EnterNotify</b><span class="roman"> and </span><b>LeaveNotify</b> events.
</p></dd>
<dt><b>|%h|</b></dt>
<dd><p>The <i>height</i><span class="roman"> field from the event. Valid only for </span><b>Configure</b>,
<b>ConfigureNotify</b><span class="roman">, </span><b>Expose</b><span class="roman">, </span><b>GraphicsExpose</b>, and
<b>ResizeRequest</b> events.
</p></dd>
<dt><b>|%k|</b></dt>
<dd><p>The <i>keycode</i><span class="roman"> field from the event. Valid only for </span><b>KeyPress</b>
and <b>KeyRelease</b> events.
</p></dd>
<dt><b>|%m|</b></dt>
<dd><p>The <i>mode</i> field from the event. The substituted string is one of
<b>NotifyNormal</b><span class="roman">, </span><b>NotifyGrab</b><span class="roman">, </span><b>NotifyUngrab</b>, or
<b>NotifyWhileGrabbed</b><span class="roman">. Valid only for </span><b>EnterWindow</b>,
<b>FocusIn</b><span class="roman">, </span><b>FocusOut</b><span class="roman">, and </span><b>LeaveWindow</b> events.
</p></dd>
<dt><b>|%o|</b></dt>
<dd><p>The <i>override_redirect</i> field from the event. Valid only for
<b>CreateNotify</b><span class="roman">, </span><b>MapNotify</b><span class="roman">, </span><b>ReparentNotify</b>,
and <b>ConfigureNotify</b> events.
</p></dd>
<dt><b>|%p|</b></dt>
<dd><p>The <i>place</i> field from the event, substituted as one of the
strings <b>PlaceOnTop</b><span class="roman"> or </span><b>PlaceOnBottom</b>. Valid only
for <b>CirculateNotify</b><span class="roman"> and </span><b>CirculateRequest</b> events.
</p></dd>
<dt><b>|%s|</b></dt>
<dd><p>The <i>state</i><span class="roman"> field from the event. For </span><b>ButtonPress</b>,
<b>ButtonRelease</b><span class="roman">, </span><b>EnterNotify</b><span class="roman">, </span><b>KeyPress</b><span class="roman">, </span><b>KeyRelease</b>,
<b>LeaveNotify</b><span class="roman">, and </span><b>MotionNotify</b> events,
a decimal string
is substituted. For <b>VisibilityNotify</b>, one of the strings
<b>VisibilityUnobscured</b><span class="roman">, </span><b>VisibilityPartiallyObscured</b>,
and <b>VisibilityFullyObscured</b> is substituted.
</p></dd>
<dt><b>|%t|</b></dt>
<dd><p>The <i>time</i> field from the event. Valid only for events that
contain a <i>time</i> field.
</p></dd>
<dt><b>|%v|</b></dt>
<dd><p>The <i>value_mask</i> field from the event. Valid only for
<b>ConfigureRequest</b> events.
</p></dd>
<dt><b>|%w|</b></dt>
<dd><p>The <i>width</i> field from the event. Valid only for
<b>Configure</b><span class="roman">, </span><b>ConfigureRequest</b><span class="roman">, </span><b>Expose</b>,
<b>GraphicsExpose</b><span class="roman">, and </span><b>ResizeRequest</b> events.
</p></dd>
<dt><b>|%x|</b></dt>
<dd><p>The <i>x</i> field from the event. Valid only for events containing
an <i>x</i> field.
</p></dd>
<dt><b>|%y|</b></dt>
<dd><p>The <i>y</i> field from the event. Valid only for events containing
a <i>y</i> field.
</p></dd>
<dt><b>%A</b></dt>
<dd><p>Substitutes the ASCII character corresponding to the event, or
the empty string if the event doesn&rsquo;t correspond to an ASCII character
(e.g. the shift key was pressed). <b>XLookupString</b> does all the
work of translating from the event to an ASCII character.
Valid only for <b>KeyPress</b><span class="roman"> and </span><b>KeyRelease</b> events.
</p></dd>
<dt><b>%B</b></dt>
<dd><p>The <i>border_width</i> field from the event. Valid only for
<b>ConfigureNotify</b><span class="roman"> and </span><b>CreateWindow</b> events.
</p></dd>
<dt><b>%D</b></dt>
<dd><p>The <i>display</i> field from the event. Valid for all event types.
</p></dd>
<dt><b>%E</b></dt>
<dd><p>The <i>send_event</i> field from the event. Valid for all event types.
</p></dd>
<dt><b>%K</b></dt>
<dd><p>The keysym corresponding to the event, substituted as a textual
string. Valid only for <b>KeyPress</b><span class="roman"> and </span><b>KeyRelease</b> events.
</p></dd>
<dt><b>%N</b></dt>
<dd><p>The keysym corresponding to the event, substituted as
a decimal
number. Valid only for <b>KeyPress</b><span class="roman"> and </span><b>KeyRelease</b> events.
</p></dd>
<dt><b>%R</b></dt>
<dd><p>The <i>root</i> window identifier from the event. Valid only for
events containing a <i>root</i> field.
</p></dd>
<dt><b>%S</b></dt>
<dd><p>The <i>subwindow</i> window identifier from the event. Valid only for
events containing a <i>subwindow</i> field.
</p></dd>
<dt><b>%T</b></dt>
<dd><p>The <i>type</i> field from the event. Valid for all event types.
</p></dd>
<dt><b>%W</b></dt>
<dd><p>The path name of the window to which the event was reported (the
<i>window</i> field from the event). Valid for all event types.
</p></dd>
<dt><b>%X</b></dt>
<dd><p>The <i>x_root</i> field from the event.
If a virtual-root window manager is being used then the substituted
value is the corresponding x-coordinate in the virtual root.
Valid only for
<b>ButtonPress</b><span class="roman">, </span><b>ButtonRelease</b><span class="roman">, </span><b>KeyPress</b><span class="roman">, </span><b>KeyRelease</b>,
and <b>MotionNotify</b> events.
</p></dd>
<dt><b>%Y</b></dt>
<dd><p>The <i>y_root</i> field from the event.
If a virtual-root window manager is being used then the substituted
value is the corresponding y-coordinate in the virtual root.
Valid only for
<b>ButtonPress</b><span class="roman">, </span><b>ButtonRelease</b><span class="roman">, </span><b>KeyPress</b><span class="roman">, </span><b>KeyRelease</b>,
and <b>MotionNotify</b> events.
</p></dd>
</dl>
<p>If the replacement string
for a %-replacement contains characters that are interpreted
specially by the Tcl parser (such as backslashes or square
brackets or spaces) additional backslashes are added
during replacement so that the result after parsing is the original
replacement string.
For example, if <i>command</i> is
</p>
<div class="example">
<pre class="example">insert %A
</pre></div>
<p>and the character typed is an open square bracket, then the command
actually executed will be
</p>
<div class="example">
<pre class="example">insert \e[
</pre></div>
<p>This will cause the <b>insert</b> to receive the original replacement
string (open square bracket) as its first argument.
If the extra backslash hadn&rsquo;t been added, Tcl would not have been
able to parse the command correctly.
</p>
<p>At most one binding will trigger for any given X event.
If several bindings match the recent events, the most specific binding
is chosen and its command will be executed.
The following tests are applied, in order, to determine which of
several matching sequences is more specific:
(a) a binding whose <i>windowSpec</i> names a particular window is
more specific than a binding for a class,
which is more specific than a binding whose <i>windowSpec</i> is
<b>all</b>;
(b) a longer sequence (in terms of number
of events matched) is more specific than a shorter sequence;
(c) an event pattern that specifies a specific button or key is more specific
than one that doesn&rsquo;t; (e) an event pattern that requires a particular
modifier is more specific than one that doesn&rsquo;t require the modifier;
(e) an event pattern specifying the <b>Any</b> modifier is less specific
than one that doesn&rsquo;t. If the matching sequences contain more than
one event, then tests (c)-(e) are applied in order from the most
recent event to the least recent event in the sequences. If these
tests fail to determine a winner, then the most recently registered
sequence is the winner.
</p>
<p>If an X event does not match any of the existing bindings, then the
event is ignored (an unbound event is not considered to be an error).
</p>
<p>When a <i>sequence</i><span class="roman"> specified in a </span><b>bind</b> command contains
more than one event pattern, then its command is executed whenever
the recent events (leading up to and including the current event)
match the given sequence. This means, for example, that if button 1 is
clicked repeatedly the sequence <b>&lt;Double-ButtonPress-1&gt;</b> will match
each button press but the first.
If extraneous events that would prevent a match occur in the middle
of an event sequence then the extraneous events are
ignored unless they are <b>KeyPress</b><span class="roman"> or </span><b>ButtonPress</b> events.
For example, <b>&lt;Double-ButtonPress-1&gt;</b> will match a sequence of
presses of button 1, even though there will be <b>ButtonRelease</b>
events (and possibly <b>MotionNotify</b> events) between the
<b>ButtonPress</b> events.
Furthermore, a <b>KeyPress</b> event may be preceded by any number
of other <b>KeyPress</b> events for modifier keys without the
modifier keys preventing a match.
For example, the event sequence <b>aB</b> will match a press of the
<b>a</b><span class="roman"> key, a release of the </span><b>a</b><span class="roman"> key, a press of the </span><b>Shift</b>
key, and a press of the <b>b</b><span class="roman"> key: the press of </span><b>Shift</b> is
ignored because it is a modifier key.
Finally, if several <b>MotionNotify</b> events occur in a row, only
the last one is used for purposes of matching binding sequences.
</p>
<p>If an error occurs in executing the command for a binding then the
<b>tkerror</b> mechanism is used to report the error.
The command will be executed at global level (outside the context
of any Tcl procedure).
</p>
<p>See <a href="tkerror.html#tkerror">tkerror</a>.
</p>
<a name="Keywords-16"></a>
<h4 class="unnumberedsubsec">Keywords</h4>
<p>form, manual
</p><hr>
<div class="header">
<p>
Next: <a href="destroy.html#destroy" accesskey="n" rel="next">destroy</a>, Previous: <a href="after.html#after" accesskey="p" rel="prev">after</a>, Up: <a href="Control.html#Control" accesskey="u" rel="up">Control</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
</body>
</html>

263
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/button.html Normal file
View file

@ -0,0 +1,263 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL TK Manual: button</title>
<meta name="description" content="GCL TK Manual: button">
<meta name="keywords" content="GCL TK Manual: button">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="wm.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Widgets.html#Widgets" rel="up" title="Widgets">
<link href="listbox.html#listbox" rel="next" title="listbox">
<link href="Widgets.html#Widgets" rel="prev" title="Widgets">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="button"></a>
<div class="header">
<p>
Next: <a href="listbox.html#listbox" accesskey="n" rel="next">listbox</a>, Previous: <a href="Widgets.html#Widgets" accesskey="p" rel="prev">Widgets</a>, Up: <a href="Widgets.html#Widgets" accesskey="u" rel="up">Widgets</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
<hr>
<a name="button-1"></a>
<h3 class="section">2.1 button</h3>
<p>button \- Create and manipulate button widgets
</p><a name="Synopsis"></a>
<h4 class="unnumberedsubsec">Synopsis</h4>
<p><b>button</b><i> </i><i>pathName </i><span class="roman">?</span><i>options</i>?
</p><a name="Standard-Options"></a>
<h4 class="unnumberedsubsec">Standard Options</h4>
<div class="example">
<pre class="example">activeBackground bitmap font relief
activeForeground borderWidth foreground text
anchor cursor padX textVariable
background disabledForeground padY
</pre></div>
<p>See <a href="options.html#options">options</a>, for more information.
</p><a name="Arguments-for-Button"></a>
<h4 class="unnumberedsubsec">Arguments for Button</h4>
<dl compact="compact">
<dt><code><b>:command</b></code></dt>
<dd><p align="right">Name=<code>&quot;<b>command</b><span class="roman">&quot;</span> Class=<code>&quot;</code><b>Command</b>&quot;</code>
</p><br>
<p>Specifies a Tcl command to associate with the button. This command
is typically invoked when mouse button 1 is released over the button
window.
</p></dd>
</dl>
<dl compact="compact">
<dt><code><b>:height</b></code></dt>
<dd><p align="right">Name=<code>&quot;<b>height</b><span class="roman">&quot;</span> Class=<code>&quot;</code><b>Height</b>&quot;</code>
</p><br>
<p>Specifies a desired height for the button.
If a bitmap is being displayed in the button then the value is in
screen units (i.e. any of the forms acceptable to <b>Tk_GetPixels</b>);
for text it is in lines of text.
If this option isn&rsquo;t specified, the button&rsquo;s desired height is computed
from the size of the bitmap or text being displayed in it.
</p></dd>
</dl>
<dl compact="compact">
<dt><code><b>:state</b></code></dt>
<dd><p align="right">Name=<code>&quot;<b>state</b><span class="roman">&quot;</span> Class=<code>&quot;</code><b>State</b>&quot;</code>
</p><br>
<p>Specifies one of three states for the button: <b>normal</b><span class="roman">, </span><b>active</b>,
or <b>disabled</b>. In normal state the button is displayed using the
<b>foreground</b><span class="roman"> and </span><b>background</b> options. The active state is
typically used when the pointer is over the button. In active state
the button is displayed using the <b>activeForeground</b> and
<b>activeBackground</b> options. Disabled state means that the button
is insensitive: it doesn&rsquo;t activate and doesn&rsquo;t respond to mouse
button presses. In this state the <b>disabledForeground</b> and
<b>background</b> options determine how the button is displayed.
</p></dd>
</dl>
<dl compact="compact">
<dt><code><b>:width</b></code></dt>
<dd><p align="right">Name=<code>&quot;<b>width</b><span class="roman">&quot;</span> Class=<code>&quot;</code><b>Width</b>&quot;</code>
</p><br>
<p>Specifies a desired width for the button.
If a bitmap is being displayed in the button then the value is in
screen units (i.e. any of the forms acceptable to <b>Tk_GetPixels</b>);
for text it is in characters.
If this option isn&rsquo;t specified, the button&rsquo;s desired width is computed
from the size of the bitmap or text being displayed in it.
</p></dd>
</dl>
<a name="Description"></a>
<h4 class="unnumberedsubsec">Description</h4>
<p>The <b>button</b> command creates a new window (given by the
<i>pathName</i> argument) and makes it into a button widget.
Additional
options, described above, may be specified on the command line
or in the option database
to configure aspects of the button such as its colors, font,
text, and initial relief. The <b>button</b> command returns its
<i>pathName</i> argument. At the time this command is invoked,
there must not exist a window named <i>pathName</i>, but
<i>pathName</i>&rsquo;s parent must exist.
</p>
<p>A button is a widget
that displays a textual string or bitmap.
It can display itself in either of three different ways, according
to
the <b>state</b> option;
it can be made to appear raised, sunken, or flat;
and it can be made to flash. When a user invokes the
button (by pressing mouse button 1 with the cursor over the
button), then the Tcl command specified in the <b>:command</b>
option is invoked.
</p>
<a name="A-Button-Widget_0027s-Arguments"></a>
<h4 class="unnumberedsubsec">A Button Widget&rsquo;s Arguments</h4>
<p>The <b>button</b> command creates a new Tcl command whose
name is <i>pathName</i>. This
command may be used to invoke various
operations on the widget. It has the following general form:
</p>
<div class="example">
<pre class="example"><i>pathName option </i><span class="roman">?</span><i>arg arg ...</i>?
</pre></div>
<p><i>Option</i><span class="roman"> and the </span><i>arg</i>s
determine the exact behavior of the command. The following
commands are possible for button widgets:
</p>
<dl compact="compact">
<dt><i>pathName </i><b>:activate</b></dt>
<dd><p>Change the button&rsquo;s state to <b>active</b> and redisplay the button
using its active foreground and background colors instead of normal
colors.
This command is ignored if the button&rsquo;s state is <b>disabled</b>.
This command is obsolete and will eventually be removed;
use &ldquo;<i>pathName </i><b>:configure :state active</b>&rdquo; instead.
</p></dd>
<dt><i>pathName </i><b>:configure</b><span class="roman"> ?</span><i>option</i><span class="roman">? ?</span><i>value option value ...</i>?</dt>
<dd><p>Query or modify the configuration options of the widget.
If no <i>option</i> is specified, returns a list describing all of
the available options for <i>pathName</i><span class="roman"> (see </span><b>Tk_ConfigureInfo</b> for
information on the format of this list). If <i>option</i> is specified
with no <i>value</i>, then the command returns a list describing the
one named option (this list will be identical to the corresponding
sublist of the value returned if no <i>option</i> is specified). If
one or more <i>option:value</i> pairs are specified, then the command
modifies the given widget option(s) to have the given value(s); in
this case the command returns an empty string.
<i>Option</i><span class="roman"> may have any of the values accepted by the </span><b>button</b>
command.
</p></dd>
<dt><i>pathName </i><b>:deactivate</b></dt>
<dd><p>Change the button&rsquo;s state to <b>normal</b> and redisplay the button
using its normal foreground and background colors.
This command is ignored if the button&rsquo;s state is <b>disabled</b>.
This command is obsolete and will eventually be removed;
use &ldquo;<i>pathName </i><b>:configure :state normal</b>&rdquo; instead.
</p></dd>
<dt><i>pathName </i><b>:flash</b></dt>
<dd><p>Flash the button. This is accomplished by redisplaying the button
several times, alternating between active and normal colors. At
the end of the flash the button is left in the same normal/active
state as when the command was invoked.
This command is ignored if the button&rsquo;s state is <b>disabled</b>.
</p></dd>
<dt><i>pathName </i><b>:invoke</b></dt>
<dd><p>Invoke the Tcl command associated with the button, if there is one.
The return value is the return value from the Tcl command, or an
empty string if there is no command associated with the button.
This command is ignored if the button&rsquo;s state is <b>disabled</b>.
</p>
</dd>
</dl>
<a name="g_t_0022Default-Bindings_0022"></a>
<h4 class="unnumberedsubsec">&quot;Default Bindings&quot;</h4>
<p>Tk automatically creates class bindings for buttons that give them
the following default behavior:
</p><ul class="no-bullet">
<li> [1]
The button activates whenever the mouse passes over it and deactivates
whenever the mouse leaves the button.
</li><li> [2]
The button&rsquo;s relief is changed to sunken whenever mouse button 1 is
pressed over the button, and the relief is restored to its original
value when button 1 is later released.
</li><li> [3]
If mouse button 1 is pressed over the button and later released over
the button, the button is invoked. However, if the mouse is not
over the button when button 1 is released, then no invocation occurs.
</li></ul>
<p>If the button&rsquo;s state is <b>disabled</b> then none of the above
actions occur: the button is completely non-responsive.
</p>
<p>The behavior of buttons can be changed by defining new bindings for
individual widgets or by redefining the class bindings.
</p>
<a name="Keywords"></a>
<h4 class="unnumberedsubsec">Keywords</h4>
<p>button, widget
</p><hr>
<div class="header">
<p>
Next: <a href="listbox.html#listbox" accesskey="n" rel="next">listbox</a>, Previous: <a href="Widgets.html#Widgets" accesskey="p" rel="prev">Widgets</a>, Up: <a href="Widgets.html#Widgets" accesskey="u" rel="up">Widgets</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
</body>
</html>

1570
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/canvas.html Normal file
View file

File diff suppressed because it is too large Load diff

347
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/checkbutton.html Normal file
View file

@ -0,0 +1,347 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GCL TK Manual: checkbutton</title>
<meta name="description" content="GCL TK Manual: checkbutton">
<meta name="keywords" content="GCL TK Manual: checkbutton">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="wm.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Widgets.html#Widgets" rel="up" title="Widgets">
<link href="menubutton.html#menubutton" rel="next" title="menubutton">
<link href="scrollbar.html#scrollbar" rel="prev" title="scrollbar">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="checkbutton"></a>
<div class="header">
<p>
Next: <a href="menubutton.html#menubutton" accesskey="n" rel="next">menubutton</a>, Previous: <a href="scrollbar.html#scrollbar" accesskey="p" rel="prev">scrollbar</a>, Up: <a href="Widgets.html#Widgets" accesskey="u" rel="up">Widgets</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
<hr>
<a name="checkbutton-1"></a>
<h3 class="section">2.7 checkbutton</h3>
<p>checkbutton \- Create and manipulate check-button widgets
</p><a name="Synopsis-6"></a>
<h4 class="unnumberedsubsec">Synopsis</h4>
<p><b>checkbutton</b><i> pathName </i><span class="roman">?</span><i>options</i>?
</p><a name="Standard-Options-6"></a>
<h4 class="unnumberedsubsec">Standard Options</h4>
<div class="example">
<pre class="example">activeBackground bitmap font relief
activeForeground borderWidth foreground text
anchor cursor padX textVariable
background disabledForeground padY
</pre></div>
<p>See <a href="options.html#options">options</a>, for more information.
</p><a name="Arguments-for-Checkbutton"></a>
<h4 class="unnumberedsubsec">Arguments for Checkbutton</h4>
<dl compact="compact">
<dt><code><b>:command</b></code></dt>
<dd><p align="right">Name=<code>&quot;<b>command</b><span class="roman">&quot;</span> Class=<code>&quot;</code><b>Command</b>&quot;</code>
</p><br>
<p>Specifies a Tcl command to associate with the button. This command
is typically invoked when mouse button 1 is released over the button
window. The button&rsquo;s global variable (<b>:variable</b> option) will
be updated before the command is invoked.
</p></dd>
</dl>
<dl compact="compact">
<dt><code><b>:height</b></code></dt>
<dd><p align="right">Name=<code>&quot;<b>height</b><span class="roman">&quot;</span> Class=<code>&quot;</code><b>Height</b>&quot;</code>
</p><br>
<p>Specifies a desired height for the button.
If a bitmap is being displayed in the button then the value is in
screen units (i.e. any of the forms acceptable to <b>Tk_GetPixels</b>);
for text it is in lines of text.
If this option isn&rsquo;t specified, the button&rsquo;s desired height is computed
from the size of the bitmap or text being displayed in it.
</p></dd>
</dl>
<dl compact="compact">
<dt><code><b>:offvalue</b></code></dt>
<dd><p align="right">Name=<code>&quot;<b>offValue</b><span class="roman">&quot;</span> Class=<code>&quot;</code><b>Value</b>&quot;</code>
</p><br>
<p>Specifies value to store in the button&rsquo;s associated variable whenever
this button is deselected. Defaults to &ldquo;0&rdquo;.
</p></dd>
</dl>
<dl compact="compact">
<dt><code><b>:onvalue</b></code></dt>
<dd><p align="right">Name=<code>&quot;<b>onValue</b><span class="roman">&quot;</span> Class=<code>&quot;</code><b>Value</b>&quot;</code>
</p><br>
<p>Specifies value to store in the button&rsquo;s associated variable whenever
this button is selected. Defaults to &ldquo;1&rdquo;.
</p></dd>
</dl>
<dl compact="compact">
<dt><code><b>:selector</b></code></dt>
<dd><p align="right">Name=<code>&quot;<b>selector</b><span class="roman">&quot;</span> Class=<code>&quot;</code><b>Foreground</b>&quot;</code>
</p><br>
<p>Specifies the color to draw in the selector when this button is
selected.
If specified as an empty string then no selector is
drawn for the button.
</p></dd>
</dl>
<dl compact="compact">
<dt><code><b>:state</b></code></dt>
<dd><p align="right">Name=<code>&quot;<b>state</b><span class="roman">&quot;</span> Class=<code>&quot;</code><b>State</b>&quot;</code>
</p><br>
<p>Specifies one of three states for the check button: <b>normal</b><span class="roman">, </span><b>active</b>,
or <b>disabled</b>. In normal state the check button is displayed using the
<b>foreground</b><span class="roman"> and </span><b>background</b> options. The active state is
typically used when the pointer is over the check button. In active state
the check button is displayed using the <b>activeForeground</b> and
<b>activeBackground</b> options. Disabled state means that the check button
is insensitive: it doesn&rsquo;t activate and doesn&rsquo;t respond to mouse
button presses. In this state the <b>disabledForeground</b> and
<b>background</b> options determine how the check button is displayed.
</p></dd>
</dl>
<dl compact="compact">
<dt><code><b>:variable</b></code></dt>
<dd><p align="right">Name=<code>&quot;<b>variable</b><span class="roman">&quot;</span> Class=<code>&quot;</code><b>Variable</b>&quot;</code>
</p><br>
<p>Specifies name of global variable to set to indicate whether
or not this button is selected. Defaults to the name of the
button within its parent (i.e. the last element of the button
window&rsquo;s path name).
</p></dd>
</dl>
<dl compact="compact">
<dt><code><b>:width</b></code></dt>
<dd><p align="right">Name=<code>&quot;<b>width</b><span class="roman">&quot;</span> Class=<code>&quot;</code><b>Width</b>&quot;</code>
</p><br>
<p>Specifies a desired width for the button.
If a bitmap is being displayed in the button then the value is in
screen units (i.e. any of the forms acceptable to <b>Tk_GetPixels</b>);
for text it is in characters.
If this option isn&rsquo;t specified, the button&rsquo;s desired width is computed
from the size of the bitmap or text being displayed in it.
</p></dd>
</dl>
<a name="Description-4"></a>
<h4 class="unnumberedsubsec">Description</h4>
<p>The <b>checkbutton</b> command creates a new window (given by the
<i>pathName</i> argument) and makes it into a check-button widget.
Additional
options, described above, may be specified on the command line
or in the option database
to configure aspects of the check button such as its colors, font,
text, and initial relief. The <b>checkbutton</b> command returns its
<i>pathName</i> argument. At the time this command is invoked,
there must not exist a window named <i>pathName</i>, but
<i>pathName</i>&rsquo;s parent must exist.
</p>
<p>A check button is a widget
that displays a textual string or bitmap
and a square called a <i>selector</i>.
A check button has
all of the behavior of a simple button, including the
following: it can display itself in either of three different
ways, according to the <b>state</b> option;
it can be made to appear
raised, sunken, or flat; it can be made to flash; and it invokes
a Tcl command whenever mouse button 1 is clicked over the
check button.
</p>
<p>In addition, check buttons can be <i>selected</i>. If a check button is
selected then a special highlight appears in the selector, and
a Tcl variable associated with the check button is set to a particular
value (normally 1). If the check button is not selected, then
the selector is drawn in a different fashion and the associated
variable is set to a different value (typically 0). By default,
the name of the variable associated with a check button is the
same as the <i>name</i> used to create the check button. The
variable name, and the &ldquo;on&rdquo; and &ldquo;off&rdquo; values stored in it,
may be modified with options on the command line or in the option
database. By default a check button is configured to select and deselect
itself on alternate button clicks.
In addition, each check button monitors its associated variable and
automatically selects and deselects itself when the variables value
changes to and from the button&rsquo;s &ldquo;on&rdquo; value.
</p>
<a name="A-Checkbutton-Widget_0027s-Arguments"></a>
<h4 class="unnumberedsubsec">A Checkbutton Widget&rsquo;s Arguments</h4>
<p>The <b>checkbutton</b> command creates a new Tcl command whose
name is <i>pathName</i>. This
command may be used to invoke various
operations on the widget. It has the following general form:
</p>
<div class="example">
<pre class="example"><i>pathName option </i><span class="roman">?</span><i>arg arg ...</i>?
</pre></div>
<p><i>Option</i><span class="roman"> and the </span><i>arg</i>s
determine the exact behavior of the command. The following
commands are possible for check button widgets:
</p>
<dl compact="compact">
<dt><i>pathName </i><b>:activate</b></dt>
<dd><p>Change the check button&rsquo;s state to <b>active</b> and redisplay the button
using its active foreground and background colors instead of normal
colors.
This command is ignored if the check button&rsquo;s state is <b>disabled</b>.
This command is obsolete and will eventually be removed;
use &ldquo;<i>pathName </i><b>:configure :state active</b>&rdquo; instead.
</p></dd>
<dt><i>pathName </i><b>:configure</b><span class="roman"> ?</span><i>option</i><span class="roman">? ?</span><i>value option value ...</i>?</dt>
<dd><p>Query or modify the configuration options of the widget.
If no <i>option</i> is specified, returns a list describing all of
the available options for <i>pathName</i><span class="roman"> (see </span><b>Tk_ConfigureInfo</b> for
information on the format of this list). If <i>option</i> is specified
with no <i>value</i>, then the command returns a list describing the
one named option (this list will be identical to the corresponding
sublist of the value returned if no <i>option</i> is specified). If
one or more <i>option:value</i> pairs are specified, then the command
modifies the given widget option(s) to have the given value(s); in
this case the command returns an empty string.
<i>Option</i><span class="roman"> may have any of the values accepted by the </span><b>checkbutton</b>
command.
</p></dd>
<dt><i>pathName </i><b>:deactivate</b></dt>
<dd><p>Change the check button&rsquo;s state to <b>normal</b> and redisplay the button
using its normal foreground and background colors.
This command is ignored if the check button&rsquo;s state is <b>disabled</b>.
This command is obsolete and will eventually be removed;
use &ldquo;<i>pathName </i><b>:configure :state normal</b>&rdquo; instead.
</p></dd>
<dt><i>pathName </i><b>:deselect</b></dt>
<dd><p>Deselect the check button: redisplay it without a highlight in
the selector and set the associated variable to its &ldquo;off&rdquo;
value.
</p></dd>
<dt><i>pathName </i><b>:flash</b></dt>
<dd><p>Flash the check button. This is accomplished by redisplaying the check button
several times, alternating between active and normal colors. At
the end of the flash the check button is left in the same normal/active
state as when the command was invoked.
This command is ignored if the check button&rsquo;s state is <b>disabled</b>.
</p></dd>
<dt><i>pathName </i><b>:invoke</b></dt>
<dd><p>Does just what would have happened if the user invoked the check button
with the mouse: toggle the selection state of the button and invoke
the Tcl command associated with the check button, if there is one.
The return value is the return value from the Tcl command, or an
empty string if there is no command associated with the check button.
This command is ignored if the check button&rsquo;s state is <b>disabled</b>.
</p></dd>
<dt><i>pathName </i><b>:select</b></dt>
<dd><p>Select the check button: display it with a highlighted
selector and set the associated variable to its &ldquo;on&rdquo;
value.
</p></dd>
<dt><i>pathName </i><b>:toggle</b></dt>
<dd><p>Toggle the selection state of the button, redisplaying it and
modifying its associated variable to reflect the new state.
</p>
</dd>
</dl>
<a name="Bindings-3"></a>
<h4 class="unnumberedsubsec">Bindings</h4>
<p>Tk automatically creates class bindings for check buttons that give them
the following default behavior:
</p><ul class="no-bullet">
<li> [1]
The check button activates whenever the mouse passes over it and deactivates
whenever the mouse leaves the check button.
</li><li> [2]
The check button&rsquo;s relief is changed to sunken whenever mouse button 1 is
pressed over it, and the relief is restored to its original
value when button 1 is later released.
</li><li> [3]
If mouse button 1 is pressed over the check button and later released over
the check button, the check button is invoked (i.e. its selection
state toggles and the command associated with the button is invoked,
if there is one). However, if the mouse is not
over the check button when button 1 is released, then no invocation occurs.
</li></ul>
<p>If the check button&rsquo;s state is <b>disabled</b> then none of the above
actions occur: the check button is completely non-responsive.
</p>
<p>The behavior of check buttons can be changed by defining new bindings for
individual widgets or by redefining the class bindings.
</p>
<a name="Keywords-6"></a>
<h4 class="unnumberedsubsec">Keywords</h4>
<p>check button, widget
</p><hr>
<div class="header">
<p>
Next: <a href="menubutton.html#menubutton" accesskey="n" rel="next">menubutton</a>, Previous: <a href="scrollbar.html#scrollbar" accesskey="p" rel="prev">scrollbar</a>, Up: <a href="Widgets.html#Widgets" accesskey="u" rel="up">Widgets</a> &nbsp; [<a href="wm.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>]</p>
</div>
</body>
</html>

158
clones/lisp/www.csci.viu.ca/~wesselsd/courses/csci330/code/lisp/gcl-tk/demos/gc-monitor.lisp.html Normal file
View file

@ -0,0 +1,158 @@
;; bug in aix c compiler on optimize??
#+aix3 (eval-when (compile) (proclaim '(optimize (speed 0))))
(in-package "TK")
(defvar *gc-monitor-types*
'(cons fixnum string si::relocatable-blocks stream))
(defvar *special-type-background* "red")
(defun make-one-graph (top type)
(let* ((f (conc top '.type type)))
(setf (get type 'frame) f)
(setf (get type 'canvas) (conc top '.canvas type))
(frame f )
(canvas (get type 'canvas) :relief "sunken" :width "8c" :height ".4c")
(label (conc f '.data))
(button (conc f '.label) :text (string-capitalize (symbol-name type))
:background "gray90"
:command `(draw-status ',type t))
(pack (conc f '.label) (conc f '.data) :side "left" :anchor "w" :padx "4m")
(pack f :side "top" :anchor "w" :padx "1c")
(pack (get type 'canvas) :side "top" :expand 1 :pady "2m")
))
(defvar *prev-special-type* nil)
(defvar *time-to-stay-on-type* 0)
(defvar *values-array* (make-array 20 :fill-pointer 0))
(defun push-multiple-values (&rest l)
(declare (:dynamic-extent l))
(dolist (v l) (vector-push-extend v *values-array*)))
(defun draw-status (special-type &optional clicked)
(setf (fill-pointer *values-array*) 0)
(let ((max-size 0) (ar *values-array*) (i 0) (width 7.0s0)
(ht ".15c"))
(declare (fixnum max-size) (short-float width)(type (array (t)) ar))
(dolist (v *gc-monitor-types*)
(let ((fp (fill-pointer *values-array*))
)
(multiple-value-call 'push-multiple-values (si::allocated v))
(setq max-size (max max-size (aref ar (the fixnum (+ fp 1)))))))
; (nfree npages maxpage nppage gccount nused)
(dolist (v *gc-monitor-types*)
(let* ((nfree (aref ar i))
(npages (aref ar (setq i(+ i 1))))
(nppage (aref ar (setq i(+ i 2))))
(gccount (aref ar (setq i (+ i 1))))
(nused (aref ar (setq i (+ i 1))))
(wid (/ (the short-float(* npages width)) max-size))
(f (get v 'frame))
(tot (* npages nppage))
(width-used (the short-float
(/ (the short-float
(* wid (the fixnum
(- tot
(the fixnum nfree)))))
tot))))
(declare (fixnum nppage npages tot)
(short-float wid))
(setq i (+ i 1))
(funcall (get v 'canvas) :delete "graph")
(funcall (get v 'canvas) :create "line"
0 ht
width-used : "c" ht
:width "3m" :tag "graph" :fill "red")
(funcall (get v 'canvas) :create "line"
width-used : "c" ht
wid : "c" ht
:width "3m" :tag "graph" :fill "aquamarine4" )
(funcall (conc f '.data) :configure :text
gccount : " gc's for ": npages :
" pages (used=" : nused : ")")
(cond ((eql special-type v)
(cond
(clicked
(let ((n (* max-size 2)))
(.gc.amount :configure :length "8c"
:label "Allocate: " : (or special-type "")
:tickinterval (truncate n 4) :to n)
(.gc.amount :set npages)
)))))))
(set-label-background *prev-special-type* "pink")
(setq *prev-special-type* special-type)
(set-label-background special-type *special-type-background*)
)
)
(defun do-allocation ()
(when *prev-special-type*
(allocate *prev-special-type*
(.gc.amount :get :return 'number)
t)
(draw-status *prev-special-type*)))
(defun set-label-background (type colour)
(and (get type 'frame)
(let ((label (conc (get type 'frame) '.label)))
(funcall label :configure :background colour))))
(defun mkgcmonitor()
(let (si::*after-gbc-hook*)
(toplevel '.gc)
(wm :title '.gc "GC Monitor")
(wm :title '.gc "GC")
(or (> (read-from-string (winfo :depth '.gc)) 1)
(setq *special-type-background* "white"))
(message '.gc.msg :font :Adobe-times-medium-r-normal--*-180* :aspect 400
:text
"GC monitor displays after each garbage collection the amount of space used (red) and free (green) of the types in the list *gc-monitor-types*. Clicking on a type makes its size appear on the scale at the bottom, and double clicking on the scale causes actual allocation!")
(pack '.gc.msg :side "top")
(dolist (v *gc-monitor-types*)
(make-one-graph '.gc v)
)
(.gc :configure :borderwidth 4 :relief "ridge")
;; it is important to create the frame first, so that
;; it is earlier... and the others will show.
(frame '.gc.ff)
(button '.gc.ok :text "QUIT"
:command `(progn (setq si::*after-gbc-hook* nil)
(destroy '.gc)))
(scale '.gc.amount :label "Amount :" :width ".3c"
:orient "horizontal" :to 100)
(pack '.gc.amount)
(button '.gc.reset :text "RESET Number Used"
:command '(progn (dolist (v *gc-monitor-types*)
(set-label-background v "gray90"))
(si::reset-number-used)
(draw-status *prev-special-type*)))
(button '.gc.update :text "Update"
:command '(draw-status *prev-special-type*))
(pack '.gc.ok '.gc.reset '.gc.update :expand 1 :fill "x"
:in '.gc.ff :padx 3 :pady 2 :side 'left)
(pack '.gc.ff :expand 1 :fill "x")
(bind '.gc.amount "<Double-ButtonPress-1>"
'do-allocation)
(draw-status nil))
(setq si::*after-gbc-hook* 'draw-status)
)

Some files were not shown because too many files have changed in this diff Show more