2006 Scheme and Functional Programming Papers, University of

More documents

Recommendations

Info

we introduced in 3.11. The only difference is that global labels are used to hold the values of the primitives. The first library file initializes one primitive: string->symbol. Our first implementation of string->symbol need not be efficient: a simple linked list of symbols suffices. The primitive string->symbol, as its name suggests, takes a string as input and returns a symbol. By adding the core primitives make-symbol 1 and symbol-string, the implementation of string->symbol simply traverses the list of symbols looking for one having the same string. A new symbol is constructed if one with the same name does not exist. This new symbol is then added to the list before it is returned. Once string->symbol is implemented, adding symbols to our set of valid complex constants is straightforward by the following transformation: (labels ((f0 (code () () ’foo))) (let ((f (closure f0))) (eq? (funcall f) (funcall f)))) => (labels ((f0 (code () () (constant-ref t1))) (t1 (datum))) (constant-init t1 (funcall (primitive-ref string->symbol) (string #\f #\o #\o))) (let ((f (closure f0))) (eq? (funcall f) (funcall f)))) 3.15 Foreign Functions Our Scheme implementation cannot exist in isolation. It needs a way of interacting with the host operating system in order to perform Input/Output and many other useful operations. We now add a very simple way of calling to foreign C procedures. We add one additional form to our compiler: ::= (foreign-call ...) The foreign-call form takes a string literal as the first argument. The string denotes the name of the C procedure that we intend to call. Each of the expressions are evaluated first and their values are passed as arguments to the C procedure. The calling convention for C differs from the calling convention that we have been using for Scheme in that the arguments are placed below the return point and in reverse order. Figure 4 illustrates the difference. To accommodate the C calling conventions, we evaluate the arguments to a foreign-call in reverse order, saving the values on the stack, adjusting the value of %esp, issuing a call to the named procedure, then adjusting the stack pointer back to its initial position. We need not worry about the C procedure clobbering the values of the allocation and closure pointer because the Application Binary Interface (ABI) guarantees that the callee would preserve the values of the %edi, %esi, %ebp and %esp registers[14]. Since the values we pass to the foreign procedure are tagged, we would write wrapper procedures in our run-time file that take care of converting from Scheme to C values and back. We first implement and test calling the exit procedure. Calling (foreign-call "exit" 0) should cause our program to exit without performing any output. We also implement a wrapper around write as follows: ptr s_write(ptr fd, ptr str, ptr len){ int bytes = write(unshift(fd), string_data(str), unshift(len)); return shift(bytes); } 1 Symbols are similar to pairs in having two fields: a string and a value free stack space incoming arguments base low address arg3 arg2 arg1 return point high address %esp-12 %esp-8 %esp-4 %esp (A) Parameter passing to Scheme free stack space base incoming arguments low address return point arg1 arg2 arg3 high address %esp %esp+4 %esp+8 %esp+12 (B) Parameter passing to C Figure 4. The parameters to Scheme functions are placed on the stack above the return point while the parameters to C functions are placed below the return point. 3.16 Error Checking and Safe Primitives Using our newly acquired ability to write and exit, we can define a simple error procedure that takes two arguments: a symbol (denoting the caller of error), and a string (describing the error). The error procedure would write an error message to the console, then causes the program to exit. With error, we can secure some parts of our implementation to provide better debugging facilities. Better debugging allows us to progress with implementing the rest of the system more quickly since we won’t have to hunt for the causes of segfaults. There are three main causes of fatal errors: 1. Attempting to call non-procedures. 2. Passing an incorrect number of arguments to a procedure. 3. Calling primitives with invalid arguments. For example: performing (car 5) causes an immediate segfault. Worse, performing vector-set! with an index that’s out of range causes other parts of the system to get corrupted, resulting in hard-todebug errors. Calling nonprocedures can be handled by performing a procedure check before making the procedure call. If the operator is not a procedure, control is transferred to an error handler label that sets up a call to a procedure that reports the error and exits. Passing an incorrect number of arguments to a procedure can be handled by a collaboration from the caller and the callee. The caller, once it performs the procedure check, sets the value of the %eax register to be the number of arguments passed. The callee checks that the value of %eax is consistent with the number of arguments it expects. Invalid arguments cause a jump to a label that calls a procedure that reports the error and exits. For primitive calls, we can modify the compiler to insert explicit checks at every primitive call. For example, car translates to: movl %eax, %ebx andl $7, %ebx cmpl $1, %ebx jne L_car_error movl -1(%eax), %eax ... L_car_error: movl car_err_proc, %edi movl $0, %eax jmp *-3(%edi) ... # load handler # set arg-count # call the handler 34 Scheme and Functional Programming, 2006
Another approach is to restrict the compiler to unsafe primitives. Calls to safe primitives are not open-coded by the compiler, instead, a procedure call to the safe primitive is issued. The safe primitives are defined to perform the error checks themselves. Although this strategy is less efficient than open-coding the safe primitives, the implementation is much simpler and less error-prone. 3.17 Variable-arity Procedures Scheme procedures that accept a variable number of arguments are easy to implement in the architecture we defined so far. Suppose a procedure is defined to accept two or more arguments as in the following example: (let ((f (lambda (a b . c) (vector a b c)))) (f 1 2 3 4)) The call to f passes four arguments in the stack locations %esp-4, %esp-8, %esp-12, and %esp-16 in addition to the number of arguments in %eax. Upon entry of f, and after performing the argument check, f enters a loop that constructs a list of the arguments last to front. Implementing variable-arity procedures allows us to define many library procedures that accept any number of arguments including +, -, *, =,
Page 1: Scheme and Functional Programming 2
Page 4 and 5: 4 Scheme and Functional Programming
Page 6 and 7: 6 Scheme and Functional Programming
Page 8 and 9: • A web browser that plays the ro
Page 10 and 11: and requests. When a client request
Page 12 and 13: above prevents pages from these dom
Page 14 and 15: 14 Scheme and Functional Programmin
Page 16 and 17: 2. Explaining Macros Macro expansio
Page 18 and 19: For completeness, here is the macro
Page 20 and 21: onment is extended in the original
Page 22 and 23: expand-term(term, env, phase) = emi
Page 24 and 25: Derivation ::= (make-mrule Syntax S
Page 26 and 27: True derivation (before macro hidin
Page 28 and 29: We assume that the reader has basic
Page 30 and 31: the value of the %eax register by 4
Page 32 and 33: Code generation for the new forms i
Page 36 and 37: the user code from interfering with
Page 40 and 41: mization and on creating efficient
Page 42 and 43: (a) stage (b) fifo (c) split (d) me
Page 44 and 45: This tagging is used later in the c
Page 46 and 47: (let ((clo_25 (%closure (lambda (y)
Page 48 and 49: nb. cycles per element 1400 1200 10
Page 52 and 53: a ∗ ❅ left right · b ❅ a S
Page 54 and 55: T ([spec], w) = { {w}, if w ∈ L([
Page 56 and 57: A([spec]): ✓✏ (where L([spec])
Page 58 and 59: construction commands. It is possib
Page 60 and 61: ; Regular expression for Scheme num
Page 62 and 63: References [1] A. V. Aho, R. Sethi,
Page 64 and 65: (let ((n (cond ((char? var0) ) ((sy
Page 66 and 67: 3. Survey An incomplete survey of a
Page 68 and 69: case monster 10 literals 100 litera
Page 72 and 73: modest programming requirements, an
Page 74 and 75: development of incomplete subsystem
Page 76 and 77: the previous request. This method a
Page 78 and 79: could be run indefinitely. This fun
Page 80 and 81: programmers reject Scheme without r
Page 82 and 83: (define interp (λ (env e) (case e
Page 84 and 85:
Before describing the run-time sema
Page 86 and 87:
Figure 5. Cast Insertion Figure 6.
Page 88 and 89:
Figure 7. Evaluation Figure 8. Eval
Page 90 and 91:
catching type errors, as we do here
Page 92 and 93:
[34] J. C. Reynolds. Types, abstrac
Page 94 and 95:
let id (T:*) (x:T) : T = x; The tra
Page 96 and 97:
Figure 3: Regular Expressions and N
Page 98 and 99:
Figure 5: Evaluation Rules Evaluati
Page 100 and 101:
5. Exact Substitution: E, (x = v :
Page 102 and 103:
Figure 9: Subtyping Algorithm Algor
Page 104 and 105:
for most type variables, and that m
Page 106 and 107:
2. miniKanren Overview This section
Page 108 and 109:
3. Pseudo-Variadic Relations Just a
Page 110 and 111:
Replacing run 10 with run ∗ cause
Page 112 and 113:
As might be expected, we could use
Page 114 and 115:
Of course there are still infinitel
Page 116 and 117:
To ensure that streams produced by
Page 118 and 119:
118 Scheme and Functional Programmi
Page 120 and 121:
On the other hand, we can use a hig
Page 122 and 123:
(ev* (Q (lambda (x) (+ x 1)))) # >
Page 124 and 125:
(term ’lam (lambda (x) (if (equal
Page 126 and 127:
a message: there is no guarantee th
Page 128 and 129:
(! (self) 3) (?) =⇒ 1 (?? odd?) =
Page 130 and 131:
(define new-server (spawn (lambda (
Page 132 and 133:
The abstraction shown in this secti
Page 134 and 135:
Erlang Termite List length (µs) (
Page 136 and 137:
Page 138 and 139:
page of j contains the URL of the p
Page 140 and 141:
4. Solution The failed attempts abo
Page 142 and 143:
· ; · ; · :: Store × Frame Stac
Page 144 and 145:
logically creates a sub-session of
Page 146 and 147:
on this work, including Ryan Culpep
Page 148 and 149:
ing application operation. 1 As a r
Page 150 and 151:
such as image glyphs corresponding
Page 152 and 153:
Phone For clarity, this code pr
Page 154 and 155:
A. Porting TinyScheme to Qualcomm B
Page 156 and 157:
Page 158 and 159:
ware installers have to install any
Page 160 and 161:
defines a module named circle-lib i
Page 162 and 163:
Figure 2. Sometimes special cases a
Page 164 and 165:
Considering all of these issues tog
show all

2006 Scheme and Functional Programming Papers, University of

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?