# embedding_metadata

key: chroma:document
string_value:
st-pair ?x (3))  ? Exer cise 4.63.   The following data base (see Genesis 4) traces the genealogy of the descendants of Ada back to Adam, by way of Cain: (son Adam Cain)   (son Cain Enoch)   (son Enoch Irad)   (son Irad Mehujael)   (son Mehujael Methushael)   (son Methushael Lamech)   (wife Lamech Ada)   (son Ada Jabal)   (son Ada Jubal)   Formulate rules such as “If S is the son of F, and F is the son of G, then S is the grandson of G” and “If W is the wife of M, and S is the son of W, then S is the son of M” (which was supposedly more true in biblical times than today) that will enable the query system to find the grandson of Cain; the sons of Lamech; the grandsons of Methushael. (See exercise 4.69 for some rules to deduce more complicated relationships.) 4.4.2  How the Query System W orksIn section 4.4.4  we will present an implementation of the query interpreter as a collection of procedures. In this section we give an overview that explains the general structure of the system independent of low-level imp


key: chroma:document
string_value:
lementation details. After describing the implementation of the interpreter , we will be in a position to understand some of its limitations and some of the subtle ways in which the query language's logical operations differ from the operations of mathematical logic. It should be apparent that the query evaluator must perform some kind of search in order to match queries against facts and rules in the data base. One way to do this would be to implement the query system as a nondeterministic program, using the amb evaluator of section 4.3 (see exercise 4.78). Another possibility is to manage the search with the aid of streams. Our implementation follows this second approach. The query system is or ganized around two central operations called pattern matching  and unification . We first describe pattern matching and explain how this operation, together with the or ganization of information in terms of streams of frames, enables us to implement both simple and compound queries. We next discuss unification, a gen


key: chroma:document
string_value:
eralization of pattern matching needed to implement rules. Finally , we show how the entire query interpreter fits together through a procedure that classifies expressions in a manner analogous to the way eval  classifies expressions for the interpreter described in section 4.1. Pattern matching A pattern matcher  is a program that tests whether some datum fits a specified pattern. For example, the data list ((a b) c (a b))  matches the pattern (?x c ?x)  with the pattern variable ?x bound to (a b) . The same data list matches the pattern (?x ?y ?z)  with ?x and ?z both bound to (a b) and ?y bound to c. It also matches the pattern ((?x ?y) c (?x ?y)) with ?x bound to a and ?y bound to b. However , it does not match the pattern (?x a ?y) , since that pattern specifies a list whose second element is the symbol a.The pattern matcher used by the query system takes as inputs a pattern, a datum, and a frame  that specifies bindings for various pattern variables. It checks whether the datum matches the pattern in a 


key: chroma:document
string_value:
way that is consistent with the bindings already in the frame. If so, it returns the given frame augmented by any bindings that may have been determined by the match. Otherwise, it indicates that the match has failed. For example, using the pattern (?x ?y ?x)  to match (a b a)  given an empty frame will return a frame specifying that ?x is bound to a and ?y is bound to b. Trying the match with the same pattern, the same datum, and a frame specifying that ?y is bound to a will fail. Trying the match with the same pattern, the same datum, and a frame in which ?y is bound to b and ?x is unbound will return the given frame augmented by a binding of ?x to a. The pattern matcher is all the mechanism that is needed to process simple queries that don't involve rules. For instance, to process the query (job ?x (computer programmer))   we scan through all assertions in the data base and select those that match the pattern with respect to an initially empty frame. For each match we find, we use the frame returned by the


key: chroma:document
string_value:
 match to instantiate the pattern with a value for ?x. Streams of frames The testing of patterns against frames is or ganized through the use of streams. Given a single frame, the matching process runs through the data- base entries one by one. For each data-base entry , the matcher generates either a special symbol indicating that the match has failed or an extension to the frame. The results for all the data-base entries are collected into a stream, which is passed through a filter to weed out the failures. The result is a stream of all the frames that extend the given frame via a match to some assertion in the data base.67 In our system, a query takes an input stream of frames and performs the above matching operation for every frame in the stream, as indicated in figure 4.4. That is, for each frame in the input stream, the query generates anew stream consisting of all extensions to that frame by matches to assertions in the data base. All these streams are then combined to form one huge stream, which cont


key: chroma:document
string_value:
ains all possible extensions of every frame in the input stream. This stream is the output of the query . Figur e 4.4:   A query processes a stream of frames. To answer a simple query , we use the query with an input stream consisting of a single empty frame. The resulting output stream contains all extensions to the empty frame (that is, all answers to our query). This stream of frames is then used to generate a stream of copies of the original query pattern with the variables instantiated by the values in each frame, and this is the stream that is finally printed. Compound queries The real elegance of the stream-of-frames implementation is evident when we deal with compound queries. The processing of compound queries makes use of the ability of our matcher to demand that a match be consistent with a specified frame. For example, to handle the and of two queries, such as (and (can-do-job ?x (computer programmer trainee))        (job ?person ?x))   (informally , “Find all people who can do the job of a comput


key: chroma:document
string_value:
er programmer trainee”), we first find all entries that match the pattern (can-do-job ?x (computer programmer trainee))  This produces a stream of frames, each of which contains a binding for ?x. Then for each frame in the stream we find all entries that match (job ?person ?x)   in a way that is consistent with the given binding for ?x. Each such match will produce a frame containing bindings for ?x and ?person . The and of two queries can be viewed as a series combination of the two component queries, as shown in figure 4.5. The frames that pass through the first query filter are filtered and further extended by the second query . Figur e 4.5:   The and combination of two queries is produced by operating on the stream of frames in series. Figure 4.6 shows the analogous method for computing the or of two queries as a parallel combination of the two component queries. The input stream of frames is extended separately by each query . The two resulting streams are then mer ged to produce the final output stream.


key: chroma:document
string_value:
 Figur e 4.6:   The or combination of two queries is produced by operating on the stream of frames in parallel and mer ging the results.Even from this high-level description, it is apparent that the processing of compound queries can be slow . For example, since a query may produce more than one output frame for each input frame, and each query in an and gets its input frames from the previous query , an and query could, in the worst case, have to perform a number of matches that is exponential in the number of queries (see exercise 4.76).68 Though systems for handling only simple queries are quite practical, dealing with complex queries is extremely dif ficult.69 From the stream-of-frames viewpoint, the not of some query acts as a filter that removes all frames for which the query can be satisfied. For instance, given the pattern (not (job ?x (computer programmer)))   we attempt, for each frame in the input stream, to produce extension frames that satisfy (job ?x (computer programmer)) . We remove from the i


key: chroma:document
string_value:
nput stream all frames for which such extensions exist. The result is a stream consisting of only those frames in which the binding for ?x does not satisfy (job ?x (computer programmer)) . For example, in processing the query (and (supervisor ?x ?y)        (not (job ?x (computer programmer))))   the first clause will generate frames with bindings for ?x and ?y. The not clause will then filter these by removing all frames in which the binding for ?x satisfies the restriction that ?x is a computer programmer .70 The lisp-value  special form is implemented as a similar filter on frame streams. We use each frame in the stream to instantiate any variables in the pattern, then apply the Lisp predicate. We remove from the input stream all frames for which the predicate fails. Unification In order to handle rules in the query language, we must be able to find the rules whose conclusions match a given query pattern. Rule conclusions are like assertions except that they can contain variables, so we will need ageneraliz


key: chroma:document
string_value:
ation of pattern matching – called unification  – in which both the “pattern” and the “datum” may contain variables. A unifier takes two patterns, each containing constants and variables, and determines whether it is possible to assign values to the variables that will make the two patterns equal. If so, it returns a frame containing these bindings. For example, unifying (?x a ?y)  and (?y ?z a)  will specify a frame in which ?x, ?y, and ?z must all be bound to a. On the other hand, unifying (?x ?y a)  and (?x b ?y)  will fail, because there is no value for ? y that can make the two patterns equal. (For the second elements of the patterns to be equal, ?y would have to be b; however , for the third elements to be equal, ?y would have to be a.) The unifier used in the query system, like the pattern matcher , takes a frame as input and performs unifications that are consistent with this frame. The unification algorithm is the most technically dif ficult part of the query system. With complex patterns, performing


key: chroma:document
string_value:
 unification may seem to require deduction. To unify (?x ?x)  and ((a ?y c) (a b ?z)) , for example, the algorithm must infer that ?x should be (a b c) , ?y should be b, and ?z should be c. We may think of this process as solving a set of equations among the pattern components. In general, these are simultaneous equations, which may require substantial manipulation to solve.71 For example, unifying (?x ?x)  and ((a ?y c) (a b ?z))  may be thought of as specifying the simultaneous equations ?x  =  (a ?y c)   ?x  =  (a b ?z)   These equations imply that (a ?y c)  =  (a b ?z)   which in turn implies that a  =  a, ?y  =  b, c  =  ?z,   and hence that?x  =  (a b c)   In a successful pattern match, all pattern variables become bound, and the values to which they are bound contain only constants. This is also true of all the examples of unification we have seen so far . In general, however , a successful unification may not completely determine the variable values; some variables may remain unbound and others may be


key: chroma:document
string_value:
 bound to values that contain variables. Consider the unification of (?x a)  and ((b ?y) ?z) . We can deduce that ? x = (b ?y)  and a = ?z, but we cannot further solve for ?x or ?y. The unification doesn't fail, since it is certainly possible to make the two patterns equal by assigning values to ?x and ?y. Since this match in no way restricts the values ?y can take on, no binding for ?y is put into the result frame. The match does, however , restrict the value of ?x. Whatever value ?y has, ?x must be (b ?y) . A binding of ?x to the pattern (b ?y)  is thus put into the frame. If a value for ?y is later determined and added to the frame (by a pattern match or unification that is required to be consistent with this frame), the previously bound ?x will refer to this value.72 Applying rules Unification is the key to the component of the query system that makes inferences from rules. T o see how this is accomplished, consider processing a query that involves applying a rule, such as (lives-near ?x (Hacker Alyssa P)


key: chroma:document
string_value:
)   To process this query , we first use the ordinary pattern-match procedure described above to see if there are any assertions in the data base that match this pattern. (There will not be any in this case, since our data base includes no direct assertions about who lives near whom.) The next step is to attempt to unify the query pattern with the conclusion of each rule. We find that the pattern unifies with the conclusion of the rule (rule (lives-near ?person-1 ?person-2)         (and (address ?person-1 (?town . ?rest-1))             (address ?person-2 (?town . ?rest-2))              (not (same ?person-1 ?person-2))))   resulting in a frame specifying that ?person-2  is bound to (Hacker Alyssa P) and that ?x should be bound to (have the same value as) ?person-1 . Now , relative to this frame, we evaluate the compound query given by the body of the rule. Successful matches will extend this frame by providing a binding for ?person-1 , and consequently a value for ?x, which we can use to instantiate the origin


key: chroma:document
string_value:
al query pattern. In general, the query evaluator uses the following method to apply a rule when trying to establish a query pattern in a frame that specifies bindings for some of the pattern variables: Unify the query with the conclusion of the rule to form, if successful, an extension of the original frame. Relative to the extended frame, evaluate the query formed by the body of the rule. Notice how similar this is to the method for applying a procedure in the eval /apply  evaluator for Lisp: Bind the procedure's parameters to its ar guments to form a frame that extends the original procedure environment. Relative to the extended environment, evaluate the expression formed by the body of the procedure. The similarity between the two evaluators should come as no surprise. Just as procedure definitions are the means of abstraction in Lisp, rule definitions are the means of abstraction in the query language. In each case, we unwind the abstraction by creating appropriate bindings and evaluating the rule or pro


key: chroma:document
string_value:
cedure body relative to these. Simple queriesWe saw earlier in this section how to evaluate simple queries in the absence of rules. Now that we have seen how to apply rules, we can describe how to evaluate simple queries by using both rules and assertions. Given the query pattern and a stream of frames, we produce, for each frame in the input stream, two streams: a stream of extended frames obtained by matching the pattern against all assertions in the data base (using the pattern matcher), and a stream of extended frames obtained by applying all possible rules (using the unifier).73 Appending these two streams produces a stream that consists of all the ways that the given pattern can be satisfied consistent with the original frame. These streams (one for each frame in the input stream) are now all combined to form one lar ge stream, which therefore consists of all the ways that any of the frames in the original input stream can be extended to produce a match with the given pattern. The query evaluator and th


key: chroma:document
string_value:
e driver loop Despite the complexity of the underlying matching operations, the system is organized much like an evaluator for any language. The procedure that coordinates the matching operations is called qeval , and it plays a role analogous to that of the eval  procedure for Lisp. Qeval  takes as inputs a query and a stream of frames. Its output is a stream of frames, corresponding to successful matches to the query pattern, that extend some frame in the input stream, as indicated in figure 4.4. Like eval , qeval classifies the dif ferent types of expressions (queries) and dispatches to an appropriate procedure for each. There is a procedure for each special form (and, or, not, and lisp-value ) and one for simple queries. The driver loop, which is analogous to the driver-loop  procedure for the other evaluators in this chapter , reads queries from the terminal. For each query , it calls qeval  with the query and a stream that consists of a single empty frame. This will produce the stream of all possible ma


key: chroma:document
string_value:
tches (all possible extensions to the empty frame). For each frame in the resultingstream, it instantiates the original query using the values of the variables found in the frame. This stream of instantiated queries is then printed.74 The driver also checks for the special command assert! , which signals that the input is not a query but rather an assertion or rule to be added to the data base. For instance, (assert! (job (Bitdiddle Ben) (computer wizard)))   (assert! (rule (wheel ?person)                  (and (supervisor ?middle-manager ?person)                       (supervisor ?x ?middle-manager))))   4.4.3  Is Logic Pr ogramming Mathematical Logic? The means of combination used in the query language may at first seem identical to the operations and, or, and not of mathematical logic, and the application of query-language rules is in fact accomplished through a legitimate method of inference.75 This identification of the query language with mathematical logic is not really valid, though, because the query


key: chroma:document
string_value:
 language provides a contr ol structur e that interprets the logical statements procedurally . We can often take advantage of this control structure. For example, to find all of the supervisors of programmers we could formulate a query in either of two logically equivalent forms: (and (job ?x (computer programmer))        (supervisor ?x ?y))   or (and (supervisor ?x ?y)        (job ?x (computer programmer)))   If a company has many more supervisors than programmers (the usual case), it is better to use the first form rather than the second because the data base must be scanned for each intermediate result (frame) produced by the first clause of the and.The aim of logic programming is to provide the programmer with techniques for decomposing a computational problem into two separate problems: “what” is to be computed, and “how” this should be computed. This is accomplished by selecting a subset of the statements of mathematical logic that is powerful enough to be able to describe anything one might want to com


key: chroma:document
string_value:
pute, yet weak enough to have a controllable procedural interpretation. The intention here is that, on the one hand, a program specified in a logic programming language should be an ef fective program that can be carried out by a computer . Control (“how” to compute) is effected by using the order of evaluation of the language. We should be able to arrange the order of clauses and the order of subgoals within each clause so that the computation is done in an order deemed to be ef fective and ef ficient. At the same time, we should be able to view the result of the computation (“what” to compute) as a simple consequence of the laws of logic. Our query language can be regarded as just such a procedurally interpretable subset of mathematical logic. An assertion represents a simple fact (an atomic proposition). A rule represents the implication that the rule conclusion holds for those cases where the rule body holds. A rule has a natural procedural interpretation: T o establish the conclusion of the rule, establi


key: chroma:document
string_value:
sh the body of the rule. Rules, therefore, specify computations. However , because rules can also be regarded as statements of mathematical logic, we can justify any “inference” accomplished by a logic program by asserting that the same result could be obtained by working entirely within mathematical logic.76 Infinite loops A consequence of the procedural interpretation of logic programs is that it is possible to construct hopelessly inef ficient programs for solving certain problems. An extreme case of inef ficiency occurs when the system falls into infinite loops in making deductions. As a simple example, suppose we are setting up a data base of famous marriages, including (assert! (married Minnie Mickey))  If we now ask (married Mickey ?who)   we will get no response, because the system doesn't know that if A is married to B, then B is married to A. So we assert the rule (assert! (rule (married ?x ?y)                  (married ?y ?x)))   and again query (married Mickey ?who)   Unfortunately , this will dri


key: chroma:document
string_value:
ve the system into an infinite loop, as follows: The system finds that the married  rule is applicable; that is, the rule conclusion (married ?x ?y)  successfully unifies with the query pattern (married Mickey ?who)  to produce a frame in which ?x is bound to Mickey  and ?y is bound to ?who . So the interpreter proceeds to evaluate the rule body (married ?y ?x)  in this frame – in ef fect, to process the query (married ?who Mickey) . One answer appears directly as an assertion in the data base: (married Minnie Mickey) . The married  rule is also applicable, so the interpreter again evaluates the rule body , which this time is equivalent to (married Mickey ? who) . The system is now in an infinite loop. Indeed, whether the system will find the simple answer (married Minnie Mickey)  before it goes into the loop depends on implementation details concerning the order in which the system checks the items in the data base. This is a very simple example of the kinds of loops that can occur . Collections of interrela


key: chroma:document
string_value:
ted rules can lead to loops that are much harder to anticipate, and the appearance of a loop can depend on the order of clauses in an and (see exercise 4.64) or on low-level details concerning the order in which the system processes queries.77Problems with not Another quirk in the query system concerns not. Given the data base of section 4.4.1 , consider the following two queries: (and (supervisor ?x ?y)        (not (job ?x (computer programmer))))   (and (not (job ?x (computer programmer)))        (supervisor ?x ?y))   These two queries do not produce the same result. The first query begins by finding all entries in the data base that match (supervisor ?x ?y) , and then filters the resulting frames by removing the ones in which the value of ?x satisfies (job ?x (computer programmer)) . The second query begins by filtering the incoming frames to remove those that can satisfy (job ?x (computer programmer)) . Since the only incoming frame is empty , it checks the data base to see if there are any patterns that 


key: chroma:document
string_value:
satisfy (job ?x (computer programmer)) . Since there generally are entries of this form, the not clause filters out the empty frame and returns an empty stream of frames. Consequently , the entire compound query returns an empty stream. The trouble is that our implementation of not really is meant to serve as a filter on values for the variables. If a not clause is processed with a frame in which some of the variables remain unbound (as does ?x in the example above), the system will produce unexpected results. Similar problems occur with the use of lisp-value  – the Lisp predicate can't work if some of its arguments are unbound. See exercise 4.77. There is also a much more serious way in which the not of the query language dif fers from the not of mathematical logic. In logic, we interpret the statement “not P” to mean that P is not true. In the query system, however , “not P” means that P is not deducible from the knowledge in the data base. For example, given the personnel data base of section 4.4.1 , the s


key: chroma:document
string_value:
ystem would happily deduce all sorts of not statements, such as that Ben Bitdiddle is not a baseball fan, that it is not raining outside, and that 2 + 2 is not 4.78 In other words, the not of logic programming languages reflects theso-called closed world assumption  that all relevant information has been included in the data base.79 Exer cise 4.64.   Louis Reasoner mistakenly deletes the outranked-by  rule (section 4.4.1 ) from the data base. When he realizes this, he quickly reinstalls it. Unfortunately , he makes a slight change in the rule, and types it in as (rule (outranked-by ?staff-person ?boss)         (or (supervisor ?staff-person ?boss)             (and (outranked-by ?middle-manager ?boss)                  (supervisor ?staff-person ?middle-manager))))   Just after Louis types this information into the system, DeW itt Aull comes by to find out who outranks Ben Bitdiddle. He issues the query (outranked-by (Bitdiddle Ben) ?who)   After answering, the system goes into an infinite loop. Explain why . Exe


key: chroma:document
string_value:
r cise 4.65.   Cy D. Fect, looking forward to the day when he will rise in the or ganization, gives a query to find all the wheels (using the wheel  rule of section 4.4.1 ): (wheel ?who)   To his surprise, the system responds ;;; Query results:   (wheel (Warbucks Oliver))   (wheel (Bitdiddle Ben))   (wheel (Warbucks Oliver))   (wheel (Warbucks Oliver))   (wheel (Warbucks Oliver))   Why is Oliver W arbucks listed four times?Exer cise 4.66.   Ben has been generalizing the query system to provide statistics about the company . For example, to find the total salaries of all the computer programmers one will be able to say (sum ?amount        (and (job ?x (computer programmer))             (salary ?x ?amount)))   In general, Ben's new system allows expressions of the form (accumulation-function < variable >                         < query pattern >)  where accumulation-function  can be things like sum, average , or maximum . Ben reasons that it should be a cinch to implement this. He will simply feed the query pat


key: chroma:document
string_value:
tern to qeval . This will produce a stream of frames. He will then pass this stream through a mapping function that extracts the value of the designated variable from each frame in the stream and feed the resulting stream of values to the accumulation function. Just as Ben completes the implementation and is about to try it out, Cy walks by , still puzzling over the wheel  query result in exercise 4.65. When Cy shows Ben the system's response, Ben groans, “Oh, no, my simple accumulation scheme won't work!” What has Ben just realized? Outline a method he can use to salvage the situation. Exer cise 4.67.   Devise a way to install a loop detector in the query system so as to avoid the kinds of simple loops illustrated in the text and in exercise 4.64. The general idea is that the system should maintain some sort of history of its current chain of deductions and should not begin processing a query that it is already working on. Describe what kind of information (patterns and frames) is included in this history , 


key: chroma:document
string_value:
and how the check should be made. (After you study the details of the query-system implementation in section 4.4.4 , you may want to modify the system to include your loop detector .)Exer cise 4.68.   Define rules to implement the reverse  operation of exercise 2.18, which returns a list containing the same elements as a given list in reverse order . (Hint: Use append-to-form .) Can your rules answer both (reverse (1 2 3) ?x)  and (reverse ?x (1 2 3))  ? Exer cise 4.69.   Beginning with the data base and the rules you formulated in exercise 4.63, devise a rule for adding “greats” to a grandson relationship. This should enable the system to deduce that Irad is the great- grandson of Adam, or that Jabal and Jubal are the great-great-great-great- great-grandsons of Adam. (Hint: Represent the fact about Irad, for example, as ((great grandson) Adam Irad) . Write rules that determine if a list ends in the word grandson . Use this to express a rule that allows one to derive the relationship ((great . ?rel) ?x ?y) , 


key: chroma:document
string_value:
where ?rel  is a list ending in grandson .) Check your rules on queries such as ((great grandson) ?g ?ggs)  and (?relationship Adam Irad) . 4.4.4  Implementing the Query System Section 4.4.2  described how the query system works. Now we fill in the details by presenting a complete implementation of the system. 4.4.4.1  The Driver Loop and Instantiation The driver loop for the query system repeatedly reads input expressions. If the expression is a rule or assertion to be added to the data base, then the information is added. Otherwise the expression is assumed to be a query . The driver passes this query to the evaluator qeval  together with an initial frame stream consisting of a single empty frame. The result of the evaluation is a stream of frames generated by satisfying the query with variable values found in the data base. These frames are used to form a new stream consisting of copies of the original query in which the variables are instantiated with values supplied by the stream of frames, and this fina


key: chroma:document
string_value:
l stream is printed at the terminal: (define input-prompt ";;; Query input:")   (define output-prompt ";;; Query results:")   (define (query-driver-loop)    (prompt-for-input input-prompt)     (let ((q (query-syntax-process (read))))       (cond ((assertion-to-be-added? q)              (add-rule-or-assertion! (add-assertion-body q))              (newline)              (display "Assertion added to data base.")              (query-driver-loop))             (else              (newline)              (display output-prompt)              (display-stream               (stream-map                (lambda (frame)                  (instantiate q                               frame                               (lambda (v f)                                 (contract-question-mark v))))                (qeval q (singleton-stream '()))))              (query-driver-loop)))))   Here, as in the other evaluators in this chapter , we use an abstract syntax for the expressions of the query language. The implementation of the expr


key: chroma:document
string_value:
ession syntax, including the predicate assertion-to-be-added?  and the selector add-assertion-body , is given in section 4.4.4.7 . Add-rule-or- assertion!  is defined in section 4.4.4.5 . Before doing any processing on an input expression, the driver loop transforms it syntactically into a form that makes the processing more efficient. This involves changing the representation of pattern variables. When the query is instantiated, any variables that remain unbound are transformed back to the input representation before being printed. These transformations are performed by the two procedures query-syntax- process  and contract-question-mark  (section  4.4.4.7 ). To instantiate an expression, we copy it, replacing any variables in the expression by their values in a given frame. The values are themselves instantiated, since they could contain variables (for example, if ?x in exp isbound to ?y as the result of unification and ?y is in turn bound to 5). The action to take if a variable cannot be instantiated is gi


key: chroma:document
string_value:
ven by a procedural argument to instantiate . (define (instantiate exp frame unbound-var-handler)     (define (copy exp)       (cond ((var? exp)              (let ((binding (binding-in-frame exp frame)))                (if binding                    (copy (binding-value binding))                    (unbound-var-handler exp frame))))             ((pair? exp)              (cons (copy (car exp)) (copy (cdr exp))))             (else exp)))     (copy exp))   The procedures that manipulate bindings are defined in section 4.4.4.8 . 4.4.4.2  The Evaluator The qeval  procedure, called by the query-driver-loop , is the basic evaluator of the query system. It takes as inputs a query and a stream of frames, and it returns a stream of extended frames. It identifies special forms by a data-directed dispatch using get and put, just as we did in implementing generic operations in chapter 2. Any query that is not identified as a special form is assumed to be a simple query , to be processed by simple-query . (define (qeval qu


key: chroma:document
string_value:
ery frame-stream)     (let ((qproc (get (type query) 'qeval)))       (if qproc           (qproc (contents query) frame-stream)           (simple-query query frame-stream))))   Type  and contents , defined in section 4.4.4.7 , implement the abstract syntax of the special forms. Simple queriesThe simple-query  procedure handles simple queries. It takes as ar guments a simple query (a pattern) together with a stream of frames, and it returns the stream formed by extending each frame by all data-base matches of the query . (define (simple-query query-pattern frame-stream)     (stream-flatmap      (lambda (frame)        (stream-append-delayed         (find-assertions query-pattern frame)         (delay (apply-rules query-pattern frame))))      frame-stream))   For each frame in the input stream, we use find-assertions (section 4.4.4.3 ) to match the pattern against all assertions in the data base, producing a stream of extended frames, and we use apply-rules (section 4.4.4.4 ) to apply all possible rules, producin


key: chroma:document
string_value:
g another stream of extended frames. These two streams are combined (using stream-append- delayed , section 4.4.4.6 ) to make a stream of all the ways that the given pattern can be satisfied consistent with the original frame (see exercise 4.71). The streams for the individual input frames are combined using stream-flatmap  (section 4.4.4.6 ) to form one lar ge stream of all the ways that any of the frames in the original input stream can be extended to produce a match with the given pattern. Compound queries And queries are handled as illustrated in figure 4.5 by the conjoin procedure. Conjoin  takes as inputs the conjuncts and the frame stream and returns the stream of extended frames. First, conjoin  processes the stream of frames to find the stream of all possible frame extensions that satisfy the first query in the conjunction. Then, using this as the new frame stream, it recursively applies conjoin  to the rest of the queries. (define (conjoin conjuncts frame-stream)     (if (empty-conjunction? conjunct


key: chroma:document
string_value:
s)         frame-stream        (conjoin (rest-conjuncts conjuncts)                  (qeval (first-conjunct conjuncts)                         frame-stream))))   The expression (put 'and 'qeval conjoin)   sets up qeval  to dispatch to conjoin  when an and form is encountered. Or queries are handled similarly , as shown in figure 4.6. The output streams for the various disjuncts of the or are computed separately and mer ged using the interleave-delayed  procedure from section 4.4.4.6 . (See exercises 4.71 and 4.72.) (define (disjoin disjuncts frame-stream)     (if (empty-disjunction? disjuncts)         the-empty-stream         (interleave-delayed          (qeval (first-disjunct disjuncts) frame-stream)          (delay (disjoin (rest-disjuncts disjuncts)                          frame-stream)))))   (put 'or 'qeval disjoin)   The predicates and selectors for the syntax of conjuncts and disjuncts are given in section 4.4.4.7 . Filters Not is handled by the method outlined in section 4.4.2 . We attempt to extend ea


key: chroma:document
string_value:
ch frame in the input stream to satisfy the query being negated, and we include a given frame in the output stream only if it cannot be extended. (define (negate operands frame-stream)     (stream-flatmap      (lambda (frame)        (if (stream-null? (qeval (negated-query operands)                                (singleton-stream frame)))            (singleton-stream frame)            the-empty-stream))      frame-stream))   (put 'not 'qeval negate)   Lisp-value  is a filter similar to not. Each frame in the stream is used to instantiate the variables in the pattern, the indicated predicate is applied, and the frames for which the predicate returns false are filtered out of the input stream. An error results if there are unbound pattern variables. (define (lisp-value call frame-stream)     (stream-flatmap      (lambda (frame)        (if (execute             (instantiate              call              frame              (lambda (v f)                (error "Unknown pat var -- LISP-VALUE" v))))            (singl


key: chroma:document
string_value:
eton-stream frame)            the-empty-stream))      frame-stream))   (put 'lisp-value 'qeval lisp-value)   Execute , which applies the predicate to the ar guments, must eval  the predicate expression to get the procedure to apply . However , it must not evaluate the ar guments, since they are already the actual ar guments, not expressions whose evaluation (in Lisp) will produce the ar guments. Note that execute  is implemented using eval  and apply  from the underlying Lisp system. (define (execute exp)     (apply (eval (predicate exp) user-initial-environment)            (args exp)))   The always-true  special form provides for a query that is always satisfied. It ignores its contents (normally empty) and simply passes through all theframes in the input stream. Always-true  is used by the rule-body  selector (section 4.4.4.7 ) to provide bodies for rules that were defined without bodies (that is, rules whose conclusions are always satisfied). (define (always-true ignore frame-stream) frame-stream)   (put '


key: chroma:document
string_value:
always-true 'qeval always-true)   The selectors that define the syntax of not and lisp-value  are given in section 4.4.4.7 . 4.4.4.3  Finding Assertions by Pattern Matching Find-assertions , called by simple-query  (section 4.4.4.2 ), takes as input a pattern and a frame. It returns a stream of frames, each extending the given one by a data-base match of the given pattern. It uses fetch- assertions  (section 4.4.4.5 ) to get a stream of all the assertions in the data base that should be checked for a match against the pattern and the frame. The reason for fetch-assertions  here is that we can often apply simple tests that will eliminate many of the entries in the data base from the pool of candidates for a successful match. The system would still work if we eliminated fetch-assertions  and simply checked a stream of all assertions in the data base, but the computation would be less ef ficient because we would need to make many more calls to the matcher . (define (find-assertions pattern frame)     (stream-fla


key: chroma:document
string_value:
tmap (lambda (datum)                       (check-an-assertion datum pattern frame))                     (fetch-assertions pattern frame)))   Check-an-assertion  takes as ar guments a pattern, a data object (assertion), and a frame and returns either a one-element stream containing the extended frame or the-empty-stream  if the match fails. (define (check-an-assertion assertion query-pat query-frame)     (let ((match-result            (pattern-match query-pat assertion query-frame)))       (if (eq? match-result 'failed)          the-empty-stream           (singleton-stream match-result))))   The basic pattern matcher returns either the symbol failed  or an extension of the given frame. The basic idea of the matcher is to check the pattern against the data, element by element, accumulating bindings for the pattern variables. If the pattern and the data object are the same, the match succeeds and we return the frame of bindings accumulated so far . Otherwise, if the pattern is a variable we extend the current f


key: chroma:document
string_value:
rame by binding the variable to the data, so long as this is consistent with the bindings already in the frame. If the pattern and the data are both pairs, we (recursively) match the car of the pattern against the car of the data to produce a frame; in this frame we then match the cdr of the pattern against the cdr of the data. If none of these cases are applicable, the match fails and we return the symbol failed . (define (pattern-match pat dat frame)     (cond ((eq? frame 'failed) 'failed)           ((equal? pat dat) frame)           ((var? pat) (extend-if-consistent pat dat frame))           ((and (pair? pat) (pair? dat))            (pattern-match (cdr pat)                           (cdr dat)                           (pattern-match (car pat)                                          (car dat)                                          frame)))           (else 'failed)))   Here is the procedure that extends a frame by adding a new binding, if this is consistent with the bindings already in the frame: (define 


key: chroma:document
string_value:
(extend-if-consistent var dat frame)     (let ((binding (binding-in-frame var frame)))       (if binding           (pattern-match (binding-value binding) dat frame)           (extend var dat frame))))   If there is no binding for the variable in the frame, we simply add the binding of the variable to the data. Otherwise we match, in the frame, thedata against the value of the variable in the frame. If the stored value contains only constants, as it must if it was stored during pattern matching by extend-if-consistent , then the match simply tests whether the stored and new values are the same. If so, it returns the unmodified frame; if not, it returns a failure indication. The stored value may , however , contain pattern variables if it was stored during unification (see section 4.4.4.4 ). The recursive match of the stored pattern against the new data will add or check bindings for the variables in this pattern. For example, suppose we have a frame in which ?x is bound to (f ?y)  and ?y is unbound, and we wis


key: chroma:document
string_value:
h to augment this frame by a binding of ?x to (f b) . We look up ?x and find that it is bound to (f ?y) . This leads us to match (f ?y)  against the proposed new value (f b)  in the same frame. Eventually this match extends the frame by adding a binding of ?y to b. ?X remains bound to (f ? y). We never modify a stored binding and we never store more than one binding for a given variable. The procedures used by extend-if-consistent  to manipulate bindings are defined in section 4.4.4.8 . Patterns with dotted tails If a pattern contains a dot followed by a pattern variable, the pattern variable matches the rest of the data list (rather than the next element of the data list), just as one would expect with the dotted-tail notation described in exercise 2.20. Although the pattern matcher we have just implemented doesn't look for dots, it does behave as we want. This is because the Lisp read  primitive, which is used by query-driver-loop  to read the query and represent it as a list structure, treats dots in a spe


key: chroma:document
string_value:
cial way . When read  sees a dot, instead of making the next item be the next element of a list (the car of a cons  whose cdr will be the rest of the list) it makes the next item be the cdr of the list structure. For example, the list structure produced by read  for the pattern (computer ?type)  could be constructed by evaluating the expression (cons 'computer (cons '?type '())) , and that for (computer . ?type)  could be constructed by evaluating the expression (cons 'computer '?type) .Thus, as pattern-match  recursively compares cars and cdrs of a data list and a pattern that had a dot, it eventually matches the variable after the dot (which is a cdr of the pattern) against a sublist of the data list, binding the variable to that list. For example, matching the pattern (computer . ? type)  against (computer programmer trainee)  will match ?type  against the list (programmer trainee) . 4.4.4.4  Rules and Unification Apply-rules  is the rule analog of find-assertions  (section 4.4.4.3 ). It takes as input a p


key: chroma:document
string_value:
attern and a frame, and it forms a stream of extension frames by applying rules from the data base. Stream-flatmap  maps apply- a-rule  down the stream of possibly applicable rules (selected by fetch- rules , section 4.4.4.5 ) and combines the resulting streams of frames. (define (apply-rules pattern frame)     (stream-flatmap (lambda (rule)                       (apply-a-rule rule pattern frame))                     (fetch-rules pattern frame)))   Apply-a-rule  applies rules using the method outlined in section 4.4.2 . It first augments its ar gument frame by unifying the rule conclusion with the pattern in the given frame. If this succeeds, it evaluates the rule body in this new frame. Before any of this happens, however , the program renames all the variables in the rule with unique new names. The reason for this is to prevent the variables for dif ferent rule applications from becoming confused with each other . For instance, if two rules both use a variable named ?x, then each one may add a binding for ?


key: chroma:document
string_value:
x to the frame when it is applied. These two ?x's have nothing to do with each other , and we should not be fooled into thinking that the two bindings must be consistent. Rather than rename variables, we could devise a more clever environment structure; however , the renaming approach we have chosen here is the most straightforward, even if not the most ef ficient. (See exercise 4.79.) Here is the apply-a-rule procedure:(define (apply-a-rule rule query-pattern query-frame)     (let ((clean-rule (rename-variables-in rule)))       (let ((unify-result              (unify-match query-pattern                           (conclusion clean-rule)                           query-frame)))         (if (eq? unify-result 'failed)             the-empty-stream             (qeval (rule-body clean-rule)                    (singleton-stream unify-result))))))   The selectors rule-body  and conclusion  that extract parts of a rule are defined in section 4.4.4.7 . We generate unique variable names by associating a unique identifie


key: chroma:document
string_value:
r (such as a number) with each rule application and combining this identifier with the original variable names. For example, if the rule-application identifier is 7, we might change each ?x in the rule to ?x-7  and each ?y in the rule to ? y-7. (Make-new-variable  and new-rule-application-id  are included with the syntax procedures in section 4.4.4.7 .) (define (rename-variables-in rule)     (let ((rule-application-id (new-rule-application-id)))       (define (tree-walk exp)         (cond ((var? exp)                (make-new-variable exp rule-application-id))               ((pair? exp)                (cons (tree-walk (car exp))                      (tree-walk (cdr exp))))               (else exp)))       (tree-walk rule)))   The unification algorithm is implemented as a procedure that takes as inputs two patterns and a frame and returns either the extended frame or the symbol failed . The unifier is like the pattern matcher except that it is symmetrical – variables are allowed on both sides of the match. Unif


key: chroma:document
string_value:
y- match  is basically the same as pattern-match , except that there is extracode (marked “ ***” below) to handle the case where the object on the right side of the match is a variable. (define (unify-match p1 p2 frame)     (cond ((eq? frame 'failed) 'failed)           ((equal? p1 p2) frame)           ((var? p1) (extend-if-possible p1 p2 frame))           ((var? p2) (extend-if-possible p2 p1 frame))  ; ***          ((and (pair? p1) (pair? p2))            (unify-match (cdr p1)                         (cdr p2)                         (unify-match (car p1)                                      (car p2)                                      frame)))           (else 'failed)))   In unification, as in one-sided pattern matching, we want to accept a proposed extension of the frame only if it is consistent with existing bindings. The procedure extend-if-possible  used in unification is the same as the extend-if-consistent  used in pattern matching except for two special checks, marked “ ***” in the program below . In t


key: chroma:document
string_value:
he first case, if the variable we are trying to match is not bound, but the value we are trying to match it with is itself a (dif ferent) variable, it is necessary to check to see if the value is bound, and if so, to match its value. If both parties to the match are unbound, we may bind either to the other . The second check deals with attempts to bind a variable to a pattern that includes that variable. Such a situation can occur whenever a variable is repeated in both patterns. Consider , for example, unifying the two patterns (?x ?x)  and (?y <expression involving ?y>) in a frame where both ?x and ?y are unbound. First ?x is matched against ?y, making a binding of ?x to ?y. Next, the same ?x is matched against the given expression involving ?y. Since ?x is already bound to ?y, this results in matching ?y against the expression. If we think of the unifier as finding a set of values for the pattern variables that make the patterns the same, then these patterns imply instructions to find a ?y such that ?y is 


key: chroma:document
string_value:
equal to the expression involving ?y. There is no general method for solving such equations, so we reject suchbindings; these cases are recognized by the predicate depends-on? .80 On the other hand, we do not want to reject attempts to bind a variable to itself. For example, consider unifying (?x ?x)  and (?y ?y) . The second attempt to bind ?x to ?y matches ?y (the stored value of ?x) against ?y (the new value of ?x). This is taken care of by the equal?  clause of unify-match . (define (extend-if-possible var val frame)     (let ((binding (binding-in-frame var frame)))       (cond (binding              (unify-match               (binding-value binding) val frame))             ((var? val)                      ; ***             (let ((binding (binding-in-frame val frame)))                (if binding                    (unify-match                     var (binding-value binding) frame)                    (extend var val frame))))             ((depends-on? val var frame)     ; ***             'failed)           


key: chroma:document
string_value:
  (else (extend var val frame)))))   Depends-on?  is a predicate that tests whether an expression proposed to be the value of a pattern variable depends on the variable. This must be done relative to the current frame because the expression may contain occurrences of a variable that already has a value that depends on our test variable. The structure of depends-on?  is a simple recursive tree walk in which we substitute for the values of variables whenever necessary . (define (depends-on? exp var frame)     (define (tree-walk e)       (cond ((var? e)              (if (equal? var e)                  true                  (let ((b (binding-in-frame e frame)))                    (if b                        (tree-walk (binding-value b))                        false))))            ((pair? e)              (or (tree-walk (car e))                  (tree-walk (cdr e))))             (else false)))     (tree-walk exp))   4.4.4.5  Maintaining the Data Base One important problem in designing logic programming languages i


key: chroma:document
string_value:
s that of arranging things so that as few irrelevant data-base entries as possible will be examined in checking a given pattern. In our system, in addition to storing all assertions in one big stream, we store all assertions whose cars are constant symbols in separate streams, in a table indexed by the symbol. To fetch an assertion that may match a pattern, we first check to see if the car of the pattern is a constant symbol. If so, we return (to be tested using the matcher) all the stored assertions that have the same car. If the pattern's car is not a constant symbol, we return all the stored assertions. Cleverer methods could also take advantage of information in the frame, or try also to optimize the case where the car of the pattern is not a constant symbol. We avoid building our criteria for indexing (using the car, handling only the case of constant symbols) into the program; instead we call on predicates and selectors that embody our criteria. (define THE-ASSERTIONS the-empty-stream)   (define (fetch-


key: chroma:document
string_value:
assertions pattern frame)     (if (use-index? pattern)         (get-indexed-assertions pattern)         (get-all-assertions)))   (define (get-all-assertions) THE-ASSERTIONS)   (define (get-indexed-assertions pattern)     (get-stream (index-key-of pattern) 'assertion-stream))   Get-stream  looks up a stream in the table and returns an empty stream if nothing is stored there. (define (get-stream key1 key2)     (let ((s (get key1 key2)))      (if s s the-empty-stream)))   Rules are stored similarly , using the car of the rule conclusion. Rule conclusions are arbitrary patterns, however , so they dif fer from assertions in that they can contain variables. A pattern whose car is a constant symbol can match rules whose conclusions start with a variable as well as rules whose conclusions have the same car. Thus, when fetching rules that might match a pattern whose car is a constant symbol we fetch all rules whose conclusions start with a variable as well as those whose conclusions have the same car as the pattern. F


key: chroma:document
string_value:
or this purpose we store all rules whose conclusions start with a variable in a separate stream in our table, indexed by the symbol ?. (define THE-RULES the-empty-stream)   (define (fetch-rules pattern frame)     (if (use-index? pattern)         (get-indexed-rules pattern)         (get-all-rules)))   (define (get-all-rules) THE-RULES)   (define (get-indexed-rules pattern)     (stream-append      (get-stream (index-key-of pattern) 'rule-stream)      (get-stream '? 'rule-stream)))   Add-rule-or-assertion!  is used by query-driver-loop  to add assertions and rules to the data base. Each item is stored in the index, if appropriate, and in a stream of all assertions or rules in the data base. (define (add-rule-or-assertion! assertion)     (if (rule? assertion)         (add-rule! assertion)         (add-assertion! assertion)))   (define (add-assertion! assertion)     (store-assertion-in-index assertion)     (let ((old-assertions THE-ASSERTIONS))       (set! THE-ASSERTIONS             (cons-stream assertion old-asse


key: chroma:document
string_value:
rtions))       'ok))  (define (add-rule! rule)     (store-rule-in-index rule)     (let ((old-rules THE-RULES))       (set! THE-RULES (cons-stream rule old-rules))       'ok))   To actually store an assertion or a rule, we check to see if it can be indexed. If so, we store it in the appropriate stream. (define (store-assertion-in-index assertion)     (if (indexable? assertion)         (let ((key (index-key-of assertion)))           (let ((current-assertion-stream                  (get-stream key 'assertion-stream)))             (put key                  'assertion-stream                  (cons-stream assertion                               current-assertion-stream))))))   (define (store-rule-in-index rule)     (let ((pattern (conclusion rule)))       (if (indexable? pattern)           (let ((key (index-key-of pattern)))             (let ((current-rule-stream                    (get-stream key 'rule-stream)))               (put key                    'rule-stream                    (cons-stream rule            


key: chroma:document
string_value:
                     current-rule-stream)))))))   The following procedures define how the data-base index is used. A pattern (an assertion or a rule conclusion) will be stored in the table if it starts with a variable or a constant symbol. (define (indexable? pat)     (or (constant-symbol? (car pat))         (var? (car pat))))  The key under which a pattern is stored in the table is either ? (if it starts with a variable) or the constant symbol with which it starts. (define (index-key-of pat)     (let ((key (car pat)))       (if (var? key) '? key)))   The index will be used to retrieve items that might match a pattern if the pattern starts with a constant symbol. (define (use-index? pat)     (constant-symbol? (car pat)))   Exer cise 4.70.   What is the purpose of the let bindings in the procedures add-assertion!  and add-rule!  ? What would be wrong with the following implementation of add-assertion!  ? Hint: Recall the definition of the infinite stream of ones in section 3.5.2 : (define ones (cons-stream 1 o


key: chroma:document
string_value:
nes)) . (define (add-assertion! assertion)     (store-assertion-in-index assertion)     (set! THE-ASSERTIONS           (cons-stream assertion THE-ASSERTIONS))     'ok)  4.4.4.6  Str eam Operations The query system uses a few stream operations that were not presented in chapter 3. Stream-append-delayed  and interleave-delayed  are just like stream- append  and interleave  (section 3.5.3 ), except that they take a delayed argument (like the integral  procedure in section 3.5.4 ). This postpones looping in some cases (see exercise 4.71). (define (stream-append-delayed s1 delayed-s2)     (if (stream-null? s1)         (force delayed-s2)        (cons-stream          (stream-car s1)          (stream-append-delayed (stream-cdr s1) delayed-s2))))   (define (interleave-delayed s1 delayed-s2)     (if (stream-null? s1)         (force delayed-s2)         (cons-stream          (stream-car s1)          (interleave-delayed (force delayed-s2)                              (delay (stream-cdr s1))))))   Stream-flatmap , which is


key: chroma:document
string_value:
 used throughout the query evaluator to map a procedure over a stream of frames and combine the resulting streams of frames, is the stream analog of the flatmap  procedure introduced for ordinary lists in section 2.2.3 . Unlike ordinary flatmap , however , we accumulate the streams with an interleaving process, rather than simply appending them (see exercises 4.72 and  4.73). (define (stream-flatmap proc s)     (flatten-stream (stream-map proc s)))   (define (flatten-stream stream)     (if (stream-null? stream)         the-empty-stream         (interleave-delayed          (stream-car stream)          (delay (flatten-stream (stream-cdr stream))))))   The evaluator also uses the following simple procedure to generate a stream consisting of a single element: (define (singleton-stream x)     (cons-stream x the-empty-stream))   4.4.4.7  Query Syntax Pr ocedur es Type  and contents , used by qeval  (section 4.4.4.2 ), specify that a special form is identified by the symbol in its car. They are the same as the type-


key: chroma:document
string_value:
 tag and contents  procedures in section 2.4.2 , except for the error message.(define (type exp)     (if (pair? exp)         (car exp)         (error "Unknown expression TYPE" exp)))   (define (contents exp)     (if (pair? exp)         (cdr exp)         (error "Unknown expression CONTENTS" exp)))   The following procedures, used by query-driver-loop  (in section 4.4.4.1 ), specify that rules and assertions are added to the data base by expressions of the form (assert! < rule-or-assertion >): (define (assertion-to-be-added? exp)     (eq? (type exp) 'assert!))   (define (add-assertion-body exp)     (car (contents exp)))   Here are the syntax definitions for the and, or, not, and lisp-value  special forms (section 4.4.4.2 ): (define (empty-conjunction? exps) (null? exps))   (define (first-conjunct exps) (car exps))   (define (rest-conjuncts exps) (cdr exps))   (define (empty-disjunction? exps) (null? exps))   (define (first-disjunct exps) (car exps))   (define (rest-disjuncts exps) (cdr exps))   (define (negated


key: chroma:document
string_value:
-query exps) (car exps))   (define (predicate exps) (car exps))   (define (args exps) (cdr exps))   The following three procedures define the syntax of rules: (define (rule? statement)     (tagged-list? statement 'rule))   (define (conclusion rule) (cadr rule))   (define (rule-body rule)     (if (null? (cddr rule))        '(always-true)         (caddr rule)))   Query-driver-loop  (section 4.4.4.1 ) calls query-syntax-process  to transform pattern variables in the expression, which have the form ?symbol , into the internal format (? symbol) . That is to say , a pattern such as (job ? x ?y)  is actually represented internally by the system as (job (? x) (? y)). This increases the ef ficiency of query processing, since it means that the system can check to see if an expression is a pattern variable by checking whether the car of the expression is the symbol ?, rather than having to extract characters from the symbol. The syntax transformation is accomplished by the following procedure:81 (define (query-syntax-pr


key: chroma:document
string_value:
ocess exp)     (map-over-symbols expand-question-mark exp))   (define (map-over-symbols proc exp)     (cond ((pair? exp)            (cons (map-over-symbols proc (car exp))                  (map-over-symbols proc (cdr exp))))           ((symbol? exp) (proc exp))           (else exp)))   (define (expand-question-mark symbol)     (let ((chars (symbol->string symbol)))       (if (string=? (substring chars 0 1) "?")           (list '?                 (string->symbol                  (substring chars 1 (string-length chars))))           symbol)))   Once the variables are transformed in this way , the variables in a pattern are lists starting with ?, and the constant symbols (which need to be recognized for data-base indexing, section 4.4.4.5 ) are just the symbols. (define (var? exp)     (tagged-list? exp '?))   (define (constant-symbol? exp) (symbol? exp))  Unique variables are constructed during rule application (in section 4.4.4.4 ) by means of the following procedures. The unique identifier for a rule applicati


key: chroma:document
string_value:
on is a number , which is incremented each time a rule is applied. (define rule-counter 0)   (define (new-rule-application-id)     (set! rule-counter (+ 1 rule-counter))     rule-counter)   (define (make-new-variable var rule-application-id)     (cons '? (cons rule-application-id (cdr var))))   When query-driver-loop  instantiates the query to print the answer , it converts any unbound pattern variables back to the right form for printing, using (define (contract-question-mark variable)     (string->symbol      (string-append "?"        (if (number? (cadr variable))            (string-append (symbol->string (caddr variable))                           "-"                           (number->string (cadr variable)))            (symbol->string (cadr variable))))))   4.4.4.8  Frames and Bindings Frames are represented as lists of bindings, which are variable-value pairs: (define (make-binding variable value)     (cons variable value))   (define (binding-variable binding)     (car binding))   (define (binding-value


key: chroma:document
string_value:
 binding)     (cdr binding))   (define (binding-in-frame variable frame)     (assoc variable frame))   (define (extend variable value frame)     (cons (make-binding variable value) frame))  Exer cise 4.71.   Louis Reasoner wonders why the simple-query  and disjoin  procedures (section 4.4.4.2 ) are implemented using explicit delay operations, rather than being defined as follows: (define (simple-query query-pattern frame-stream)     (stream-flatmap      (lambda (frame)        (stream-append (find-assertions query-pattern frame)                       (apply-rules query-pattern frame)))      frame-stream))   (define (disjoin disjuncts frame-stream)     (if (empty-disjunction? disjuncts)         the-empty-stream         (interleave          (qeval (first-disjunct disjuncts) frame-stream)          (disjoin (rest-disjuncts disjuncts) frame-stream))))   Can you give examples of queries where these simpler definitions would lead to undesirable behavior? Exer cise 4.72.   Why do disjoin  and stream-flatmap  interleav


key: chroma:document
string_value:
e the streams rather than simply append them? Give examples that illustrate why interleaving works better . (Hint: Why did we use interleave  in section 3.5.3 ?) Exer cise 4.73.   Why does flatten-stream  use delay  explicitly? What would be wrong with defining it as follows: (define (flatten-stream stream)     (if (stream-null? stream)         the-empty-stream         (interleave          (stream-car stream)          (flatten-stream (stream-cdr stream)))))   Exer cise 4.74.   Alyssa P . Hacker proposes to use a simpler version of stream-flatmap  in negate , lisp-value , and find-assertions . She observes that the procedure that is mapped over the frame stream in thesecases always produces either the empty stream or a singleton stream, so no interleaving is needed when combining these streams. a. Fill in the missing expressions in Alyssa's program. (define (simple-stream-flatmap proc s)     (simple-flatten (stream-map proc s)))     (define (simple-flatten stream)     (stream-map < ??>                (stream-f


key: chroma:document
string_value:
ilter < ??> stream)))   b. Does the query system's behavior change if we change it in this way? Exer cise 4.75.   Implement for the query language a new special form called unique . Unique  should succeed if there is precisely one item in the data base satisfying a specified query . For example, (unique (job ?x (computer wizard)))   should print the one-item stream (unique (job (Bitdiddle Ben) (computer wizard)))   since Ben is the only computer wizard, and (unique (job ?x (computer programmer)))   should print the empty stream, since there is more than one computer programmer . Moreover , (and (job ?x ?j) (unique (job ?anyone ?j)))   should list all the jobs that are filled by only one person, and the people who fill them. There are two parts to implementing unique . The first is to write a procedure that handles this special form, and the second is to make qeval dispatch to that procedure. The second part is trivial, since qeval  does itsdispatching in a data-directed way . If your procedure is called uniqu


key: chroma:document
string_value:
ely- asserted , all you need to do is (put 'unique 'qeval uniquely-asserted)   and qeval  will dispatch to this procedure for every query whose type  (car) is the symbol unique . The real problem is to write the procedure uniquely-asserted . This should take as input the contents  (cdr) of the unique  query , together with a stream of frames. For each frame in the stream, it should use qeval  to find the stream of all extensions to the frame that satisfy the given query . Any stream that does not have exactly one item in it should be eliminated. The remaining streams should be passed back to be accumulated into one big stream that is the result of the unique  query . This is similar to the implementation of the not special form. Test your implementation by forming a query that lists all people who supervise precisely one person. Exer cise 4.76.   Our implementation of and as a series combination of queries (figure 4.5) is elegant, but it is inef ficient because in processing the second query of the and we mus


key: chroma:document
string_value:
t scan the data base for each frame produced by the first query . If the data base has N elements, and a typical query produces a number of output frames proportional to N (say N/k), then scanning the data base for each frame produced by the first query will require N2/k calls to the pattern matcher . Another approach would be to process the two clauses of the and separately , then look for all pairs of output frames that are compatible. If each query produces N/k output frames, then this means that we must perform N2/k2 compatibility checks – a factor of k fewer than the number of matches required in our current method. Devise an implementation of and that uses this strategy . You must implement a procedure that takes two frames as inputs, checks whether the bindings in the frames are compatible, and, if so, produces a frame that merges the two sets of bindings. This operation is similar to unification.Exer cise 4.77.   In section 4.4.3  we saw that not and lisp-value  can cause the query language to give “w


key: chroma:document
string_value:
rong” answers if these filtering operations are applied to frames in which variables are unbound. Devise a way to fix this shortcoming. One idea is to perform the filtering in a “delayed” manner by appending to the frame a “promise” to filter that is fulfilled only when enough variables have been bound to make the operation possible. We could wait to perform filtering until all other operations have been performed. However , for ef ficiency's sake, we would like to perform filtering as soon as possible so as to cut down on the number of intermediate frames generated. Exer cise 4.78.   Redesign the query language as a nondeterministic program to be implemented using the evaluator of section 4.3, rather than as a stream process. In this approach, each query will produce a single answer (rather than the stream of all answers) and the user can type try-again  to see more answers. You should find that much of the mechanism we built in this section is subsumed by nondeterministic search and backtracking. You will p


key: chroma:document
string_value:
robably also find, however , that your new query language has subtle differences in behavior from the one implemented here. Can you find examples that illustrate this dif ference? Exer cise 4.79.   When we implemented the Lisp evaluator in section 4.1, we saw how to use local environments to avoid name conflicts between the parameters of procedures. For example, in evaluating (define (square x)     (* x x))   (define (sum-of-squares x y)     (+ (square x) (square y)))   (sum-of-squares 3 4)   there is no confusion between the x in square  and the x in sum-of-squares , because we evaluate the body of each procedure in an environment that is specially constructed to contain bindings for the local variables. In the query system, we used a dif ferent strategy to avoid name conflicts in applying rules. Each time we apply a rule we rename the variables with new names that are guaranteed to be unique. The analogous strategy for the Lispevaluator would be to do away with local environments and simply rename the varia


key: chroma:document
string_value:
bles in the body of a procedure each time we apply the procedure. Implement for the query language a rule-application method that uses environments rather than renaming. See if you can build on your environment structure to create constructs in the query language for dealing with lar ge systems, such as the rule analog of block-structured procedures. Can you relate any of this to the problem of making deductions in a context (e.g., “If I supposed that P were true, then I would be able to deduce A and B.”) as a method of problem solving? (This problem is open-ended. A good answer is probably worth a Ph.D.) 58 Logic programming has grown out of a long history of research in automatic theorem proving. Early theorem-proving programs could accomplish very little, because they exhaustively searched the space of possible proofs. The major breakthrough that made such a search plausible was the discovery in the early 1960s of the unification algorithm  and the resolution principle  (Robinson 1965). Resolution was used


key: chroma:document
string_value:
, for example, by Green and Raphael (1968) (see also Green 1969) as the basis for a deductive question-answering system. During most of this period, researchers concentrated on algorithms that are guaranteed to find a proof if one exists. Such algorithms were difficult to control and to direct toward a proof. Hewitt (1969) recognized the possibility of mer ging the control structure of a programming language with the operations of a logic-manipulation system, leading to the work in automatic search mentioned in section 4.3.1  (footnote 47). At the same time that this was being done, Colmerauer , in Marseille, was developing rule-based systems for manipulating natural language (see Colmerauer et al. 1973). He invented a programming language called Prolog for representing those rules. Kowalski (1973; 1979), in Edinbur gh, recognized that execution of a Prolog program could be interpreted as proving theorems (using a proof technique called linear Horn-clause resolution). The mer ging of the last two strands led 


key: chroma:document
string_value:
to the logic- programming movement. Thus, in assigning credit for the development of logic programming, the French can point to Prolog's genesis at the University of Marseille, while the British can highlight the work at the University of Edinbur gh. According to people at MIT, logic programming was developed by these groups in an attempt to figure out what Hewitt was talking about in his brilliant but impenetrable Ph.D. thesis. For a history of logic programming, see Robinson 1983. 59 To see the correspondence between the rules and the procedure, let x in the procedure (where x is nonempty) correspond to (cons u v)  in the rule. Then z in the rule corresponds to the append  of (cdr x)  and y. 60 This certainly does not relieve the user of the entire problem of how to compute the answer . There are many dif ferent mathematically equivalent sets of rules for formulating the append  relation, only some of which can be turned into ef fective devices for computing in any direction. In addition, sometimes “what is


key: chroma:document
string_value:
” information gives no clue “how to” compute an answer . For example, consider the problem of computing the y such that y2 = x. 61 Interest in logic programming peaked during the early 80s when the Japanese government began an ambitious project aimed at building superfast computers optimized to run logic programminglanguages. The speed of such computers was to be measured in LIPS (Logical Inferences Per Second) rather than the usual FLOPS (FLoating-point Operations Per Second). Although the project succeeded in developing hardware and software as originally planned, the international computer industry moved in a dif ferent direction. See Feigenbaum and Shrobe 1993 for an overview evaluation of the Japanese project. The logic programming community has also moved on to consider relational programming based on techniques other than simple pattern matching, such as the ability to deal with numerical constraints such as the ones illustrated in the constraint-propagation system of section 3.3.5 . 62 This uses the d


key: chroma:document
string_value:
otted-tail notation introduced in exercise 2.20. 63 Actually , this description of not is valid only for simple cases. The real behavior of not is more complex. We will examine not's peculiarities in sections 4.4.2  and 4.4.3 . 64 Lisp-value  should be used only to perform an operation not provided in the query language. In particular , it should not be used to test equality (since that is what the matching in the query language is designed to do) or inequality (since that can be done with the same  rule shown below). 65 Notice that we do not need same  in order to make two things be the same: W e just use the same pattern variable for each – in ef fect, we have one thing instead of two things in the first place. For example, see ?town  in the lives-near  rule and ?middle-manager  in the wheel  rule below . Same  is useful when we want to force two things to be dif ferent, such as ?person-1  and ?person-2  in the lives-near  rule. Although using the same pattern variable in two parts of a query forces the sam


key: chroma:document
string_value:
e value to appear in both places, using dif ferent pattern variables does not force dif ferent values to appear . (The values assigned to dif ferent pattern variables may be the same or dif ferent.) 66 We will also allow rules without bodies, as in same , and we will interpret such a rule to mean that the rule conclusion is satisfied by any values of the variables. 67 Because matching is generally very expensive, we would like to avoid applying the full matcher to every element of the data base. This is usually arranged by breaking up the process into a fast, coarse match and the final match. The coarse match filters the data base to produce a small set of candidates for the final match. With care, we can arrange our data base so that some of the work of coarse matching can be done when the data base is constructed rather then when we want to select the candidates. This is called indexing  the data base. There is a vast technology built around data-base- indexing schemes. Our implementation, described in sect


key: chroma:document
string_value:
ion 4.4.4 , contains a simple-minded form of such an optimization. 68 But this kind of exponential explosion is not common in and queries because the added conditions tend to reduce rather than expand the number of frames produced. 69 There is a lar ge literature on data-base-management systems that is concerned with how to handle complex queries ef ficiently . 70 There is a subtle dif ference between this filter implementation of not and the usual meaning of not in mathematical logic. See section 4.4.3 . 71 In one-sided pattern matching, all the equations that contain pattern variables are explicit and already solved for the unknown (the pattern variable).72 Another way to think of unification is that it generates the most general pattern that is a specialization of the two input patterns. That is, the unification of (?x a)  and ((b ?y) ?z)  is ((b ? y) a) , and the unification of (?x a ?y)  and (?y ?z a) , discussed above, is (a a a) . For our implementation, it is more convenient to think of the result of 


key: chroma:document
string_value:
unification as a frame rather than a pattern. 73 Since unification is a generalization of matching, we could simplify the system by using the unifier to produce both streams. Treating the easy case with the simple matcher , however , illustrates how matching (as opposed to full-blown unification) can be useful in its own right. 74 The reason we use streams (rather than lists) of frames is that the recursive application of rules can generate infinite numbers of values that satisfy a query . The delayed evaluation embodied in streams is crucial here: The system will print responses one by one as they are generated, regardless of whether there are a finite or infinite number of responses. 75 That a particular method of inference is legitimate is not a trivial assertion. One must prove that if one starts with true premises, only true conclusions can be derived. The method of inference represented by rule applications is modus ponens , the familiar method of inference that says that if A is true and A implies B  i


key: chroma:document
string_value:
s true, then we may conclude that B is true. 76 We must qualify this statement by agreeing that, in speaking of the “inference” accomplished by a logic program, we assume that the computation terminates. Unfortunately , even this qualified statement is false for our implementation of the query language (and also false for programs in Prolog and most other current logic programming languages) because of our use of not and lisp- value . As we will describe below , the not implemented in the query language is not always consistent with the not of mathematical logic, and lisp-value  introduces additional complications. We could implement a language consistent with mathematical logic by simply removing not and lisp-value  from the language and agreeing to write programs using only simple queries, and, and or. However , this would greatly restrict the expressive power of the language. One of the major concerns of research in logic programming is to find ways to achieve more consistency with mathematical logic witho


key: chroma:document
string_value:
ut unduly sacrificing expressive power . 77 This is not a problem of the logic but one of the procedural interpretation of the logic provided by our interpreter . We could write an interpreter that would not fall into a loop here. For example, we could enumerate all the proofs derivable from our assertions and our rules in a breadth-first rather than a depth-first order . However , such a system makes it more dif ficult to take advantage of the order of deductions in our programs. One attempt to build sophisticated control into such a program is described in deKleer et al. 1977. Another technique, which does not lead to such serious control problems, is to put in special knowledge, such as detectors for particular kinds of loops (exercise 4.67). However , there can be no general scheme for reliably preventing a system from going down infinite paths in performing deductions. Imagine a diabolical rule of the form “T o show P(x) is true, show that P(f(x)) is true,” for some suitably chosen function f. 78 Conside


key: chroma:document
string_value:
r the query (not (baseball-fan (Bitdiddle Ben))) . The system finds that (baseball- fan (Bitdiddle Ben))  is not in the data base, so the empty frame does not satisfy the pattern and is not filtered out of the initial stream of frames. The result of the query is thus the empty frame, which is used to instantiate the input query to produce (not (baseball-fan (Bitdiddle Ben))) . 79 A discussion and justification of this treatment of not can be found in the article by Clark (1978).80 In general, unifying ?y with an expression involving ?y would require our being able to find a fixed point of the equation ?y = <expression involving ?y>. It is sometimes possible to syntactically form an expression that appears to be the solution. For example, ?y  =  (f ?y)  seems to have the fixed point (f (f (f ... ))) , which we can produce by beginning with the expression (f ?y)  and repeatedly substituting (f ?y)  for ?y. Unfortunately , not every such equation has a meaningful fixed point. The issues that arise here are simil


key: chroma:document
string_value:
ar to the issues of manipulating infinite series in mathematics. For example, we know that 2 is the solution to the equation y = 1 + y/2. Beginning with the expression 1 + y/2 and repeatedly substituting 1 + y/2 for y gives which leads to However , if we try the same manipulation beginning with the observation that - 1 is the solution to the equation y = 1 + 2y, we obtain which leads to Although the formal manipulations used in deriving these two equations are identical, the first result is a valid assertion about infinite series but the second is not. Similarly , for our unification results, reasoning with an arbitrary syntactically constructed expression may lead to errors. 81 Most Lisp systems give the user the ability to modify the ordinary read  procedure to perform such transformations by defining reader macr o characters . Quoted expressions are already handled in this way: The reader automatically translates 'expression  into (quote expression)  before the evaluator sees it. We could arrange for ?expr


key: chroma:document
string_value:
ession  to be transformed into (? expression)  in the same way; however , for the sake of clarity we have included the transformation procedure here explicitly . Expand-question-mark  and contract-question-mark  use several procedures with string  in their names. These are Scheme primitives.Chapter 5 Computing with Register Machines My aim is to show that the heavenly machine is not a kind of divine, live being, but a kind of clockwork (and he who believes that a clock has soul attributes the maker's glory to the work), insofar as nearly all the manifold motions are caused by a most simple and material force, just as all motions of the clock are caused by a single weight. Johannes Kepler (letter to Herwart von Hohenbur g, 1605) We began this book by studying processes and by describing processes in terms of procedures written in Lisp. To explain the meanings of these procedures, we used a succession of models of evaluation: the substitution model of chapter 1, the environment model of chapter 3, and the metac


key: chroma:document
string_value:
ircular evaluator of chapter 4. Our examination of the metacircular evaluator , in particular , dispelled much of the mystery of how Lisp-like languages are interpreted. But even the metacircular evaluator leaves important questions unanswered, because it fails to elucidate the mechanisms of control in a Lisp system. For instance, the evaluator does not explain how the evaluation of a subexpression manages to return a value to the expression that uses this value, nor does the evaluator explain how some recursive procedures generate iterative processes (that is, are evaluated using constant space) whereas other recursive procedures generate recursive processes. These questions remain unanswered because the metacircular evaluator is itself a Lisp program and hence inherits the control structure of the underlying Lisp system. In order to provide a more complete description of the control structure of the Lisp evaluator , we must work at a more primitive level than Lisp itself. In this chapter we will describe pr


key: chroma:document
string_value:
ocesses in terms of the step-by-step operation of a traditional computer . Such a computer , or register machine , sequentially executes instructions  that manipulate the contents of a fixed set of storage elements called registers . A typical register -machine instruction applies a primitive operation to the contents of some registers and assignsthe result to another register . Our descriptions of processes executed by register machines will look very much like “machine-language” programs for traditional computers. However , instead of focusing on the machine language of any particular computer , we will examine several Lisp procedures and design a specific register machine to execute each procedure. Thus, we will approach our task from the perspective of a hardware architect rather than that of a machine-language computer programmer . In designing register machines, we will develop mechanisms for implementing important programming constructs such as recursion. We will also present a language for describing 


key: chroma:document
string_value:
designs for register machines. In section 5.2 we will implement a Lisp program that uses these descriptions to simulate the machines we design. Most of the primitive operations of our register machines are very simple. For example, an operation might add the numbers fetched from two registers, producing a result to be stored into a third register . Such an operation can be performed by easily described hardware. In order to deal with list structure, however , we will also use the memory operations car, cdr, and cons , which require an elaborate storage-allocation mechanism. In section 5.3 we study their implementation in terms of more elementary operations. In section 5.4, after we have accumulated experience formulating simple procedures as register machines, we will design a machine that carries out the algorithm described by the metacircular evaluator of section 4.1. This will fill in the gap in our understanding of how Scheme expressions are interpreted, by providing an explicit model for the mechanisms o


key: chroma:document
string_value:
f control in the evaluator . In section 5.5 we will study a simple compiler that translates Scheme programs into sequences of instructions that can be executed directly with the registers and operations of the evaluator register machine.5.1  Designing Register Machines To design a register machine, we must design its data paths  (registers and operations) and the contr oller  that sequences these operations. To illustrate the design of a simple register machine, let us examine Euclid's Algorithm, which is used to compute the greatest common divisor (GCD) of two integers. As we saw in section 1.2.5 , Euclid's Algorithm can be carried out by an iterative process, as specified by the following procedure: (define (gcd a b)     (if (= b 0)         a        (gcd b (remainder a b))))   A machine to carry out this algorithm must keep track of two numbers, a and b, so let us assume that these numbers are stored in two registers with those names. The basic operations required are testing whether the contents of registe


key: chroma:document
string_value:
r b is zero and computing the remainder of the contents of register a divided by the contents of register b. The remainder operation is a complex process, but assume for the moment that we have a primitive device that computes remainders. On each cycle of the GCD algorithm, the contents of register a must be replaced by the contents of register b, and the contents of b must be replaced by the remainder of the old contents of a divided by the old contents of b. It would be convenient if these replacements could be done simultaneously , but in our model of register machines we will assume that only one register can be assigned a new value at each step. To accomplish the replacements, our machine will use a third “temporary” register , which we call t. (First the remainder will be placed in t, then the contents of b will be placed in a, and finally the remainder stored in t will be placed in b.) We can illustrate the registers and operations required for this machine by using the data-path diagram shown in figur


key: chroma:document
string_value:
e 5.1. In this diagram, the registers ( a, b, and t) are represented by rectangles. Each way to assign a value to a register is indicated by an arrow with an X behind the head, pointing from the source of data to the register . We can think of the X as a button that, when pushed, allows the value at the source to “flow” into the designated register . The label next to each button is the name we will use to refer to the button. The names are arbitrary , and can be chosen to have mnemonic value (for example, a<-b  denotes pushing the button that assigns the contents of register b to register a). The source of data for a register can be another register (as in the a<-b assignment), an operation result (as in the t<-r  assignment), or a constant (a built-in value that cannot be changed, represented in a data-path diagram by a triangle containing the constant).An operation that computes a value from constants and the contents of registers is represented in a data-path diagram by a trapezoid containing a name for t


key: chroma:document
string_value:
he operation. For example, the box marked rem in figure 5.1 represents an operation that computes the remainder of the contents of the registers a and b to which it is attached. Arrows (without buttons) point from the input registers and constants to the box, and arrows connect the operation's output value to registers. A test is represented by a circle containing a name for the test. For example, our GCD machine has an operation that tests whether the contents of register b is zero. A test also has arrows from its input registers and constants, but it has no output arrows; its value is used by the controller rather than by the data paths. Overall, the data-path diagram shows the registers and operations that are required for the machine and how they must be connected. If we view the arrows as wires and the X buttons as switches, the data-path diagram is very like the wiring diagram for a machine that could be constructed from electrical components. Figur e 5.1:   Data paths for a GCD machine. In order for th


key: chroma:document
string_value:
e data paths to actually compute GCDs, the buttons must be pushed in the correct sequence. We will describe this sequence in terms of a controller diagram, as illustrated in figure 5.2. The elements of the controller diagram indicate how the data- path components should be operated. The rectangular boxes in the controller diagram identify data-path buttons to be pushed, and the arrows describe the sequencing from one step to the next. The diamond in the diagram represents a decision. One of the two sequencing arrows will be followed, depending on the value of the data-path test identified in the diamond. We can interpret the controller in terms of a physical analogy: Think of the diagram as a maze in which a marble is rolling. When the marble rolls into a box, it pushes the data-path button that is named by the box. When the marble rolls into a decision node (such as the test for b = 0), it leaves the node on the path determined by the result of the indicated test. Taken together , the data paths and the cont


key: chroma:document
string_value:
roller completely describe a machine for computing GCDs. We start the controller (the rolling marble) at the place marked start , after placing numbers in registers a and b. When the controller reaches done , we will find the value of the GCD in register a. Figur e 5.2:   Controller for a GCD machine.Exer cise 5.1.   Design a register machine to compute factorials using the iterative algorithm specified by the following procedure. Draw data-path and controller diagrams for this machine. (define (factorial n)     (define (iter product counter)       (if (> counter n)           product           (iter (* counter product)                 (+ counter 1))))     (iter 1 1))   5.1.1  A Language for Describing Register Machines Data-path and controller diagrams are adequate for representing simple machines such as GCD, but they are unwieldy for describing lar ge machines such as a Lisp interpreter . To make it possible to deal with complex machines, we will create a language that presents, in textual form, all the inf


key: chroma:document
string_value:
ormation given by the data-path and controller diagrams. We will start with a notation that directly mirrors the diagrams. We define the data paths of a machine by describing the registers and the operations. To describe a register , we give it a name and specify the buttons that control assignment to it. We give each of these buttons a name and specify the source of the data that enters the register under the button's control. (The source is a register , a constant, or an operation.) To describe an operation, we give it a name and specify its inputs (registers or constants). We define the controller of a machine as a sequence of instructions  together with labels that identify entry points  in the sequence. An instruction is one of the following:The name of a data-path button to push to assign a value to a register . (This corresponds to a box in the controller diagram.) A test  instruction, that performs a specified test. A conditional branch ( branch  instruction) to a location indicated by a controller la


key: chroma:document
string_value:
bel, based on the result of the previous test. (The test and branch together correspond to a diamond in the controller diagram.) If the test is false, the controller should continue with the next instruction in the sequence. Otherwise, the controller should continue with the instruction after the label. An unconditional branch ( goto  instruction) naming a controller label at which to continue execution. The machine starts at the beginning of the controller instruction sequence and stops when execution reaches the end of the sequence. Except when a branch changes the flow of control, instructions are executed in the order in which they are listed. (data-paths    (registers     ((name a)      (buttons ((name a<-b) (source (register b)))))     ((name b)      (buttons ((name b<-t) (source (register t)))))     ((name t)      (buttons ((name t<-r) (source (operation rem))))))      (operations     ((name rem)      (inputs (register a) (register b)))     ((name =)      (inputs (register b) (constant 0)))))     (cont


key: chroma:document
string_value:
roller    test-b                           ; label     (test =)                       ; test     (branch (label gcd-done))      ; conditional branch      (t<-r)                         ; button push      (a<-b)                         ; button push      (b<-t)                         ; button push      (goto (label test-b))          ; unconditional branch    gcd-done)                        ; label Figur e 5.3:   A specification of the GCD machine.Figure 5.3 shows the GCD machine described in this way . This example only hints at the generality of these descriptions, since the GCD machine is a very simple case: Each register has only one button, and each button and test is used only once in the controller . Unfortunately , it is dif ficult to read such a description. In order to understand the controller instructions we must constantly refer back to the definitions of the button names and the operation names, and to understand what the buttons do we may have to refer to the definitions of the operation names.


key: chroma:document
string_value:
 We will thus transform our notation to combine the information from the data-path and controller descriptions so that we see it all together . To obtain this form of description, we will replace the arbitrary button and operation names by the definitions of their behavior . That is, instead of saying (in the controller) “Push button t<-r ” and separately saying (in the data paths) “Button t<-r  assigns the value of the rem operation to register t” and “The rem operation's inputs are the contents of registers a and b,” we will say (in the controller) “Push the button that assigns to register t the value of the rem operation on the contents of registers a and b.” Similarly , instead of saying (in the controller) “Perform the = test” and separately saying (in the data paths) “The = test operates on the contents of register b and the constant 0,” we will say “Perform the = test on the contents of register b and the constant 0.” We will omit the data-path description, leaving only the controller sequence. Thus, t


key: chroma:document
string_value:
he GCD machine is described as follows: (controller    test-b     (test (op =) (reg b) (const 0))      (branch (label gcd-done))      (assign t (op rem) (reg a) (reg b))      (assign a (reg b))      (assign b (reg t))      (goto (label test-b))    gcd-done)   This form of description is easier to read than the kind illustrated in figure 5.3, but it also has disadvantages: It is more verbose for lar ge machines, because complete descriptions of the data- path elements are repeated whenever the elements are mentioned in the controller instruction sequence. (This is not a problem in the GCD example, because each operation and button is used only once.) Moreover , repeating the data-path descriptions obscures the actual data-path structure of the machine; it is not obvious for a lar ge machine how many registers, operations, and buttons there are and how they are interconnected.Because the controller instructions in a machine definition look like Lisp expressions, it is easy to for get that they are not arbitrary


key: chroma:document
string_value:
 Lisp expressions. They can notate only legal machine operations. For example, operations can operate directly only on constants and the contents of registers, not on the results of other operations. In spite of these disadvantages, we will use this register -machine language throughout this chapter , because we will be more concerned with understanding controllers than with understanding the elements and connections in data paths. We should keep in mind, however , that data-path design is crucial in designing real machines. Exer cise 5.2.   Use the register -machine language to describe the iterative factorial machine of exercise 5.1. Actions Let us modify the GCD machine so that we can type in the numbers whose GCD we want and get the answer printed at our terminal. We will not discuss how to make a machine that can read and print, but will assume (as we do when we use read  and display  in Scheme) that they are available as primitive operations.1 Read  is like the operations we have been using in that it p


key: chroma:document
string_value:
roduces a value that can be stored in a register . But read  does not take inputs from any registers; its value depends on something that happens outside the parts of the machine we are designing. We will allow our machine's operations to have such behavior , and thus will draw and notate the use of read  just as we do any other operation that computes a value. Print , on the other hand, dif fers from the operations we have been using in a fundamental way: It does not produce an output value to be stored in a register . Though it has an ef fect, this ef fect is not on a part of the machine we are designing. We will refer to this kind of operation as an action . We will represent an action in a data-path diagram just as we represent an operation that computes a value – as a trapezoid that contains the name of the action. Arrows point to the action box from any inputs (registers or constants). We also associate a button with the action. Pushing the button makes the action happen. To make a controller push an ac


key: chroma:document
string_value:
tion button we use a new kind of instruction called perform . Thus, the action of printing the contents of register a is represented in a controller sequence by the instruction (perform (op print) (reg a))   Figure 5.4 shows the data paths and controller for the new GCD machine. Instead of having the machine stop after printing the answer , we have made it start over , so that it repeatedly reads a pair of numbers, computes their GCD, and prints the result. This structure is like the driver loops we used in the interpreters of chapter 4. (controller     gcd-loop       (assign a (op read))       (assign b (op read))     test-b       (test (op =) (reg b) (const 0))       (branch (label gcd-done))       (assign t (op rem) (reg a) (reg b))       (assign a (reg b))       (assign b (reg t))       (goto (label test-b))     gcd-done       (perform (op print) (reg a))       (goto (label gcd-loop)))  Figur e 5.4:   A GCD machine that reads inputs and prints results. 5.1.2  Abstraction in Machine Design We will often de


key: chroma:document
string_value:
fine a machine to include “primitive” operations that are actually very complex. For example, in sections 5.4 and 5.5 we will treat Scheme's environment manipulations as primitive. Such abstraction is valuable because it allows us to ignore the details of parts of a machine so that we can concentrate on other aspects of the design. The fact that we have swept a lot of complexity under the rug, however , does not mean that a machine design is unrealistic. We can always replace the complex “primitives” by simpler primitive operations. Consider the GCD machine. The machine has an instruction that computes the remainder of the contents of registers a and b and assigns the result to register t. If we want to construct the GCD machine without using a primitive remainder operation, wemust specify how to compute remainders in terms of simpler operations, such as subtraction. Indeed, we can write a Scheme procedure that finds remainders in this way: (define (remainder n d)     (if (< n d)         n        (remainder (


key: chroma:document
string_value:
- n d) d)))   We can thus replace the remainder operation in the GCD machine's data paths with a subtraction operation and a comparison test. Figure 5.5 shows the data paths and controller for the elaborated machine. The instruction Figur e 5.5:   Data paths and controller for the elaborated GCD machine. (assign t (op rem) (reg a) (reg b))   in the GCD controller definition is replaced by a sequence of instructions that contains a loop, as shown in figure 5.6. Figur e 5.6:   Controller instruction sequence for the GCD machine in figure 5.5.(controller    test-b     (test (op =) (reg b) (const 0))      (branch (label gcd-done))      (assign t (reg a))    rem-loop      (test (op <) (reg t) (reg b))      (branch (label rem-done))      (assign t (op -) (reg t) (reg b))      (goto (label rem-loop))    rem-done      (assign a (reg b))      (assign b (reg t))      (goto (label test-b))    gcd-done)   Exer cise 5.3.   Design a machine to compute square roots using Newton's method, as described in section 1.1.7 : (def


key: chroma:document
string_value:
ine (sqrt x)     (define (good-enough? guess)       (< (abs (- (square guess) x)) 0.001))     (define (improve guess)       (average guess (/ x guess)))     (define (sqrt-iter guess)       (if (good-enough? guess)           guess           (sqrt-iter (improve guess))))     (sqrt-iter 1.0))   Begin by assuming that good-enough?  and improve  operations are available as primitives. Then show how to expand these in terms of arithmetic operations. Describe each version of the sqrt  machine design by drawing a data-path diagram and writing a controller definition in the register -machine language. 5.1.3  Subr outines When designing a machine to perform a computation, we would often prefer to arrange for components to be shared by dif ferent parts of the computation rather than duplicate the components. Consider a machine that includes two GCD computations – one that finds the GCD of the contents of registers a and b and one that finds the GCD of the contents of registers c and d. We might start by assuming we have


key: chroma:document
string_value:
 a primitive gcdoperation, then expand the two instances of gcd in terms of more primitive operations. Figure 5.7 shows just the GCD portions of the resulting machine's data paths, without showing how they connect to the rest of the machine. The figure also shows the corresponding portions of the machine's controller sequence. gcd-1   (test (op =) (reg b) (const 0))    (branch (label after-gcd-1))    (assign t (op rem) (reg a) (reg b))    (assign a (reg b))    (assign b (reg t))    (goto (label gcd-1))   after-gcd-1      ⋮   gcd-2   (test (op =) (reg d) (const 0))    (branch (label after-gcd-2))    (assign s (op rem) (reg c) (reg d))    (assign c (reg d))    (assign d (reg s))    (goto (label gcd-2))   after-gcd-2  Figur e 5.7:   Portions of the data paths and controller sequence for a machine with two GCD computations. This machine has two remainder operation boxes and two boxes for testing equality . If the duplicated components are complicated, as is the remainder box, this will not be an economical way to


key: chroma:document
string_value:
 build the machine. We can avoid duplicating the data-path components by using the same components for both GCD computations, provided that doing so will not af fect the rest of the lar ger machine's computation. If the values in registers a and b are not needed by the time the controller gets to gcd-2  (or if these values can be moved to other registers for safekeeping), we can change the machine sothat it uses registers a and b, rather than registers c and d, in computing the second GCD as well as the first. If we do this, we obtain the controller sequence shown in figure 5.8. We have removed the duplicate data-path components (so that the data paths are again as in figure 5.1), but the controller now has two GCD sequences that dif fer only in their entry-point labels. It would be better to replace these two sequences by branches to a single sequence – a gcd subroutine  – at the end of which we branch back to the correct place in the main instruction sequence. We can accomplish this as follows: Before branc


key: chroma:document
string_value:
hing to gcd, we place a distinguishing value (such as 0 or 1) into a special register , continue . At the end of the gcd subroutine we return either to after-gcd-1  or to after-gcd-2 , depending on the value of the continue  register . Figure 5.9 shows the relevant portion of the resulting controller sequence, which includes only a single copy of the gcd instructions. gcd-1   (test (op =) (reg b) (const 0))    (branch (label after-gcd-1))    (assign t (op rem) (reg a) (reg b))    (assign a (reg b))    (assign b (reg t))    (goto (label gcd-1))   after-gcd-1     ⋮  gcd-2   (test (op =) (reg b) (const 0))    (branch (label after-gcd-2))    (assign t (op rem) (reg a) (reg b))    (assign a (reg b))    (assign b (reg t))    (goto (label gcd-2))   after-gcd-2  Figur e 5.8:   Portions of the controller sequence for a machine that uses the same data- path components for two dif ferent GCD computations. gcd   (test (op =) (reg b) (const 0))    (branch (label gcd-done))    (assign t (op rem) (reg a) (reg b))  Figur e 5


key: chroma:document
string_value:
.9:   Using a continue  register to avoid the duplicate controller sequence in figure 5.8. (assign a (reg b))    (assign b (reg t))    (goto (label gcd))   gcd-done    (test (op =) (reg continue) (const 0))          (branch (label after-gcd-1))    (goto (label after-gcd-2))     ⋮  ;; Before branching to gcd from the first place where   ;; it is needed, we place 0 in the continue  register    (assign continue (const 0))    (goto (label gcd))   after-gcd-1     ⋮  ;; Before the second use of gcd, we place 1 in the continue  register    (assign continue (const 1))    (goto (label gcd))   after-gcd-2   gcd   (test (op =) (reg b) (const 0))    (branch (label gcd-done))    (assign t (op rem) (reg a) (reg b))    (assign a (reg b))    (assign b (reg t))    (goto (label gcd))   gcd-done    (goto (reg continue))      ⋮  ;; Before calling gcd, we assign to continue   ;; the label to which gcd should return.    (assign continue (label after-gcd-1))    (goto (label gcd))   after-gcd-1      ⋮  ;; Here is the second call to 


key: chroma:document
string_value:
gcd, with a different continuation.    (assign continue (label after-gcd-2))    (goto (label gcd))   after-gcd-2  Figur e 5.10:   Assigning labels to the continue  register simplifies and generalizes the strategy shown in figure 5.9.This is a reasonable approach for handling small problems, but it would be awkward if there were many instances of GCD computations in the controller sequence. To decide where to continue executing after the gcd subroutine, we would need tests in the data paths and branch instructions in the controller for all the places that use gcd. A more powerful method for implementing subroutines is to have the continue  register hold the label of the entry point in the controller sequence at which execution should continue when the subroutine is finished. Implementing this strategy requires a new kind of connection between the data paths and the controller of a register machine: There must be a way to assign to a register a label in the controller sequence in such a way that this value can 


key: chroma:document
string_value:
be fetched from the register and used to continue execution at the designated entry point. To reflect this ability , we will extend the assign  instruction of the register -machine language to allow a register to be assigned as value a label from the controller sequence (as a special kind of constant). We will also extend the goto  instruction to allow execution to continue at the entry point described by the contents of a register rather than only at an entry point described by a constant label. Using these new constructs we can terminate the gcd subroutine with a branch to the location stored in the continue register . This leads to the controller sequence shown in figure 5.10. A machine with more than one subroutine could use multiple continuation registers (e.g., gcd-continue , factorial-continue ) or we could have all subroutines share a single continue  register . Sharing is more economical, but we must be careful if we have a subroutine ( sub1 ) that calls another subroutine ( sub2 ). Unless sub1  save


key: chroma:document
string_value:
s the contents of continue  in some other register before setting up continue  for the call to sub2 , sub1 will not know where to go when it is finished. The mechanism developed in the next section to handle recursion also provides a better solution to this problem of nested subroutine calls. 5.1.4  Using a Stack to Implement Recursion With the ideas illustrated so far , we can implement any iterative process by specifying a register machine that has a register corresponding to each state variable of the process. The machine repeatedly executes a controller loop, changing the contents of the registers, until some termination condition is satisfied. At each point in the controller sequence, the state of the machine (representing the state of the iterative process) is completely determined by the contents of the registers (the values of the state variables). Implementing recursive processes, however , requires an additional mechanism. Consider the following recursive method for computing factorials, which we fi


key: chroma:document
string_value:
rst examined in section 1.2.1 :(define (factorial n)     (if (= n 1)         1        (* (factorial (- n 1)) n)))   As we see from the procedure, computing n! requires computing ( n - 1)!. Our GCD machine, modeled on the procedure (define (gcd a b)     (if (= b 0)         a        (gcd b (remainder a b))))   similarly had to compute another GCD. But there is an important dif ference between the gcd procedure, which reduces the original computation to a new GCD computation, and factorial , which requires computing another factorial as a subproblem. In GCD, the answer to the new GCD computation is the answer to the original problem. To compute the next GCD, we simply place the new ar guments in the input registers of the GCD machine and reuse the machine's data paths by executing the same controller sequence. When the machine is finished solving the final GCD problem, it has completed the entire computation. In the case of factorial (or any recursive process) the answer to the new factorial subproblem is not th


key: chroma:document
string_value:
e answer to the original problem. The value obtained for ( n - 1)! must be multiplied by n to get the final answer . If we try to imitate the GCD design, and solve the factorial subproblem by decrementing the n register and rerunning the factorial machine, we will no longer have available the old value of n by which to multiply the result. We thus need a second factorial machine to work on the subproblem. This second factorial computation itself has a factorial subproblem, which requires a third factorial machine, and so on. Since each factorial machine contains another factorial machine within it, the total machine contains an infinite nest of similar machines and hence cannot be constructed from a fixed, finite number of parts. Nevertheless, we can implement the factorial process as a register machine if we can arrange to use the same components for each nested instance of the machine. Specifically , the machine that computes n! should use the same components to work on the subproblem of computing ( n - 1)!


key: chroma:document
string_value:
, on the subproblem for ( n - 2)!, and so on. This is plausible because, although the factorial process dictates that an unbounded number of copies of the same machine are needed to perform a computation, only one of these copies needs to be active at any given time. When the machine encounters a recursive subproblem, it can suspend work on the main problem, reuse the same physical parts to work on the subproblem, then continue the suspended computation.In the subproblem, the contents of the registers will be dif ferent than they were in the main problem. (In this case the n register is decremented.) In order to be able to continue the suspended computation, the machine must save the contents of any registers that will be needed after the subproblem is solved so that these can be restored to continue the suspended computation. In the case of factorial, we will save the old value of n, to be restored when we are finished computing the factorial of the decremented n register .2 Since there is no a priori  limit


key: chroma:document
string_value:
 on the depth of nested recursive calls, we may need to save an arbitrary number of register values. These values must be restored in the reverse of the order in which they were saved, since in a nest of recursions the last subproblem to be entered is the first to be finished. This dictates the use of a stack , or “last in, first out” data structure, to save register values. We can extend the register -machine language to include a stack by adding two kinds of instructions: V alues are placed on the stack using a save  instruction and restored from the stack using a restore  instruction. After a sequence of values has been save d on the stack, a sequence of restore s will retrieve these values in reverse order .3 With the aid of the stack, we can reuse a single copy of the factorial machine's data paths for each factorial subproblem. There is a similar design issue in reusing the controller sequence that operates the data paths. To reexecute the factorial computation, the controller cannot simply loop back to


key: chroma:document
string_value:
 the beginning, as with an iterative process, because after solving the ( n - 1)! subproblem the machine must still multiply the result by n. The controller must suspend its computation of n!, solve the ( n - 1)! subproblem, then continue its computation of n!. This view of the factorial computation suggests the use of the subroutine mechanism described in section 5.1.3 , which has the controller use a continue  register to transfer to the part of the sequence that solves a subproblem and then continue where it left of f on the main problem. We can thus make a factorial subroutine that returns to the entry point stored in the continue  register . Around each subroutine call, we save and restore continue  just as we do the n register , since each “level” of the factorial computation will use the same continue  register . That is, the factorial subroutine must put a new value in continue  when it calls itself for a subproblem, but it will need the old value in order to return to the place that called it to solv


key: chroma:document
string_value:
e a subproblem. Figure 5.11 shows the data paths and controller for a machine that implements the recursive factorial  procedure. The machine has a stack and three registers, called n, val, and continue . To simplify the data-path diagram, we have not named the register - assignment buttons, only the stack-operation buttons ( sc and sn to save registers, rc and rn to restore registers). To operate the machine, we put in register n the number whose factorial we wish to compute and start the machine. When the machine reaches fact- done , the computation is finished and the answer will be found in the val register . In the controller sequence, n and continue  are saved before each recursive call and restored upon return from the call. Returning from a call is accomplished by branching to thelocation stored in continue . Continue  is initialized when the machine starts so that the last return will go to fact-done . The val register , which holds the result of the factorial computation, is not saved before the rec


key: chroma:document
string_value:
ursive call, because the old contents of val is not useful after the subroutine returns. Only the new value, which is the value produced by the subcomputation, is needed. Although in principle the factorial computation requires an infinite machine, the machine in figure 5.11 is actually finite except for the stack, which is potentially unbounded. Any particular physical implementation of a stack, however , will be of finite size, and this will limit the depth of recursive calls that can be handled by the machine. This implementation of factorial illustrates the general strategy for realizing recursive algorithms as ordinary register machines augmented by stacks. When a recursive subproblem is encountered, we save on the stack the registers whose current values will be required after the subproblem is solved, solve the recursive subproblem, then restore the saved registers and continue execution on the main problem. The continue  register must always be saved. Whether there are other registers that need to be 


key: chroma:document
string_value:
saved depends on the particular machine, since not all recursive computations need the original values of registers that are modified during solution of the subproblem (see exercise 5.4). A double r ecursion Let us examine a more complex recursive process, the tree-recursive computation of the Fibonacci numbers, which we introduced in section 1.2.2 : (define (fib n)     (if (< n 2)         n        (+ (fib (- n 1)) (fib (- n 2)))))   Just as with factorial, we can implement the recursive Fibonacci computation as a register machine with registers n, val, and continue . The machine is more complex than the one for factorial, because there are two places in the controller sequence where we need to perform recursive calls – once to compute Fib( n - 1) and once to compute Fib(n - 2). To set up for each of these calls, we save the registers whose values will be needed later , set the n register to the number whose Fib we need to compute recursively (n - 1 or n - 2), and assign to continue  the entry point in the ma


key: chroma:document
string_value:
in sequence to which to return (afterfib-n-1  or afterfib-n-2 , respectively). We then go to fib-loop . When we return from the recursive call, the answer is in val. Figure 5.12 shows the controller sequence for this machine. Figur e 5.1 1:  A recursive factorial machine.(controller      (assign continue (label fact-done))     ; set up final return address    fact-loop      (test (op =) (reg n) (const 1))      (branch (label base-case))      ;; Set up for the recursive call by saving n and continue .     ;; Set up continue  so that the computation will continue      ;; at after-fact  when the subroutine returns.      (save continue)      (save n)      (assign n (op -) (reg n) (const 1))      (assign continue (label after-fact))      (goto (label fact-loop))    after-fact      (restore n)      (restore continue)      (assign val (op *) (reg n) (reg val))   ; val now contains  n(n - 1)!     (goto (reg continue))                   ; return to caller    base-case      (assign val (const 1))                  ; bas


key: chroma:document
string_value:
e case: 1! = 1     (goto (reg continue))                   ; return to caller    fact-done)   (controller      (assign continue (label fib-done))    fib-loop      (test (op <) (reg n) (const 2))      (branch (label immediate-answer))  Figur e 5.12:   Controller for a machine to compute Fibonacci numbers.   ;; set up to compute Fib(n - 1)     (save continue)      (assign continue (label afterfib-n-1))      (save n)                           ; save old value of n     (assign n (op -) (reg n) (const 1)) ; clobber n to n - 1     (goto (label fib-loop))            ; perform recursive call    afterfib-n-1                         ; upon return, val contains Fib(n - 1)     (restore n)      (restore continue)      ;; set up to compute Fib(n - 2)     (assign n (op -) (reg n) (const 2))      (save continue)      (assign continue (label afterfib-n-2))      (save val)                         ; save Fib(n - 1)     (goto (label fib-loop))    afterfib-n-2                         ; upon return, val contains Fib(n - 2)     (as


key: chroma:document
string_value:
sign n (reg val))               ; n now contains Fib(n - 2)     (restore val)                      ; val now contains Fib(n - 1)     (restore continue)      (assign val                        ;  Fib(n - 1) +  Fib(n - 2)             (op +) (reg val) (reg n))      (goto (reg continue))              ; return to caller, answer is in val   immediate-answer      (assign val (reg n))               ; base case:  Fib(n) = n     (goto (reg continue))    fib-done)   Exer cise 5.4.   Specify register machines that implement each of the following procedures. For each machine, write a controller instruction sequence and draw a diagram showing the data paths. a. Recursive exponentiation: (define (expt b n)     (if (= n 0)         1        (* b (expt b (- n 1)))))   b. Iterative exponentiation:(define (expt b n)     (define (expt-iter counter product)       (if (= counter 0)           product           (expt-iter (- counter 1) (* b product))))     (expt-iter n 1))   Exer cise 5.5.   Hand-simulate the factorial and Fibonacci 


key: chroma:document
string_value:
machines, using some nontrivial input (requiring execution of at least one recursive call). Show the contents of the stack at each significant point in the execution. Exer cise 5.6.   Ben Bitdiddle observes that the Fibonacci machine's controller sequence has an extra save  and an extra restore , which can be removed to make a faster machine. Where are these instructions? 5.1.5  Instruction Summary A controller instruction in our register -machine language has one of the following forms, where each < inputi> is either (reg <register-name >) or (const < constant- value>). These instructions were introduced in section 5.1.1 : (assign < register-name > (reg < register-name >))    (assign < register-name > (const < constant-value >))    (assign < register-name > (op <operation-name >) <input1> ... <inputn>)    (perform (op < operation-name >) <input1> ... <inputn>)    (test (op < operation-name >) <input1> ... <inputn>)    (branch (label < label-name >))    (goto (label < label-name >))  The use of registers to h


key: chroma:document
string_value:
old labels was introduced in section 5.1.3 : (assign < register-name > (label < label-name >))    (goto (reg < register-name >)) Instructions to use the stack were introduced in section 5.1.4 : (save <register-name >)    (restore < register-name >)  The only kind of < constant-value > we have seen so far is a number , but later we will use strings, symbols, and lists. For example, (const "abc")  is the string "abc" , (const abc)  is the symbol abc, (const (a b c))  is the list (a b c) , and (const ()) is the empty list. 1 This assumption glosses over a great deal of complexity . Usually a lar ge portion of the implementation of a Lisp system is dedicated to making reading and printing work. 2 One might ar gue that we don't need to save the old n; after we decrement it and solve the subproblem, we could simply increment it to recover the old value. Although this strategy works for factorial, it cannot work in general, since the old value of a register cannot always be computed from the new one. 3 In section 5.


key: chroma:document
string_value:
3 we will see how to implement a stack in terms of more primitive operations.5.2  A Register-Machine Simulator In order to gain a good understanding of the design of register machines, we must test the machines we design to see if they perform as expected. One way to test a design is to hand-simulate the operation of the controller , as in exercise 5.5. But this is extremely tedious for all but the simplest machines. In this section we construct a simulator for machines described in the register -machine language. The simulator is a Scheme program with four interface procedures. The first uses a description of a register machine to construct a model of the machine (a data structure whose parts correspond to the parts of the machine to be simulated), and the other three allow us to simulate the machine by manipulating the model: (make-machine < register-names > <operations > <controller >)  constructs and returns a model of the machine with the given registers, operations, and controller . (set-register-conten


key: chroma:document
string_value:
ts! < machine-model > <register-name > <value>)  stores a value in a simulated register in the given machine. (get-register-contents < machine-model > <register-name >)  returns the contents of a simulated register in the given machine. (start < machine-model >)  simulates the execution of the given machine, starting from the beginning of the controller sequence and stopping when it reaches the end of the sequence. As an example of how these procedures are used, we can define gcd- machine  to be a model of the GCD machine of section 5.1.1  as follows: (define gcd-machine     (make-machine      '(a b t)      (list (list 'rem remainder) (list '= =))      '(test-b         (test (op =) (reg b) (const 0))          (branch (label gcd-done))          (assign t (op rem) (reg a) (reg b))          (assign a (reg b))          (assign b (reg t))          (goto (label test-b))        gcd-done)))   The first ar gument to make-machine  is a list of register names. The next argument is a table (a list of two-element lists) t


key: chroma:document
string_value:
hat pairs each operation name with a Scheme procedure that implements the operation (that is, produces the same output value given the same input values). The last argument specifies the controller as a list of labels and machine instructions, as in section 5.1. To compute GCDs with this machine, we set the input registers, start the machine, and examine the result when the simulation terminates: (set-register-contents! gcd-machine 'a 206)   done  (set-register-contents! gcd-machine 'b 40)   done  (start gcd-machine)   done  (get-register-contents gcd-machine 'a)   2  This computation will run much more slowly than a gcd procedure written in Scheme, because we will simulate low-level machine instructions, such as assign , by much more complex operations. Exer cise 5.7.   Use the simulator to test the machines you designed in exercise 5.4. 5.2.1  The Machine Model The machine model generated by make-machine  is represented as a procedure with local state using the message-passing techniques developedin chapter


key: chroma:document
string_value:
 3. To build this model, make-machine  begins by calling the procedure make-new-machine  to construct the parts of the machine model that are common to all register machines. This basic machine model constructed by make-new-machine  is essentially a container for some registers and a stack, together with an execution mechanism that processes the controller instructions one by one. Make-machine  then extends this basic model (by sending it messages) to include the registers, operations, and controller of the particular machine being defined. First it allocates a register in the new machine for each of the supplied register names and installs the designated operations in the machine. Then it uses an assembler  (described below in section 5.2.2 ) to transform the controller list into instructions for the new machine and installs these as the machine's instruction sequence. Make-machine  returns as its value the modified machine model. (define (make-machine register-names ops controller-text)     (let ((machine (


key: chroma:document
string_value:
make-new-machine)))       (for-each (lambda (register-name)                   ((machine 'allocate-register) register-name))                 register-names)       ((machine 'install-operations) ops)          ((machine 'install-instruction-sequence)        (assemble controller-text machine))       machine))   Registers We will represent a register as a procedure with local state, as in chapter 3. The procedure make-register  creates a register that holds a value that can be accessed or changed: (define (make-register name)     (let ((contents '*unassigned*))       (define (dispatch message)         (cond ((eq? message 'get) contents)               ((eq? message 'set)               (lambda (value) (set! contents value)))               (else                (error "Unknown request -- REGISTER" message))))       dispatch))   The following procedures are used to access registers: (define (get-contents register)     (register 'get))     (define (set-contents! register value)     ((register 'set) value))   The stack W


key: chroma:document
string_value:
e can also represent a stack as a procedure with local state. The procedure make-stack  creates a stack whose local state consists of a list of the items on the stack. A stack accepts requests to push  an item onto the stack, to pop the top item of f the stack and return it, and to initialize  the stack to empty . (define (make-stack)     (let ((s '()))       (define (push x)         (set! s (cons x s)))       (define (pop)         (if (null? s)             (error "Empty stack -- POP")             (let ((top (car s)))               (set! s (cdr s))               top)))       (define (initialize)         (set! s '())         'done)       (define (dispatch message)         (cond ((eq? message 'push) push)               ((eq? message 'pop) (pop))              ((eq? message 'initialize) (initialize))               (else (error "Unknown request -- STACK"                            message))))       dispatch))   The following procedures are used to access stacks: (define (pop stack)     (stack 'pop))     (define (p


key: chroma:document
string_value:
ush stack value)     ((stack 'push) value))   The basic machine The make-new-machine  procedure, shown in figure 5.13, constructs an object whose local state consists of a stack, an initially empty instruction sequence, a list of operations that initially contains an operation to initialize the stack, and a register table  that initially contains two registers, named flag  and pc (for “program counter”). The internal procedure allocate- register  adds new entries to the register table, and the internal procedure lookup-register  looks up registers in the table. The flag  register is used to control branching in the simulated machine. Test  instructions set the contents of flag  to the result of the test (true or false). Branch  instructions decide whether or not to branch by examining the contents of flag . The pc register determines the sequencing of instructions as the machine runs. This sequencing is implemented by the internal procedure execute . In the simulation model, each machine instruction is a data


key: chroma:document
string_value:
 structure that includes a procedure of no ar guments, called the instruction execution procedur e, such that calling this procedure simulates executing the instruction. As the simulation runs, pc points to the place in the instruction sequence beginning with the next instruction to be executed. Execute  gets that instruction, executes it by calling the instruction execution procedure, and repeats this cycle until there are no more instructions to execute (i.e., until pc points to the end of the instruction sequence).(define (make-new-machine)     (let ((pc (make-register 'pc))           (flag (make-register 'flag))           (stack (make-stack))           (the-instruction-sequence '()))       (let ((the-ops              (list (list 'initialize-stack                          (lambda () (stack 'initialize)))))             (register-table              (list (list 'pc pc) (list 'flag flag))))         (define (allocate-register name)           (if (assoc name register-table)               (error "Multiply defined


key: chroma:document
string_value:
 register: " name)               (set! register-table                     (cons (list name (make-register name))                           register-table)))           'register-allocated)         (define (lookup-register name)           (let ((val (assoc name register-table)))             (if val                 (cadr val)                 (error "Unknown register:" name))))         (define (execute)           (let ((insts (get-contents pc)))             (if (null? insts)                 'done                 (begin                   ((instruction-execution-proc (car insts)))                   (execute)))))         (define (dispatch message)           (cond ((eq? message 'start)                  (set-contents! pc the-instruction-sequence)                  (execute))                 ((eq? message 'install-instruction-sequence)  Figur e 5.13:   The make-new-machine  procedure, which implements the basic machine model.               (lambda (seq) (set! the-instruction- sequence seq)))                 ((eq? messag


key: chroma:document
string_value:
e 'allocate-register) allocate- register)                 ((eq? message 'get-register) lookup-register)                 ((eq? message 'install-operations)                  (lambda (ops) (set! the-ops (append the- ops ops))))                 ((eq? message 'stack) stack)                 ((eq? message 'operations) the-ops)                 (else (error "Unknown request - - MACHINE" message))))         dispatch)))   As part of its operation, each instruction execution procedure modifies pc to indicate the next instruction to be executed. Branch  and goto  instructions change pc to point to the new destination. All other instructions simply advance pc, making it point to the next instruction in the sequence. Observe that each call to execute  calls execute  again, but this does not produce an infinite loop because running the instruction execution procedure changes the contents of pc. Make-new-machine  returns a dispatch  procedure that implements message- passing access to the internal state. Notice that starting 


key: chroma:document
string_value:
the machine is accomplished by setting pc to the beginning of the instruction sequence and calling execute . For convenience, we provide an alternate procedural interface to a machine's start  operation, as well as procedures to set and examine register contents, as specified at the beginning of section 5.2: (define (start machine)     (machine 'start))   (define (get-register-contents machine register-name)     (get-contents (get-register machine register-name)))   (define (set-register-contents! machine register-name value)    (set-contents! (get-register machine register-name) value)     'done)   These procedures (and many procedures in sections 5.2.2  and 5.2.3 ) use the following to look up the register with a given name in a given machine: (define (get-register machine reg-name)     ((machine 'get-register) reg-name))   5.2.2  The Assembler The assembler transforms the sequence of controller expressions for a machine into a corresponding list of machine instructions, each with its execution procedure. O


key: chroma:document
string_value:
verall, the assembler is much like the evaluators we studied in chapter 4 – there is an input language (in this case, the register - machine language) and we must perform an appropriate action for each type of expression in the language. The technique of producing an execution procedure for each instruction is just what we used in section 4.1.7  to speed up the evaluator by separating analysis from runtime execution. As we saw in chapter 4, much useful analysis of Scheme expressions could be performed without knowing the actual values of variables. Here, analogously , much useful analysis of register -machine-language expressions can be performed without knowing the actual contents of machine registers. For example, we can replace references to registers by pointers to the register objects, and we can replace references to labels by pointers to the place in the instruction sequence that the label designates. Before it can generate the instruction execution procedures, the assembler must know what all the labe


key: chroma:document
string_value:
ls refer to, so it begins by scanning the controller text to separate the labels from the instructions. As it scans the text, it constructs both a list of instructions and a table that associates each label with a pointer into that list. Then the assembler augments the instruction list by inserting the execution procedure for each instruction. The assemble  procedure is the main entry to the assembler . It takes the controller text and the machine model as ar guments and returns theinstruction sequence to be stored in the model. Assemble  calls extract- labels  to build the initial instruction list and label table from the supplied controller text. The second ar gument to extract-labels  is a procedure to be called to process these results: This procedure uses update-insts!  to generate the instruction execution procedures and insert them into the instruction list, and returns the modified list. (define (assemble controller-text machine)     (extract-labels controller-text       (lambda (insts labels)        


key: chroma:document
string_value:
 (update-insts! insts labels machine)         insts)))   Extract-labels  takes as ar guments a list text  (the sequence of controller instruction expressions) and a receive  procedure. Receive  will be called with two values: (1) a list insts  of instruction data structures, each containing an instruction from text ; and (2) a table called labels , which associates each label from text  with the position in the list insts  that the label designates. (define (extract-labels text receive)     (if (null? text)         (receive '() '())         (extract-labels (cdr text)          (lambda (insts labels)            (let ((next-inst (car text)))              (if (symbol? next-inst)                  (receive insts                           (cons (make-label-entry next-inst                                                   insts)                                 labels))                  (receive (cons (make-instruction next-inst)                                 insts)                           labels)))))))   Extract-


key: chroma:document
string_value:
labels  works by sequentially scanning the elements of the text and accumulating the insts  and the labels . If an element is a symbol (andthus a label) an appropriate entry is added to the labels  table. Otherwise the element is accumulated onto the insts  list.4 Update-insts!  modifies the instruction list, which initially contains only the text of the instructions, to include the corresponding execution procedures: (define (update-insts! insts labels machine)     (let ((pc (get-register machine 'pc))           (flag (get-register machine 'flag))           (stack (machine 'stack))           (ops (machine 'operations)))       (for-each        (lambda (inst)          (set-instruction-execution-proc!           inst           (make-execution-procedure            (instruction-text inst) labels machine            pc flag stack ops)))        insts)))   The machine instruction data structure simply pairs the instruction text with the corresponding execution procedure. The execution procedure is not yet available wh


key: chroma:document
string_value:
en extract-labels  constructs the instruction, and is inserted later by update-insts! . (define (make-instruction text)     (cons text '()))   (define (instruction-text inst)     (car inst))   (define (instruction-execution-proc inst)     (cdr inst))   (define (set-instruction-execution-proc! inst proc)     (set-cdr! inst proc))   The instruction text is not used by our simulator , but it is handy to keep around for debugging (see exercise 5.16).Elements of the label table are pairs: (define (make-label-entry label-name insts)     (cons label-name insts))   Entries will be looked up in the table with (define (lookup-label labels label-name)     (let ((val (assoc label-name labels)))       (if val           (cdr val)           (error "Undefined label -- ASSEMBLE" label-name))))   Exer cise 5.8.   The following register -machine code is ambiguous, because the label here  is defined more than once: start    (goto (label here))   here    (assign a (const 3))     (goto (label there))   here    (assign a (const 4))


key: chroma:document
string_value:
     (goto (label there))   there  With the simulator as written, what will the contents of register a be when control reaches there ? Modify the extract-labels  procedure so that the assembler will signal an error if the same label name is used to indicate two different locations. 5.2.3  Generating Execution Pr ocedur es for Instructions The assembler calls make-execution-procedure  to generate the execution procedure for an instruction. Like the analyze  procedure in the evaluator of section 4.1.7 , this dispatches on the type of instruction to generate the appropriate execution procedure.(define (make-execution-procedure inst labels machine                                     pc flag stack ops)     (cond ((eq? (car inst) 'assign)            (make-assign inst machine labels ops pc))           ((eq? (car inst) 'test)            (make-test inst machine labels ops flag pc))           ((eq? (car inst) 'branch)            (make-branch inst machine labels flag pc))           ((eq? (car inst) 'goto)            (ma


key: chroma:document
string_value:
ke-goto inst machine labels pc))           ((eq? (car inst) 'save)            (make-save inst machine stack pc))           ((eq? (car inst) 'restore)            (make-restore inst machine stack pc))           ((eq? (car inst) 'perform)            (make-perform inst machine labels ops pc))           (else (error "Unknown instruction type -- ASSEMBLE"                        inst))))   For each type of instruction in the register -machine language, there is a generator that builds an appropriate execution procedure. The details of these procedures determine both the syntax and meaning of the individual instructions in the register -machine language. We use data abstraction to isolate the detailed syntax of register -machine expressions from the general execution mechanism, as we did for evaluators in section 4.1.2 , by using syntax procedures to extract and classify the parts of an instruction. Assign  instructions The make-assign  procedure handles assign  instructions: (define (make-assign inst machine labels 


key: chroma:document
string_value:
operations pc)     (let ((target            (get-register machine (assign-reg-name inst)))           (value-exp (assign-value-exp inst)))       (let ((value-proc              (if (operation-exp? value-exp)                 (make-operation-exp                   value-exp machine labels operations)                  (make-primitive-exp                   (car value-exp) machine labels))))         (lambda ()                ; execution procedure for assig n          (set-contents! target (value-proc))           (advance-pc pc)))))   Make-assign  extracts the tar get register name (the second element of the instruction) and the value expression (the rest of the list that forms the instruction) from the assign  instruction using the selectors (define (assign-reg-name assign-instruction)     (cadr assign-instruction))   (define (assign-value-exp assign-instruction)     (cddr assign-instruction))   The register name is looked up with get-register  to produce the tar get register object. The value expression is passed to


key: chroma:document
string_value:
 make-operation-exp  if the value is the result of an operation, and to make-primitive-exp otherwise. These procedures (shown below) parse the value expression and produce an execution procedure for the value. This is a procedure of no arguments, called value-proc , which will be evaluated during the simulation to produce the actual value to be assigned to the register . Notice that the work of looking up the register name and parsing the value expression is performed just once, at assembly time, not every time the instruction is simulated. This saving of work is the reason we use execution procedures, and corresponds directly to the saving in work we obtained by separating program analysis from execution in the evaluator of section 4.1.7 . The result returned by make-assign  is the execution procedure for the assign  instruction. When this procedure is called (by the machine model's execute  procedure), it sets the contents of the tar get register to the result obtained by executing value-proc . Then it adva


key: chroma:document
string_value:
nces the pc to the next instruction by running the procedure(define (advance-pc pc)     (set-contents! pc (cdr (get-contents pc))))   Advance-pc  is the normal termination for all instructions except branch  and goto . Test , branch , and goto  instructions Make-test  handles test  instructions in a similar way . It extracts the expression that specifies the condition to be tested and generates an execution procedure for it. At simulation time, the procedure for the condition is called, the result is assigned to the flag  register , and the pc is advanced: (define (make-test inst machine labels operations flag pc)     (let ((condition (test-condition inst)))       (if (operation-exp? condition)           (let ((condition-proc                  (make-operation-exp                   condition machine labels operations)))             (lambda ()               (set-contents! flag (condition-proc))               (advance-pc pc)))           (error "Bad TEST instruction -- ASSEMBLE" inst))))   (define (test-condition 


key: chroma:document
string_value:
test-instruction)     (cdr test-instruction))   The execution procedure for a branch  instruction checks the contents of the flag  register and either sets the contents of the pc to the branch destination (if the branch is taken) or else just advances the pc (if the branch is not taken). Notice that the indicated destination in a branch  instruction must be a label, and the make-branch  procedure enforces this. Notice also that the label is looked up at assembly time, not each time the branch  instruction is simulated. (define (make-branch inst machine labels flag pc)     (let ((dest (branch-dest inst)))       (if (label-exp? dest)          (let ((insts                  (lookup-label labels (label-exp-label dest))))             (lambda ()               (if (get-contents flag)                   (set-contents! pc insts)                   (advance-pc pc))))           (error "Bad BRANCH instruction -- ASSEMBLE" inst))))   (define (branch-dest branch-instruction)     (cadr branch-instruction))   A goto  instructio


key: chroma:document
string_value:
n is similar to a branch, except that the destination may be specified either as a label or as a register , and there is no condition to check – the pc is always set to the new destination. (define (make-goto inst machine labels pc)     (let ((dest (goto-dest inst)))       (cond ((label-exp? dest)              (let ((insts                     (lookup-label labels                                   (label-exp-label dest))))                (lambda () (set-contents! pc insts))))             ((register-exp? dest)              (let ((reg                     (get-register machine                                   (register-exp-reg dest))))                (lambda ()                  (set-contents! pc (get-contents reg)))))             (else (error "Bad GOTO instruction -- ASSEMBLE"                          inst)))))   (define (goto-dest goto-instruction)     (cadr goto-instruction))   Other instructions The stack instructions save  and restore  simply use the stack with the designated register and advance the pc:(def


key: chroma:document
string_value:
ine (make-save inst machine stack pc)     (let ((reg (get-register machine                              (stack-inst-reg-name inst))))       (lambda ()         (push stack (get-contents reg))         (advance-pc pc))))   (define (make-restore inst machine stack pc)     (let ((reg (get-register machine                              (stack-inst-reg-name inst))))       (lambda ()         (set-contents! reg (pop stack))            (advance-pc pc))))   (define (stack-inst-reg-name stack-instruction)     (cadr stack-instruction))   The final instruction type, handled by make-perform , generates an execution procedure for the action to be performed. At simulation time, the action procedure is executed and the pc advanced. (define (make-perform inst machine labels operations pc)     (let ((action (perform-action inst)))       (if (operation-exp? action)           (let ((action-proc                  (make-operation-exp                   action machine labels operations)))             (lambda ()               (action-pro


key: chroma:document
string_value:
c)               (advance-pc pc)))           (error "Bad PERFORM instruction -- ASSEMBLE" inst))))   (define (perform-action inst) (cdr inst))   Execution pr ocedur es for subexpr essions The value of a reg, label , or const  expression may be needed for assignment to a register ( make-assign ) or for input to an operation ( make- operation-exp , below). The following procedure generates execution procedures to produce values for these expressions during the simulation:(define (make-primitive-exp exp machine labels)     (cond ((constant-exp? exp)            (let ((c (constant-exp-value exp)))              (lambda () c)))           ((label-exp? exp)            (let ((insts                   (lookup-label labels                                 (label-exp-label exp))))              (lambda () insts)))           ((register-exp? exp)            (let ((r (get-register machine                                   (register-exp-reg exp))))              (lambda () (get-contents r))))           (else            (error "Un


key: chroma:document
string_value:
known expression type -- ASSEMBLE" exp))))   The syntax of reg, label , and const  expressions is determined by (define (register-exp? exp) (tagged-list? exp 'reg))   (define (register-exp-reg exp) (cadr exp))   (define (constant-exp? exp) (tagged-list? exp 'const))   (define (constant-exp-value exp) (cadr exp))   (define (label-exp? exp) (tagged-list? exp 'label))   (define (label-exp-label exp) (cadr exp))   Assign , perform , and test  instructions may include the application of a machine operation (specified by an op expression) to some operands (specified by reg and const  expressions). The following procedure produces an execution procedure for an “operation expression” – a list containing the operation and operand expressions from the instruction: (define (make-operation-exp exp machine labels operations)     (let ((op (lookup-prim (operation-exp-op exp) operations))           (aprocs            (map (lambda (e)                   (make-primitive-exp e machine labels))                 (operation-exp-ope


key: chroma:document
string_value:
rands exp))))      (lambda ()         (apply op (map (lambda (p) (p)) aprocs)))))   The syntax of operation expressions is determined by (define (operation-exp? exp)     (and (pair? exp) (tagged-list? (car exp) 'op)))   (define (operation-exp-op operation-exp)     (cadr (car operation-exp)))   (define (operation-exp-operands operation-exp)     (cdr operation-exp))   Observe that the treatment of operation expressions is very much like the treatment of procedure applications by the analyze-application  procedure in the evaluator of section 4.1.7  in that we generate an execution procedure for each operand. At simulation time, we call the operand procedures and apply the Scheme procedure that simulates the operation to the resulting values. The simulation procedure is found by looking up the operation name in the operation table for the machine: (define (lookup-prim symbol operations)     (let ((val (assoc symbol operations)))       (if val           (cadr val)           (error "Unknown operation -- ASSEMBLE" s


key: chroma:document
string_value:
ymbol))))   Exer cise 5.9.   The treatment of machine operations above permits them to operate on labels as well as on constants and the contents of registers. Modify the expression-processing procedures to enforce the condition that operations can be used only with registers and constants. Exer cise 5.10.   Design a new syntax for register -machine instructions and modify the simulator to use your new syntax. Can you implement your new syntax without changing any part of the simulator except the syntax procedures in this section? Exer cise 5.1 1.  When we introduced save  and restore  in section 5.1.4 , we didn't specify what would happen if you tried to restore a register that wasnot the last one saved, as in the sequence (save y)   (save x)   (restore y)   There are several reasonable possibilities for the meaning of restore : a.  (restore y)  puts into y the last value saved on the stack, regardless of what register that value came from. This is the way our simulator behaves. Show how to take advantage of


key: chroma:document
string_value:
 this behavior to eliminate one instruction from the Fibonacci machine of section 5.1.4  (figure 5.12). b.  (restore y)  puts into y the last value saved on the stack, but only if that value was saved from y; otherwise, it signals an error . Modify the simulator to behave this way . You will have to change save  to put the register name on the stack along with the value. c.  (restore y)  puts into y the last value saved from y regardless of what other registers were saved after y and not restored. Modify the simulator to behave this way . You will have to associate a separate stack with each register . You should make the initialize-stack  operation initialize all the register stacks. Exer cise 5.12.   The simulator can be used to help determine the data paths required for implementing a machine with a given controller . Extend the assembler to store the following information in the machine model: a list of all instructions, with duplicates removed, sorted by instruction type (assign , goto , and so on); a li


key: chroma:document
string_value:
st (without duplicates) of the registers used to hold entry points (these are the registers referenced by goto  instructions); a list (without duplicates) of the registers that are save d or restore d; for each register , a list (without duplicates) of the sources from which it is assigned (for example, the sources for register val in the factorialmachine of figure 5.11 are (const 1)  and ((op *) (reg n) (reg val)) ). Extend the message-passing interface to the machine to provide access to this new information. To test your analyzer , define the Fibonacci machine from figure 5.12 and examine the lists you constructed. Exer cise 5.13.   Modify the simulator so that it uses the controller sequence to determine what registers the machine has rather than requiring a list of registers as an ar gument to make-machine . Instead of pre-allocating the registers in make-machine , you can allocate them one at a time when they are first seen during assembly of the instructions. 5.2.4  Monitoring Machine Performance Simul


key: chroma:document
string_value:
ation is useful not only for verifying the correctness of a proposed machine design but also for measuring the machine's performance. For example, we can install in our simulation program a “meter” that measures the number of stack operations used in a computation. To do this, we modify our simulated stack to keep track of the number of times registers are saved on the stack and the maximum depth reached by the stack, and add a message to the stack's interface that prints the statistics, as shown below . We also add an operation to the basic machine model to print the stack statistics, by initializing the-ops  in make-new-machine  to (list (list 'initialize-stack               (lambda () (stack 'initialize)))         (list 'print-stack-statistics               (lambda () (stack 'print-statistics))))   Here is the new version of make-stack : (define (make-stack)     (let ((s '())           (number-pushes 0)           (max-depth 0)           (current-depth 0))       (define (push x)        (set! s (cons x s))  


key: chroma:document
string_value:
       (set! number-pushes (+ 1 number-pushes))         (set! current-depth (+ 1 current-depth))         (set! max-depth (max current-depth max-depth)))       (define (pop)         (if (null? s)             (error "Empty stack -- POP")             (let ((top (car s)))               (set! s (cdr s))               (set! current-depth (- current-depth 1))               top)))          (define (initialize)         (set! s '())         (set! number-pushes 0)         (set! max-depth 0)         (set! current-depth 0)         'done)       (define (print-statistics)         (newline)         (display (list 'total-pushes  '= number-pushes                        'maximum-depth '= max-depth)))       (define (dispatch message)         (cond ((eq? message 'push) push)               ((eq? message 'pop) (pop))               ((eq? message 'initialize) (initialize))               ((eq? message 'print-statistics)                (print-statistics))               (else                (error "Unknown request -- STACK" message)))) 


key: chroma:document
string_value:
      dispatch))   Exercises 5.15 through 5.19 describe other useful monitoring and debugging features that can be added to the register -machine simulator . Exer cise 5.14.   Measure the number of pushes and the maximum stack depth required to compute n! for various small values of n using the factorial machine shown in figure 5.11. From your data determine formulasin terms of n for the total number of push operations and the maximum stack depth used in computing n! for any n > 1. Note that each of these is a linear function of n and is thus determined by two constants. In order to get the statistics printed, you will have to augment the factorial machine with instructions to initialize the stack and print the statistics. You may want to also modify the machine so that it repeatedly reads a value for n, computes the factorial, and prints the result (as we did for the GCD machine in figure 5.4), so that you will not have to repeatedly invoke get-register- contents , set-register-contents! , and start . Exer c


key: chroma:document
string_value:
ise 5.15.   Add instruction counting  to the register machine simulation. That is, have the machine model keep track of the number of instructions executed. Extend the machine model's interface to accept a new message that prints the value of the instruction count and resets the count to zero. Exer cise 5.16.   Augment the simulator to provide for instruction tracing . That is, before each instruction is executed, the simulator should print the text of the instruction. Make the machine model accept trace-on  and trace-off  messages to turn tracing on and of f. Exer cise 5.17.   Extend the instruction tracing of exercise 5.16 so that before printing an instruction, the simulator prints any labels that immediately precede that instruction in the controller sequence. Be careful to do this in a way that does not interfere with instruction counting (exercise 5.15). You will have to make the simulator retain the necessary label information. Exer cise 5.18.   Modify the make-register  procedure of section 5.2.1  so 


key: chroma:document
string_value:
that registers can be traced. Registers should accept messages that turn tracing on and of f. When a register is traced, assigning a value to the register should print the name of the register , the old contents of the register , and the new contents being assigned. Extend the interface to the machine model to permit you to turn tracing on and of f for designated machine registers. Exer cise 5.19.   Alyssa P . Hacker wants a breakpoint  feature in the simulator to help her debug her machine designs. You have been hired to install this feature for her . She wants to be able to specify a place in the controllersequence where the simulator will stop and allow her to examine the state of the machine. You are to implement a procedure (set-breakpoint < machine> <label> <n>)  that sets a breakpoint just before the nth instruction after the given label. For example, (set-breakpoint gcd-machine 'test-b 4)   installs a breakpoint in gcd-machine  just before the assignment to register a. When the simulator reaches the b


key: chroma:document
string_value:
reakpoint it should print the label and the of fset of the breakpoint and stop executing instructions. Alyssa can then use get-register-contents  and set-register-contents!  to manipulate the state of the simulated machine. She should then be able to continue execution by saying (proceed-machine < machine>)  She should also be able to remove a specific breakpoint by means of (cancel-breakpoint < machine> <label> <n>)  or to remove all breakpoints by means of (cancel-all-breakpoints < machine>)  4 Using the receive  procedure here is a way to get extract-labels  to ef fectively return two values – labels  and insts  – without explicitly making a compound data structure to hold them. An alternative implementation, which returns an explicit pair of values, is (define (extract-labels text)     (if (null? text)         (cons '() '())         (let ((result (extract-labels (cdr text))))           (let ((insts (car result)) (labels (cdr result)))             (let ((next-inst (car text)))               (if (symbol? ne


key: chroma:document
string_value:
xt-inst)                   (cons insts                         (cons (make-label-entry next-inst insts) labels))                  (cons (cons (make-instruction next-inst) insts)                         labels)))))))   which would be called by assemble  as follows: (define (assemble controller-text machine)     (let ((result (extract-labels controller-text)))       (let ((insts (car result)) (labels (cdr result)))         (update-insts! insts labels machine)         insts)))   You can consider our use of receive  as demonstrating an elegant way to return multiple values, or simply an excuse to show of f a programming trick. An ar gument like receive  that is the next procedure to be invoked is called a “continuation.” Recall that we also used continuations to implement the backtracking control structure in the amb evaluator in section 4.3.3 .5.3  Storage Allocation and Garbage Collection In section 5.4, we will show how to implement a Scheme evaluator as a register machine. In order to simplify the discussion,


key: chroma:document
string_value:
 we will assume that our register machines can be equipped with a list-structur ed memory , in which the basic operations for manipulating list-structured data are primitive. Postulating the existence of such a memory is a useful abstraction when one is focusing on the mechanisms of control in a Scheme interpreter , but this does not reflect a realistic view of the actual primitive data operations of contemporary computers. To obtain a more complete picture of how a Lisp system operates, we must investigate how list structure can be represented in a way that is compatible with conventional computer memories. There are two considerations in implementing list structure. The first is purely an issue of representation: how to represent the “box-and-pointer” structure of Lisp pairs, using only the storage and addressing capabilities of typical computer memories. The second issue concerns the management of memory as a computation proceeds. The operation of a Lisp system depends crucially on the ability to continual


key: chroma:document
string_value:
ly create new data objects. These include objects that are explicitly created by the Lisp procedures being interpreted as well as structures created by the interpreter itself, such as environments and ar gument lists. Although the constant creation of new data objects would pose no problem on a computer with an infinite amount of rapidly addressable memory , computer memories are available only in finite sizes (more's the pity). Lisp systems thus provide an automatic storage allocation  facility to support the illusion of an infinite memory . When a data object is no longer needed, the memory allocated to it is automatically recycled and used to construct new data objects. There are various techniques for providing such automatic storage allocation. The method we shall discuss in this section is called garbage collection . 5.3.1  Memory as V ectors A conventional computer memory can be thought of as an array of cubbyholes, each of which can contain a piece of information. Eachcubbyhole has a unique name, call


key: chroma:document
string_value:
ed its address or location . Typical memory systems provide two primitive operations: one that fetches the data stored in a specified location and one that assigns new data to a specified location. Memory addresses can be incremented to support sequential access to some set of the cubbyholes. More generally , many important data operations require that memory addresses be treated as data, which can be stored in memory locations and manipulated in machine registers. The representation of list structure is one application of such address arithmetic . To model computer memory , we use a new kind of data structure called a vector . Abstractly , a vector is a compound data object whose individual elements can be accessed by means of an integer index in an amount of time that is independent of the index.5 In order to describe memory operations, we use two primitive Scheme procedures for manipulating vectors: (vector-ref < vector> <n>) returns the nth element of the vector . (vector-set! < vector> <n> <value>) sets 


key: chroma:document
string_value:
the nth element of the vector to the designated value. For example, if v is a vector , then (vector-ref v 5)  gets the fifth entry in the vector v and (vector-set! v 5 7)  changes the value of the fifth entry of the vector v to 7.6 For computer memory , this access can be implemented through the use of address arithmetic to combine a base addr ess that specifies the beginning location of a vector in memory with an index  that specifies the of fset of a particular element of the vector . Repr esenting Lisp data We can use vectors to implement the basic pair structures required for a list- structured memory . Let us imagine that computer memory is divided into two vectors: the-cars  and the-cdrs . We will represent list structure as follows: A pointer to a pair is an index into the two vectors. The car of the pair is the entry in the-cars  with the designated index, and the cdr of the pair is the entry in the-cdrs  with the designated index. We also need a representation for objects other than pairs (such as nu


key: chroma:document
string_value:
mbers and symbols)and a way to distinguish one kind of data from another . There are many methods of accomplishing this, but they all reduce to using typed pointers , that is, to extending the notion of “pointer” to include information on data type.7 The data type enables the system to distinguish a pointer to a pair (which consists of the “pair” data type and an index into the memory vectors) from pointers to other kinds of data (which consist of some other data type and whatever is being used to represent data of that type). Two data objects are considered to be the same ( eq?) if their pointers are identical.8 Figure 5.14 illustrates the use of this method to represent the list ((1 2) 3 4) , whose box-and-pointer diagram is also shown. We use letter prefixes to denote the data-type information. Thus, a pointer to the pair with index 5 is denoted p5, the empty list is denoted by the pointer e0, and a pointer to the number 4 is denoted n4. In the box-and-pointer diagram, we have indicated at the lower left o


key: chroma:document
string_value:
f each pair the vector index that specifies where the car and cdr of the pair are stored. The blank locations in the- cars  and the-cdrs  may contain parts of other list structures (not of interest here). Figur e 5.14:   Box-and-pointer and memory-vector representations of the list ((1 2) 3 4) . A pointer to a number , such as n4, might consist of a type indicating numeric data together with the actual representation of the number 4.9 To deal with numbers that are too lar ge to be represented in the fixed amount of space allocated for a single pointer , we could use a distinct bignum  data type, for which the pointer designates a list in which the parts of the number are stored.10A symbol might be represented as a typed pointer that designates a sequence of the characters that form the symbol's printed representation. This sequence is constructed by the Lisp reader when the character string is initially encountered in input. Since we want two instances of a symbol to be recognized as the “same” symbol by eq? 


key: chroma:document
string_value:
and we want eq? to be a simple test for equality of pointers, we must ensure that if the reader sees the same character string twice, it will use the same pointer (to the same sequence of characters) to represent both occurrences. To accomplish this, the reader maintains a table, traditionally called the obarray , of all the symbols it has ever encountered. When the reader encounters a character string and is about to construct a symbol, it checks the obarray to see if it has ever before seen the same character string. If it has not, it uses the characters to construct a new symbol (a typed pointer to a new character sequence) and enters this pointer in the obarray . If the reader has seen the string before, it returns the symbol pointer stored in the obarray . This process of replacing character strings by unique pointers is called interning  symbols. Implementing the primitive list operations Given the above representation scheme, we can replace each “primitive” list operation of a register machine with one


key: chroma:document
string_value:
 or more primitive vector operations. We will use two registers, the-cars  and the-cdrs , to identify the memory vectors, and will assume that vector-ref  and vector-set!  are available as primitive operations. We also assume that numeric operations on pointers (such as incrementing a pointer , using a pair pointer to index a vector , or adding two numbers) use only the index portion of the typed pointer . For example, we can make a register machine support the instructions (assign < reg1> (op car) (reg < reg2>))    (assign < reg1> (op cdr) (reg < reg2>))  if we implement these, respectively , as(assign < reg1> (op vector-ref) (reg the-cars) (reg < reg2>))    (assign < reg1> (op vector-ref) (reg the-cdrs) (reg < reg2>))  The instructions (perform (op set-car!) (reg < reg1>) (reg < reg2>))    (perform (op set-cdr!) (reg < reg1>) (reg < reg2>))  are implemented as (perform    (op vector-set!) (reg the-cars) (reg < reg1>) (reg < reg2>))    (perform    (op vector-set!) (reg the-cdrs) (reg < reg1>) (reg < reg2>)) 


key: chroma:document
string_value:
 Cons  is performed by allocating an unused index and storing the ar guments to cons  in the-cars  and the-cdrs  at that indexed vector position. We presume that there is a special register , free , that always holds a pair pointer containing the next available index, and that we can increment the index part of that pointer to find the next free location.11 For example, the instruction (assign < reg1> (op cons) (reg < reg2>) (reg < reg3>))  is implemented as the following sequence of vector operations:12 (perform    (op vector-set!) (reg the-cars) (reg free) (reg < reg2>))  (perform    (op vector-set!) (reg the-cdrs) (reg free) (reg < reg3>))  (assign < reg1> (reg free))   (assign free (op +) (reg free) (const 1))   The eq? operation(op eq?) (reg < reg1>) (reg < reg2>)  simply tests the equality of all fields in the registers, and predicates such as pair? , null? , symbol? , and number?  need only check the type field. Implementing stacks Although our register machines use stacks, we need do nothing special h


key: chroma:document
string_value:
ere, since stacks can be modeled in terms of lists. The stack can be a list of the saved values, pointed to by a special register the-stack . Thus, (save <reg>) can be implemented as (assign the-stack (op cons) (reg < reg>) (reg the-stack))   Similarly , (restore < reg>) can be implemented as (assign < reg> (op car) (reg the-stack))   (assign the-stack (op cdr) (reg the-stack))   and (perform (op initialize-stack))  can be implemented as (assign the-stack (const ()))   These operations can be further expanded in terms of the vector operations given above. In conventional computer architectures, however , it is usually advantageous to allocate the stack as a separate vector . Then pushing and popping the stack can be accomplished by incrementing or decrementing an index into that vector . Exer cise 5.20.   Draw the box-and-pointer representation and the memory- vector representation (as in figure 5.14) of the list structure produced by (define x (cons 1 2))   (define y (list x x))   with the free  pointer init


key: chroma:document
string_value:
ially p1. What is the final value of free  ? What pointers represent the values of x and y ?Exer cise 5.21.   Implement register machines for the following procedures. Assume that the list-structure memory operations are available as machine primitives. a. Recursive count-leaves : (define (count-leaves tree)     (cond ((null? tree) 0)           ((not (pair? tree)) 1)           (else (+ (count-leaves (car tree))                    (count-leaves (cdr tree))))))   b. Recursive count-leaves  with explicit counter: (define (count-leaves tree)     (define (count-iter tree n)       (cond ((null? tree) n)             ((not (pair? tree)) (+ n 1))             (else (count-iter (cdr tree)                               (count-iter (car tree) n)))))     (count-iter tree 0))   Exer cise 5.22.   Exercise 3.12 of section 3.3.1  presented an append procedure that appends two lists to form a new list and an append! procedure that splices two lists together . Design a register machine to implement each of these procedures. Assu


key: chroma:document
string_value:
me that the list-structure memory operations are available as primitive operations. 5.3.2  Maintaining the Illusion of Infinite Memory The representation method outlined in section 5.3.1  solves the problem of implementing list structure, provided that we have an infinite amount of memory . With a real computer we will eventually run out of free space in which to construct new pairs.13 However , most of the pairs generated in a typical computation are used only to hold intermediate results. After these results are accessed, the pairs are no longer needed – they are garbage . For instance, the computation(accumulate + 0 (filter odd? (enumerate-interval 0 n)))   constructs two lists: the enumeration and the result of filtering the enumeration. When the accumulation is complete, these lists are no longer needed, and the allocated memory can be reclaimed. If we can arrange to collect all the garbage periodically , and if this turns out to recycle memory at about the same rate at which we construct new pairs, we w


key: chroma:document
string_value:
ill have preserved the illusion that there is an infinite amount of memory . In order to recycle pairs, we must have a way to determine which allocated pairs are not needed (in the sense that their contents can no longer influence the future of the computation). The method we shall examine for accomplishing this is known as garbage collection . Garbage collection is based on the observation that, at any moment in a Lisp interpretation, the only objects that can af fect the future of the computation are those that can be reached by some succession of car and cdr operations starting from the pointers that are currently in the machine registers.14 Any memory cell that is not so accessible may be recycled. There are many ways to perform garbage collection. The method we shall examine here is called stop-and-copy . The basic idea is to divide memory into two halves: “working memory” and “free memory .” When cons constructs pairs, it allocates these in working memory . When working memory is full, we perform garbag


key: chroma:document
string_value:
e collection by locating all the useful pairs in working memory and copying these into consecutive locations in free memory . (The useful pairs are located by tracing all the car and cdr pointers, starting with the machine registers.) Since we do not copy the garbage, there will presumably be additional free memory that we can use to allocate new pairs. In addition, nothing in the working memory is needed, since all the useful pairs in it have been copied. Thus, if we interchange the roles of working memory and free memory , we can continue processing; new pairs will be allocated in the new working memory (which was the old free memory). When this is full, we can copy the useful pairs into the new free memory (which was the old working memory).15 Implementation of a stop-and-copy garbage collectorWe now use our register -machine language to describe the stop-and-copy algorithm in more detail. We will assume that there is a register called root that contains a pointer to a structure that eventually points at a


key: chroma:document
string_value:
ll accessible data. This can be arranged by storing the contents of all the machine registers in a pre-allocated list pointed at by root  just before starting garbage collection.16 We also assume that, in addition to the current working memory , there is free memory available into which we can copy the useful data. The current working memory consists of vectors whose base addresses are in registers called the-cars  and the-cdrs , and the free memory is in registers called new-cars  and new-cdrs . Garbage collection is triggered when we exhaust the free cells in the current working memory , that is, when a cons  operation attempts to increment the free  pointer beyond the end of the memory vector . When the garbage- collection process is complete, the root  pointer will point into the new memory , all objects accessible from the root  will have been moved to the new memory , and the free  pointer will indicate the next place in the new memory where a new pair can be allocated. In addition, the roles of working


key: chroma:document
string_value:
 memory and new memory will have been interchanged – new pairs will be constructed in the new memory , beginning at the place indicated by free , and the (previous) working memory will be available as the new memory for the next garbage collection. Figure 5.15 shows the arrangement of memory just before and just after garbage collection. Figur e 5.15:   Reconfiguration of memory by the garbage-collection process.The state of the garbage-collection process is controlled by maintaining two pointers: free  and scan . These are initialized to point to the beginning of the new memory . The algorithm begins by relocating the pair pointed at by root  to the beginning of the new memory . The pair is copied, the root pointer is adjusted to point to the new location, and the free  pointer is incremented. In addition, the old location of the pair is marked to show that its contents have been moved. This marking is done as follows: In the car position, we place a special tag that signals that this is an already-moved obj


key: chroma:document
string_value:
ect. (Such an object is traditionally called a broken heart .)17 In the cdr position we place a forwar ding addr ess that points at the location to which the object has been moved. After relocating the root, the garbage collector enters its basic cycle. At each step in the algorithm, the scan  pointer (initially pointing at the relocated root) points at a pair that has been moved to the new memory butwhose car and cdr pointers still refer to objects in the old memory . These objects are each relocated, and the scan  pointer is incremented. To relocate an object (for example, the object indicated by the car pointer of the pair we are scanning) we check to see if the object has already been moved (as indicated by the presence of a broken-heart tag in the car position of the object). If the object has not already been moved, we copy it to the place indicated by free , update free , set up a broken heart at the object's old location, and update the pointer to the object (in this example, the car pointer of the pa


key: chroma:document
string_value:
ir we are scanning) to point to the new location. If the object has already been moved, its forwarding address (found in the cdr position of the broken heart) is substituted for the pointer in the pair being scanned. Eventually , all accessible objects will have been moved and scanned, at which point the scan  pointer will overtake the free  pointer and the process will terminate. We can specify the stop-and-copy algorithm as a sequence of instructions for a register machine. The basic step of relocating an object is accomplished by a subroutine called relocate-old-result-in-new . This subroutine gets its ar gument, a pointer to the object to be relocated, from a register named old. It relocates the designated object (incrementing free  in the process), puts a pointer to the relocated object into a register called new, and returns by branching to the entry point stored in the register relocate- continue . To begin garbage collection, we invoke this subroutine to relocate the root  pointer , after initializing


key: chroma:document
string_value:
 free  and scan . When the relocation of root  has been accomplished, we install the new pointer as the new root  and enter the main loop of the garbage collector . begin-garbage-collection     (assign free (const 0))     (assign scan (const 0))     (assign old (reg root))     (assign relocate-continue (label reassign-root))     (goto (label relocate-old-result-in-new))   reassign-root     (assign root (reg new))     (goto (label gc-loop))  In the main loop of the garbage collector we must determine whether there are any more objects to be scanned. We do this by testing whether the scan pointer is coincident with the free  pointer . If the pointers are equal, then all accessible objects have been relocated, and we branch to gc-flip , which cleans things up so that we can continue the interrupted computation. If there are still pairs to be scanned, we call the relocate subroutine to relocate the car of the next pair (by placing the car pointer in old). The relocate- continue  register is set up so that the sub


key: chroma:document
string_value:
routine will return to update the car pointer . gc-loop    (test (op =) (reg scan) (reg free))     (branch (label gc-flip))     (assign old (op vector-ref) (reg new-cars) (reg scan))     (assign relocate-continue (label update-car))     (goto (label relocate-old-result-in-new))   At update-car , we modify the car pointer of the pair being scanned, then proceed to relocate the cdr of the pair . We return to update-cdr  when that relocation has been accomplished. After relocating and updating the cdr, we are finished scanning that pair , so we continue with the main loop. update-car     (perform      (op vector-set!) (reg new-cars) (reg scan) (reg new))     (assign old (op vector-ref) (reg new-cdrs) (reg scan))     (assign relocate-continue (label update-cdr))     (goto (label relocate-old-result-in-new))     update-cdr     (perform      (op vector-set!) (reg new-cdrs) (reg scan) (reg new))     (assign scan (op +) (reg scan) (const 1))     (goto (label gc-loop))   The subroutine relocate-old-result-in-new  relo


key: chroma:document
string_value:
cates objects as follows: If the object to be relocated (pointed at by old) is not a pair , then we return the same pointer to the object unchanged (in new). (For example, we may bescanning a pair whose car is the number 4. If we represent the car by n4, as described in section 5.3.1 , then we want the “relocated” car pointer to still be n4.) Otherwise, we must perform the relocation. If the car position of the pair to be relocated contains a broken-heart tag, then the pair has in fact already been moved, so we retrieve the forwarding address (from the cdr position of the broken heart) and return this in new. If the pointer in old points at a yet-unmoved pair , then we move the pair to the first free cell in new memory (pointed at by free ) and set up the broken heart by storing a broken-heart tag and forwarding address at the old location. Relocate-old- result-in-new  uses a register oldcr  to hold the car or the cdr of the object pointed at by old.18 relocate-old-result-in-new     (test (op pointer-to-pair?


key: chroma:document
string_value:
) (reg old))     (branch (label pair))     (assign new (reg old))     (goto (reg relocate-continue))   pair    (assign oldcr (op vector-ref) (reg the-cars) (reg old))     (test (op broken-heart?) (reg oldcr))     (branch (label already-moved))     (assign new (reg free)) ; new location for pair     ;; Update free pointer.     (assign free (op +) (reg free) (const 1))     ;; Copy the car and cdr to new memory.     (perform (op vector-set!)              (reg new-cars) (reg new) (reg oldcr))     (assign oldcr (op vector-ref) (reg the-cdrs) (reg old))     (perform (op vector-set!)              (reg new-cdrs) (reg new) (reg oldcr))     ;; Construct the broken heart.     (perform (op vector-set!)              (reg the-cars) (reg old) (const broken-heart))     (perform      (op vector-set!) (reg the-cdrs) (reg old) (reg new))     (goto (reg relocate-continue))   already-moved    (assign new (op vector-ref) (reg the-cdrs) (reg old))     (goto (reg relocate-continue))   At the very end of the garbage-collection proces


key: chroma:document
string_value:
s, we interchange the role of old and new memories by interchanging pointers: interchanging the- cars  with new-cars , and the-cdrs  with new-cdrs . We will then be ready to perform another garbage collection the next time memory runs out. gc-flip    (assign temp (reg the-cdrs))     (assign the-cdrs (reg new-cdrs))     (assign new-cdrs (reg temp))     (assign temp (reg the-cars))     (assign the-cars (reg new-cars))     (assign new-cars (reg temp))   5 We could represent memory as lists of items. However , the access time would then not be independent of the index, since accessing the nth element of a list requires n - 1 cdr operations. 6 For completeness, we should specify a make-vector  operation that constructs vectors. However , in the present application we will use vectors only to model fixed divisions of the computer memory . 7 This is precisely the same “tagged data” idea we introduced in chapter 2 for dealing with generic operations. Here, however , the data types are included at the primitive machin


key: chroma:document
string_value:
e level rather than constructed through the use of lists. 8 Type information may be encoded in a variety of ways, depending on the details of the machine on which the Lisp system is to be implemented. The execution ef ficiency of Lisp programs will be strongly dependent on how cleverly this choice is made, but it is dif ficult to formulate general design rules for good choices. The most straightforward way to implement typed pointers is to allocate a fixed set of bits in each pointer to be a type field  that encodes the data type. Important questions to be addressed in designing such a representation include the following: How many type bits are required? How lar ge must the vector indices be? How ef ficiently can the primitive machine instructions be used to manipulate the type fields of pointers? Machines that include special hardware for the ef ficient handling of type fields are said to have tagged ar chitectur es. 9 This decision on the representation of numbers determines whether eq?, which tests equali


key: chroma:document
string_value:
ty of pointers, can be used to test for equality of numbers. If the pointer contains the number itself, then equal numbers will have the same pointer . But if the pointer contains the index of a location where the number is stored, equal numbers will be guaranteed to have equal pointers only if we are careful never to store the same number in more than one location.10 This is just like writing a number as a sequence of digits, except that each “digit” is a number between 0 and the lar gest number that can be stored in a single pointer . 11 There are other ways of finding free storage. For example, we could link together all the unused pairs into a free list . Our free locations are consecutive (and hence can be accessed by incrementing a pointer) because we are using a compacting garbage collector , as we will see in section 5.3.2 . 12 This is essentially the implementation of cons  in terms of set-car!  and set-cdr! , as described in section 3.3.1 . The operation get-new-pair  used in that implementation is 


key: chroma:document
string_value:
realized here by the free pointer . 13 This may not be true eventually , because memories may get lar ge enough so that it would be impossible to run out of free memory in the lifetime of the computer . For example, there are about 3× 1013, microseconds in a year , so if we were to cons  once per microsecond we would need about 1015 cells of memory to build a machine that could operate for 30 years without running out of memory . That much memory seems absurdly lar ge by today's standards, but it is not physically impossible. On the other hand, processors are getting faster and a future computer may have lar ge numbers of processors operating in parallel on a single memory , so it may be possible to use up memory much faster than we have postulated. 14 We assume here that the stack is represented as a list as described in section 5.3.1 , so that items on the stack are accessible via the pointer in the stack register . 15 This idea was invented and first implemented by Minsky , as part of the implementation of


key: chroma:document
string_value:
 Lisp for the PDP-1 at the MIT Research Laboratory of Electronics. It was further developed by Fenichel and Yochelson (1969) for use in the Lisp implementation for the Multics time-sharing system. Later , Baker (1978) developed a “real-time” version of the method, which does not require the computation to stop during garbage collection. Baker's idea was extended by Hewitt, Lieberman, and Moon (see Lieberman and Hewitt 1983) to take advantage of the fact that some structure is more volatile and other structure is more permanent. An alternative commonly used garbage-collection technique is the mark-sweep  method. This consists of tracing all the structure accessible from the machine registers and marking each pair we reach. We then scan all of memory , and any location that is unmarked is “swept up” as garbage and made available for reuse. A full discussion of the mark-sweep method can be found in Allen 1978. The Minsky-Fenichel-Y ochelson algorithm is the dominant algorithm in use for lar ge-memory systems bec


key: chroma:document
string_value:
ause it examines only the useful part of memory . This is in contrast to mark-sweep, in which the sweep phase must check all of memory . A second advantage of stop-and-copy is that it is a compacting  garbage collector . That is, at the end of the garbage-collection phase the useful data will have been moved to consecutive memory locations, with all garbage pairs compressed out. This can be an extremely important performance consideration in machines with virtual memory , in which accesses to widely separated memory addresses may require extra paging operations. 16 This list of registers does not include the registers used by the storage-allocation system – root , the-cars , the-cdrs , and the other registers that will be introduced in this section. 17 The term broken heart  was coined by David Cressey , who wrote a garbage collector for MDL, a dialect of Lisp developed at MIT during the early 1970s.18 The garbage collector uses the low-level predicate pointer-to-pair?  instead of the list-structure pair?  op


key: chroma:document
string_value:
eration because in a real system there might be various things that are treated as pairs for garbage-collection purposes. For example, in a Scheme system that conforms to the IEEE standard a procedure object may be implemented as a special kind of “pair” that doesn't satisfy the pair? predicate. For simulation purposes, pointer-to-pair?  can be implemented as pair? .5.4  The Explicit-Control Evaluator In section 5.1 we saw how to transform simple Scheme programs into descriptions of register machines. We will now perform this transformation on a more complex program, the metacircular evaluator of sections 4.1.1 - 4.1.4 , which shows how the behavior of a Scheme interpreter can be described in terms of the procedures eval  and apply . The explicit-contr ol evaluator  that we develop in this section shows how the underlying procedure-calling and ar gument-passing mechanisms used in the evaluation process can be described in terms of operations on registers and stacks. In addition, the explicit-control evaluator


key: chroma:document
string_value:
 can serve as an implementation of a Scheme interpreter , written in a language that is very similar to the native machine language of conventional computers. The evaluator can be executed by the register -machine simulator of section 5.2. Alternatively , it can be used as a starting point for building a machine-language implementation of a Scheme evaluator , or even a special-purpose machine for evaluating Scheme expressions. Figure 5.16 shows such a hardware implementation: a silicon chip that acts as an evaluator for Scheme. The chip designers started with the data-path and controller specifications for a register machine similar to the evaluator described in this section and used design automation programs to construct the integrated-circuit layout.19 Registers and operations In designing the explicit-control evaluator , we must specify the operations to be used in our register machine. We described the metacircular evaluator in terms of abstract syntax, using procedures such as quoted?  and make- procedu


key: chroma:document
string_value:
re . In implementing the register machine, we could expand these procedures into sequences of elementary list-structure memory operations, and implement these operations on our register machine. However , this would make our evaluator very long, obscuring the basic structure with details. To clarify the presentation, we will include as primitive operations of the register machine the syntax procedures given in section 4.1.2  and the procedures for representing environments and other run-time data given in sections 4.1.3  and 4.1.4 . In order to completely specify an evaluator that could be programmed in a low-level machine language or implemented inhardware, we would replace these operations by more elementary operations, using the list-structure implementation we described in section 5.3. Figur e 5.16:   A silicon-chip implementation of an evaluator for Scheme. Our Scheme evaluator register machine includes a stack and seven registers: exp, env, val, continue , proc , argl , and unev . Exp is used to hold th


key: chroma:document
string_value:
e expression to be evaluated, and env contains the environment in which the evaluation is to be performed. At the end of an evaluation, val contains the value obtained by evaluating the expression in the designated environment. The continue  register is used to implement recursion, as explained in section 5.1.4 . (The evaluator needs to call itself recursively , since evaluating an expression requires evaluating its subexpressions.) The registers proc , argl , and unev  are used in evaluating combinations. We will not provide a data-path diagram to show how the registers and operations of the evaluator are connected, nor will we give the complete list of machine operations. These are implicit in the evaluator's controller , which will be presented in detail. 5.4.1  The Cor e of the Explicit-Contr ol EvaluatorThe central element in the evaluator is the sequence of instructions beginning at eval-dispatch . This corresponds to the eval  procedure of the metacircular evaluator described in section 4.1.1 . When th


key: chroma:document
string_value:
e controller starts at eval-dispatch , it evaluates the expression specified by exp in the environment specified by env. When evaluation is complete, the controller will go to the entry point stored in continue , and the val register will hold the value of the expression. As with the metacircular eval , the structure of eval-dispatch  is a case analysis on the syntactic type of the expression to be evaluated.20 eval-dispatch     (test (op self-evaluating?) (reg exp))     (branch (label ev-self-eval))     (test (op variable?) (reg exp))     (branch (label ev-variable))     (test (op quoted?) (reg exp))     (branch (label ev-quoted))     (test (op assignment?) (reg exp))     (branch (label ev-assignment))     (test (op definition?) (reg exp))     (branch (label ev-definition))     (test (op if?) (reg exp))     (branch (label ev-if))     (test (op lambda?) (reg exp))     (branch (label ev-lambda))     (test (op begin?) (reg exp))     (branch (label ev-begin))     (test (op application?) (reg exp))     (branch (l


key: chroma:document
string_value:
abel ev-application))     (goto (label unknown-expression-type))   Evaluating simple expr essions Numbers and strings (which are self-evaluating), variables, quotations, and lambda  expressions have no subexpressions to be evaluated. For these, the evaluator simply places the correct value in the val register and continuesexecution at the entry point specified by continue . Evaluation of simple expressions is performed by the following controller code: ev-self-eval     (assign val (reg exp))     (goto (reg continue))   ev-variable     (assign val (op lookup-variable-value) (reg exp) (reg env))     (goto (reg continue))   ev-quoted     (assign val (op text-of-quotation) (reg exp))     (goto (reg continue))   ev-lambda     (assign unev (op lambda-parameters) (reg exp))     (assign exp (op lambda-body) (reg exp))     (assign val (op make-procedure)                 (reg unev) (reg exp) (reg env))     (goto (reg continue))   Observe how ev-lambda  uses the unev  and exp registers to hold the parameters and body of


key: chroma:document
string_value:
 the lambda expression so that they can be passed to the make-procedure  operation, along with the environment in env. Evaluating pr ocedur e applications A procedure application is specified by a combination containing an operator and operands. The operator is a subexpression whose value is a procedure, and the operands are subexpressions whose values are the arguments to which the procedure should be applied. The metacircular eval handles applications by calling itself recursively to evaluate each element of the combination, and then passing the results to apply , which performs the actual procedure application. The explicit-control evaluator does the same thing; these recursive calls are implemented by goto  instructions, together with use of the stack to save registers that will be restored after the recursive call returns. Before each call we will be careful to identify which registers must be saved (because their values will be needed later).21We begin the evaluation of an application by evaluating the 


key: chroma:document
string_value:
operator to produce a procedure, which will later be applied to the evaluated operands. To evaluate the operator , we move it to the exp register and go to eval- dispatch . The environment in the env register is already the correct one in which to evaluate the operator . However , we save env because we will need it later to evaluate the operands. We also extract the operands into unev  and save this on the stack. We set up continue  so that eval-dispatch  will resume at ev-appl-did-operator  after the operator has been evaluated. First, however , we save the old value of continue , which tells the controller where to continue after the application. ev-application     (save continue)     (save env)     (assign unev (op operands) (reg exp))     (save unev)     (assign exp (op operator) (reg exp))     (assign continue (label ev-appl-did-operator))     (goto (label eval-dispatch))   Upon returning from evaluating the operator subexpression, we proceed to evaluate the operands of the combination and to accumulate


key: chroma:document
string_value:
 the resulting arguments in a list, held in argl . First we restore the unevaluated operands and the environment. We initialize argl  to an empty list. Then we assign to the proc  register the procedure that was produced by evaluating the operator . If there are no operands, we go directly to apply-dispatch . Otherwise we save proc  on the stack and start the ar gument-evaluation loop:22 ev-appl-did-operator     (restore unev)                  ; the operands     (restore env)     (assign argl (op empty-arglist))     (assign proc (reg val))         ; the operator     (test (op no-operands?) (reg unev))     (branch (label apply-dispatch))     (save proc)  Each cycle of the ar gument-evaluation loop evaluates an operand from the list in unev  and accumulates the result into argl . To evaluate an operand, we place it in the exp register and go to eval-dispatch , after setting continue  so that execution will resume with the ar gument-accumulation phase. But first we save the ar guments accumulated so far (held in


key: chroma:document
string_value:
 argl ), the environment (held in env), and the remaining operands to be evaluated (held in unev ). A special case is made for the evaluation of the last operand, which is handled at ev-appl-last-arg . ev-appl-operand-loop     (save argl)     (assign exp (op first-operand) (reg unev))     (test (op last-operand?) (reg unev))     (branch (label ev-appl-last-arg))     (save env)     (save unev)     (assign continue (label ev-appl-accumulate-arg))     (goto (label eval-dispatch))   When an operand has been evaluated, the value is accumulated into the list held in argl . The operand is then removed from the list of unevaluated operands in unev , and the ar gument-evaluation continues. ev-appl-accumulate-arg     (restore unev)     (restore env)     (restore argl)     (assign argl (op adjoin-arg) (reg val) (reg argl))     (assign unev (op rest-operands) (reg unev))     (goto (label ev-appl-operand-loop))   Evaluation of the last ar gument is handled dif ferently . There is no need to save the environment or the lis


key: chroma:document
string_value:
t of unevaluated operands before going to eval-dispatch , since they will not be required after the last operand is evaluated. Thus, we return from the evaluation to a special entry point ev- appl-accum-last-arg , which restores the ar gument list, accumulates the new ar gument, restores the saved procedure, and goes of f to perform the application.23ev-appl-last-arg     (assign continue (label ev-appl-accum-last-arg))     (goto (label eval-dispatch))   ev-appl-accum-last-arg     (restore argl)     (assign argl (op adjoin-arg) (reg val) (reg argl))     (restore proc)     (goto (label apply-dispatch))   The details of the ar gument-evaluation loop determine the order in which the interpreter evaluates the operands of a combination (e.g., left to right or right to left – see exercise 3.8). This order is not determined by the metacircular evaluator , which inherits its control structure from the underlying Scheme in which it is implemented.24 Because the first- operand  selector (used in ev-appl-operand-loop  to


key: chroma:document
string_value:
 extract successive operands from unev ) is implemented as car and the rest-operands  selector is implemented as cdr, the explicit-control evaluator will evaluate the operands of a combination in left-to-right order . Procedur e application The entry point apply-dispatch  corresponds to the apply  procedure of the metacircular evaluator . By the time we get to apply-dispatch , the proc register contains the procedure to apply and argl  contains the list of evaluated ar guments to which it must be applied. The saved value of continue  (originally passed to eval-dispatch  and saved at ev- application ), which tells where to return with the result of the procedure application, is on the stack. When the application is complete, the controller transfers to the entry point specified by the saved continue , with the result of the application in val. As with the metacircular apply , there are two cases to consider . Either the procedure to be applied is a primitive or it is a compound procedure. apply-dispatch     (t


key: chroma:document
string_value:
est (op primitive-procedure?) (reg proc))     (branch (label primitive-apply))     (test (op compound-procedure?) (reg proc))     (branch (label compound-apply))     (goto (label unknown-procedure-type))   We assume that each primitive is implemented so as to obtain its ar guments from argl  and place its result in val. To specify how the machine handles primitives, we would have to provide a sequence of controller instructions to implement each primitive and arrange for primitive-apply  to dispatch to the instructions for the primitive identified by the contents of proc . Since we are interested in the structure of the evaluation process rather than the details of the primitives, we will instead just use an apply-primitive- procedure  operation that applies the procedure in proc  to the ar guments in argl . For the purpose of simulating the evaluator with the simulator of section 5.2 we use the procedure apply-primitive-procedure , which calls on the underlying Scheme system to perform the application, just 


key: chroma:document
string_value:
as we did for the metacircular evaluator in section 4.1.4 . After computing the value of the primitive application, we restore continue  and go to the designated entry point. primitive-apply     (assign val (op apply-primitive-procedure)                 (reg proc)                 (reg argl))     (restore continue)     (goto (reg continue))   To apply a compound procedure, we proceed just as with the metacircular evaluator . We construct a frame that binds the procedure's parameters to the arguments, use this frame to extend the environment carried by the procedure, and evaluate in this extended environment the sequence of expressions that forms the body of the procedure. Ev-sequence , described below in section 5.4.2 , handles the evaluation of the sequence. compound-apply     (assign unev (op procedure-parameters) (reg proc))     (assign env (op procedure-environment) (reg proc))     (assign env (op extend-environment)                 (reg unev) (reg argl) (reg env))    (assign unev (op procedure-body) (reg 


key: chroma:document
string_value:
proc))     (goto (label ev-sequence))   Compound-apply  is the only place in the interpreter where the env register is ever assigned a new value. Just as in the metacircular evaluator , the new environment is constructed from the environment carried by the procedure, together with the ar gument list and the corresponding list of variables to be bound. 5.4.2  Sequence Evaluation and T ail Recursion The portion of the explicit-control evaluator at ev-sequence  is analogous to the metacircular evaluator's eval-sequence  procedure. It handles sequences of expressions in procedure bodies or in explicit begin  expressions. Explicit begin  expressions are evaluated by placing the sequence of expressions to be evaluated in unev , saving continue  on the stack, and jumping to ev-sequence . ev-begin     (assign unev (op begin-actions) (reg exp))     (save continue)     (goto (label ev-sequence))   The implicit sequences in procedure bodies are handled by jumping to ev- sequence  from compound-apply , at which point con


key: chroma:document
string_value:
tinue  is already on the stack, having been saved at ev-application . The entries at ev-sequence  and ev-sequence-continue  form a loop that successively evaluates each expression in a sequence. The list of unevaluated expressions is kept in unev . Before evaluating each expression, we check to see if there are additional expressions to be evaluated in the sequence. If so, we save the rest of the unevaluated expressions (held in unev ) and the environment in which these must be evaluated (held in env) and call eval-dispatch  to evaluate the expression. The two saved registers are restored upon the return from this evaluation, at ev-sequence- continue .The final expression in the sequence is handled dif ferently , at the entry point ev-sequence-last-exp . Since there are no more expressions to be evaluated after this one, we need not save unev  or env before going to eval-dispatch . The value of the whole sequence is the value of the last expression, so after the evaluation of the last expression there is noth


key: chroma:document
string_value:
ing left to do except continue at the entry point currently held on the stack (which was saved by ev-application  or ev-begin .) Rather than setting up continue  to arrange for eval-dispatch  to return here and then restoring continue  from the stack and continuing at that entry point, we restore continue  from the stack before going to eval-dispatch , so that eval- dispatch  will continue at that entry point after evaluating the expression. ev-sequence     (assign exp (op first-exp) (reg unev))     (test (op last-exp?) (reg unev))     (branch (label ev-sequence-last-exp))     (save unev)     (save env)     (assign continue (label ev-sequence-continue))     (goto (label eval-dispatch))   ev-sequence-continue     (restore env)     (restore unev)     (assign unev (op rest-exps) (reg unev))     (goto (label ev-sequence))   ev-sequence-last-exp     (restore continue)     (goto (label eval-dispatch))   Tail recursion In chapter 1 we said that the process described by a procedure such as (define (sqrt-iter guess x)


key: chroma:document
string_value:
     (if (good-enough? guess x)         guess        (sqrt-iter (improve guess x)                    x)))   is an iterative process. Even though the procedure is syntactically recursive (defined in terms of itself), it is not logically necessary for an evaluator to save information in passing from one call to sqrt-iter  to the next.25 An evaluator that can execute a procedure such as sqrt-iter  without requiring increasing storage as the procedure continues to call itself is called a tail- recursive  evaluator . The metacircular implementation of the evaluator in chapter 4 does not specify whether the evaluator is tail-recursive, because that evaluator inherits its mechanism for saving state from the underlying Scheme. With the explicit-control evaluator , however , we can trace through the evaluation process to see when procedure calls cause a net accumulation of information on the stack. Our evaluator is tail-recursive, because in order to evaluate the final expression of a sequence we transfer directly to 


key: chroma:document
string_value:
eval-dispatch  without saving any information on the stack. Hence, evaluating the final expression in a sequence – even if it is a procedure call (as in sqrt-iter , where the if expression, which is the last expression in the procedure body , reduces to a call to sqrt-iter ) – will not cause any information to be accumulated on the stack.26 If we did not think to take advantage of the fact that it was unnecessary to save information in this case, we might have implemented eval-sequence by treating all the expressions in a sequence in the same way – saving the registers, evaluating the expression, returning to restore the registers, and repeating this until all the expressions have been evaluated:27 ev-sequence     (test (op no-more-exps?) (reg unev))     (branch (label ev-sequence-end))     (assign exp (op first-exp) (reg unev))     (save unev)     (save env)     (assign continue (label ev-sequence-continue))     (goto (label eval-dispatch))  ev-sequence-continue     (restore env)     (restore unev)     (assi


key: chroma:document
string_value:
gn unev (op rest-exps) (reg unev))     (goto (label ev-sequence))   ev-sequence-end     (restore continue)     (goto (reg continue))   This may seem like a minor change to our previous code for evaluation of a sequence: The only dif ference is that we go through the save-restore cycle for the last expression in a sequence as well as for the others. The interpreter will still give the same value for any expression. But this change is fatal to the tail-recursive implementation, because we must now return after evaluating the final expression in a sequence in order to undo the (useless) register saves. These extra saves will accumulate during a nest of procedure calls. Consequently , processes such as sqrt-iter  will require space proportional to the number of iterations rather than requiring constant space. This dif ference can be significant. For example, with tail recursion, an infinite loop can be expressed using only the procedure-call mechanism: (define (count n)     (newline)     (display n)     (count (+


key: chroma:document
string_value:
 n 1)))   Without tail recursion, such a procedure would eventually run out of stack space, and expressing a true iteration would require some control mechanism other than procedure call. 5.4.3  Conditionals, Assignments, and Definitions As with the metacircular evaluator , special forms are handled by selectively evaluating fragments of the expression. For an if expression, we must evaluate the predicate and decide, based on the value of predicate, whether to evaluate the consequent or the alternative.Before evaluating the predicate, we save the if expression itself so that we can later extract the consequent or alternative. We also save the environment, which we will need later in order to evaluate the consequent or the alternative, and we save continue , which we will need later in order to return to the evaluation of the expression that is waiting for the value of the if. ev-if    (save exp)                    ; save expression for later     (save env)     (save continue)     (assign continue (label ev-if


key: chroma:document
string_value:
-decide))     (assign exp (op if-predicate) (reg exp))     (goto (label eval-dispatch))  ; evaluate the predicate   When we return from evaluating the predicate, we test whether it was true or false and, depending on the result, place either the consequent or the alternative in exp before going to eval-dispatch . Notice that restoring env and continue  here sets up eval-dispatch  to have the correct environment and to continue at the right place to receive the value of the if expression. ev-if-decide     (restore continue)     (restore env)     (restore exp)     (test (op true?) (reg val))     (branch (label ev-if-consequent))     ev-if-alternative     (assign exp (op if-alternative) (reg exp))     (goto (label eval-dispatch))   ev-if-consequent     (assign exp (op if-consequent) (reg exp))     (goto (label eval-dispatch))   Assignments and definitionsAssignments are handled by ev-assignment , which is reached from eval- dispatch  with the assignment expression in exp. The code at ev- assignment  first evalua


key: chroma:document
string_value:
tes the value part of the expression and then installs the new value in the environment. Set-variable-value!  is assumed to be available as a machine operation. ev-assignment     (assign unev (op assignment-variable) (reg exp))     (save unev)                   ; save variable for later     (assign exp (op assignment-value) (reg exp))     (save env)     (save continue)     (assign continue (label ev-assignment-1))     (goto (label eval-dispatch))  ; evaluate the assignment value   ev-assignment-1     (restore continue)     (restore env)     (restore unev)     (perform      (op set-variable-value!) (reg unev) (reg val) (reg env))     (assign val (const ok))     (goto (reg continue))   Definitions are handled in a similar way: ev-definition     (assign unev (op definition-variable) (reg exp))     (save unev)                   ; save variable for later     (assign exp (op definition-value) (reg exp))     (save env)     (save continue)     (assign continue (label ev-definition-1))     (goto (label eval-dispatch))


key: chroma:document
string_value:
  ; evaluate the definition value   ev-definition-1     (restore continue)     (restore env)     (restore unev)    (perform      (op define-variable!) (reg unev) (reg val) (reg env))     (assign val (const ok))     (goto (reg continue))   Exer cise 5.23.   Extend the evaluator to handle derived expressions such as cond , let, and so on (section 4.1.2 ). You may “cheat” and assume that the syntax transformers such as cond->if  are available as machine operations.28 Exer cise 5.24.   Implement cond  as a new basic special form without reducing it to if. You will have to construct a loop that tests the predicates of successive cond  clauses until you find one that is true, and then use ev- sequence  to evaluate the actions of the clause. Exer cise 5.25.   Modify the evaluator so that it uses normal-order evaluation, based on the lazy evaluator of section 4.2. 5.4.4  Running the Evaluator With the implementation of the explicit-control evaluator we come to the end of a development, begun in chapter 1, in which we


key: chroma:document
string_value:
 have explored successively more precise models of the evaluation process. We started with the relatively informal substitution model, then extended this in chapter 3 to the environment model, which enabled us to deal with state and change. In the metacircular evaluator of chapter 4, we used Scheme itself as a language for making more explicit the environment structure constructed during evaluation of an expression. Now , with register machines, we have taken a close look at the evaluator's mechanisms for storage management, ar gument passing, and control. At each new level of description, we have had to raise issues and resolve ambiguities that were not apparent at the previous, less precise treatment of evaluation. To understand the behavior of the explicit- control evaluator , we can simulate it and monitor its performance. We will install a driver loop in our evaluator machine. This plays the role of the driver-loop  procedure of section 4.1.4 . The evaluator will repeatedly print a prompt, read an expres


key: chroma:document
string_value:
sion, evaluate the expression by going toeval-dispatch , and print the result. The following instructions form the beginning of the explicit-control evaluator's controller sequence:29 read-eval-print-loop     (perform (op initialize-stack))     (perform      (op prompt-for-input) (const ";;; EC-Eval input:"))     (assign exp (op read))     (assign env (op get-global-environment))     (assign continue (label print-result))     (goto (label eval-dispatch))   print-result     (perform      (op announce-output) (const ";;; EC-Eval value:"))     (perform (op user-print) (reg val))     (goto (label read-eval-print-loop))   When we encounter an error in a procedure (such as the “unknown procedure type error” indicated at apply-dispatch ), we print an error message and return to the driver loop.30 unknown-expression-type     (assign val (const unknown-expression-type-error))     (goto (label signal-error))   unknown-procedure-type     (restore continue)    ; clean up stack (from apply-dispatch )    (assign val (const


key: chroma:document
string_value:
 unknown-procedure-type-error))     (goto (label signal-error))   signal-error     (perform (op user-print) (reg val))     (goto (label read-eval-print-loop))   For the purposes of the simulation, we initialize the stack each time through the driver loop, since it might not be empty after an error (such as an undefined variable) interrupts an evaluation.31If we combine all the code fragments presented in sections 5.4.1 -5.4.4 , we can create an evaluator machine model that we can run using the register - machine simulator of section 5.2. (define eceval     (make-machine      '(exp env val proc argl continue unev)      eceval-operations     '(      read-eval-print-loop         <entire machine controller as given above >     )))  We must define Scheme procedures to simulate the operations used as primitives by the evaluator . These are the same procedures we used for the metacircular evaluator in section 4.1, together with the few additional ones defined in footnotes throughout section 5.4. (define eceval-opera


key: chroma:document
string_value:
tions     (list (list 'self-evaluating? self-evaluating)           <complete list of operations for eceval machine> ))  Finally , we can initialize the global environment and run the evaluator: (define the-global-environment (setup-environment))     (start eceval)   ;;; EC-Eval input:   (define (append x y)     (if (null? x)         y        (cons (car x)               (append (cdr x) y))))   ;;; EC-Eval value:   ok  ;;; EC-Eval input:   (append '(a b c) '(d e f))  ;;; EC-Eval value:   (a b c d e f)   Of course, evaluating expressions in this way will take much longer than if we had directly typed them into Scheme, because of the multiple levels of simulation involved. Our expressions are evaluated by the explicit-control- evaluator machine, which is being simulated by a Scheme program, which is itself being evaluated by the Scheme interpreter . Monitoring the performance of the evaluator Simulation can be a powerful tool to guide the implementation of evaluators. Simulations make it easy not only to explore 


key: chroma:document
string_value:
variations of the register -machine design but also to monitor the performance of the simulated evaluator . For example, one important factor in performance is how ef ficiently the evaluator uses the stack. We can observe the number of stack operations required to evaluate various expressions by defining the evaluator register machine with the version of the simulator that collects statistics on stack use (section 5.2.4 ), and adding an instruction at the evaluator's print-result  entry point to print the statistics: print-result     (perform (op print-stack-statistics)) ; added instruction     (perform      (op announce-output) (const ";;; EC-Eval value:"))     ... ; same as before   Interactions with the evaluator now look like this: ;;; EC-Eval input:   (define (factorial n)     (if (= n 1)         1        (* (factorial (- n 1)) n)))   (total-pushes = 3 maximum-depth = 3)   ;;; EC-Eval value:   ok  ;;; EC-Eval input:  (factorial 5)   (total-pushes = 144 maximum-depth = 28)   ;;; EC-Eval value:   120  Note


key: chroma:document
string_value:
 that the driver loop of the evaluator reinitializes the stack at the start of each interaction, so that the statistics printed will refer only to stack operations used to evaluate the previous expression. Exer cise 5.26.   Use the monitored stack to explore the tail-recursive property of the evaluator (section 5.4.2 ). Start the evaluator and define the iterative factorial  procedure from section 1.2.1 : (define (factorial n)     (define (iter product counter)       (if (> counter n)           product           (iter (* counter product)                 (+ counter 1))))     (iter 1 1))   Run the procedure with some small values of n. Record the maximum stack depth and the number of pushes required to compute n! for each of these values. a. You will find that the maximum depth required to evaluate n! is independent of n. What is that depth? b. Determine from your data a formula in terms of n for the total number of push operations used in evaluating n! for any n > 1. Note that the number of operations used is 


key: chroma:document
string_value:
a linear function of n and is thus determined by two constants. Exer cise 5.27.   For comparison with exercise 5.26, explore the behavior of the following procedure for computing factorials recursively: (define (factorial n)     (if (= n 1)        1        (* (factorial (- n 1)) n)))   By running this procedure with the monitored stack, determine, as a function of n, the maximum depth of the stack and the total number of pushes used in evaluating n! for n > 1. (Again, these functions will be linear .) Summarize your experiments by filling in the following table with the appropriate expressions in terms of n: Maximum depth Number of pushes Recursive factorial Iterative factorial The maximum depth is a measure of the amount of space used by the evaluator in carrying out the computation, and the number of pushes correlates well with the time required. Exer cise 5.28.   Modify the definition of the evaluator by changing eval- sequence  as described in section 5.4.2  so that the evaluator is no longer tail- recurs


key: chroma:document
string_value:
ive. Rerun your experiments from exercises 5.26 and 5.27 to demonstrate that both versions of the factorial  procedure now require space that grows linearly with their input. Exer cise 5.29.   Monitor the stack operations in the tree-recursive Fibonacci computation: (define (fib n)     (if (< n 2)         n        (+ (fib (- n 1)) (fib (- n 2)))))   a. Give a formula in terms of n for the maximum depth of the stack required to compute Fib(n) for n > 2. Hint: In section 1.2.2  we ar gued that the space used by this process grows linearly with n.b. Give a formula for the total number of pushes used to compute Fib(n) for n > 2. You should find that the number of pushes (which correlates well with the time used) grows exponentially with n. Hint: Let S(n) be the number of pushes used in computing Fib(n). You should be able to ar gue that there is a formula that expresses S(n) in terms of S(n - 1), S(n - 2), and some fixed “overhead” constant k that is independent of n. Give the formula, and say what k is. Then sho


key: chroma:document
string_value:
w that S(n) can be expressed as a Fib(n + 1) + b and give the values of a and b. Exer cise 5.30.   Our evaluator currently catches and signals only two kinds of errors – unknown expression types and unknown procedure types. Other errors will take us out of the evaluator read-eval-print loop. When we run the evaluator using the register -machine simulator , these errors are caught by the underlying Scheme system. This is analogous to the computer crashing when a user program makes an error .32 It is a lar ge project to make a real error system work, but it is well worth the ef fort to understand what is involved here. a. Errors that occur in the evaluation process, such as an attempt to access an unbound variable, could be caught by changing the lookup operation to make it return a distinguished condition code, which cannot be a possible value of any user variable. The evaluator can test for this condition code and then do what is necessary to go to signal-error . Find all of the places in the evaluator where 


key: chroma:document
string_value:
such a change is necessary and fix them. This is lots of work. b. Much worse is the problem of handling errors that are signaled by applying primitive procedures, such as an attempt to divide by zero or an attempt to extract the car of a symbol. In a professionally written high- quality system, each primitive application is checked for safety as part of the primitive. For example, every call to car could first check that the argument is a pair . If the ar gument is not a pair , the application would return a distinguished condition code to the evaluator , which would then report the failure. We could arrange for this in our register -machine simulator by making each primitive procedure check for applicability and returning an appropriate distinguished condition code on failure. Then the primitive- apply  code in the evaluator can check for the condition code and go tosignal-error  if necessary . Build this structure and make it work. This is a major project. 19 See Batali et al. 1982 for more information on t


key: chroma:document
string_value:
he chip and the method by which it was designed. 20 In our controller , the dispatch is written as a sequence of test  and branch  instructions. Alternatively , it could have been written in a data-directed style (and in a real system it probably would have been) to avoid the need to perform sequential tests and to facilitate the definition of new expression types. A machine designed to run Lisp would probably include a dispatch-on-type instruction that would ef ficiently execute such data-directed dispatches. 21 This is an important but subtle point in translating algorithms from a procedural language, such as Lisp, to a register -machine language. As an alternative to saving only what is needed, we could save all the registers (except val) before each recursive call. This is called a framed-stack  discipline. This would work but might save more registers than necessary; this could be an important consideration in a system where stack operations are expensive. Saving registers whose contents will not be need


key: chroma:document
string_value:
ed later may also hold onto useless data that could otherwise be garbage-collected, freeing space to be reused. 22 We add to the evaluator data-structure procedures in section 4.1.3  the following two procedures for manipulating ar gument lists: (define (empty-arglist) '())     (define (adjoin-arg arg arglist)     (append arglist (list arg)))   We also use an additional syntax procedure to test for the last operand in a combination: (define (last-operand? ops)     (null? (cdr ops)))   23 The optimization of treating the last operand specially is known as evlis tail r ecursion  (see Wand 1980). We could be somewhat more ef ficient in the ar gument evaluation loop if we made evaluation of the first operand a special case too. This would permit us to postpone initializing argl  until after evaluating the first operand, so as to avoid saving argl  in this case. The compiler in section 5.5 performs this optimization. (Compare the construct-arglist  procedure of section 5.5.3 .) 24 The order of operand evaluation i


key: chroma:document
string_value:
n the metacircular evaluator is determined by the order of evaluation of the ar guments to cons  in the procedure list-of-values  of section 4.1.1  (see exercise 4.1). 25 We saw in section 5.1 how to implement such a process with a register machine that had no stack; the state of the process was stored in a fixed set of registers. 26 This implementation of tail recursion in ev-sequence  is one variety of a well-known optimization technique used by many compilers. In compiling a procedure that ends with a procedure call, one can replace the call by a jump to the called procedure's entry point. Building this strategy into theinterpreter , as we have done in this section, provides the optimization uniformly throughout the language. 27 We can define no-more-exps?  as follows: (define (no-more-exps? seq) (null? seq))   28 This isn't really cheating. In an actual implementation built from scratch, we would use our explicit-control evaluator to interpret a Scheme program that performs source-level transformations li


key: chroma:document
string_value:
ke cond->if  in a syntax phase that runs before execution. 29 We assume here that read  and the various printing operations are available as primitive machine operations, which is useful for our simulation, but completely unrealistic in practice. These are actually extremely complex operations. In practice, they would be implemented using low-level input-output operations such as transferring single characters to and from a device. To support the get-global-environment  operation we define (define the-global-environment (setup-environment))     (define (get-global-environment)     the-global-environment)   30 There are other errors that we would like the interpreter to handle, but these are not so simple. See exercise 5.30. 31 We could perform the stack initialization only after errors, but doing it in the driver loop will be convenient for monitoring the evaluator's performance, as described below . 32 Regrettably , this is the normal state of af fairs in conventional compiler -based language systems such as


key: chroma:document
string_value:
 C. In UNIXTM the system “dumps core,” and in DOS/W indowsTM it becomes catatonic. The MacintoshTM displays a picture of an exploding bomb and of fers you the opportunity to reboot the computer – if you're lucky .5.5  Compilation The explicit-control evaluator of section 5.4 is a register machine whose controller interprets Scheme programs. In this section we will see how to run Scheme programs on a register machine whose controller is not a Scheme interpreter . The explicit-control evaluator machine is universal – it can carry out any computational process that can be described in Scheme. The evaluator's controller orchestrates the use of its data paths to perform the desired computation. Thus, the evaluator's data paths are universal: They are suf ficient to perform any computation we desire, given an appropriate controller .33 Commercial general-purpose computers are register machines or ganized around a collection of registers and operations that constitute an ef ficient and convenient universal set of da


key: chroma:document
string_value:
ta paths. The controller for a general-purpose machine is an interpreter for a register -machine language like the one we have been using. This language is called the native language  of the machine, or simply machine language . Programs written in machine language are sequences of instructions that use the machine's data paths. For example, the explicit-control evaluator's instruction sequence can be thought of as a machine-language program for a general-purpose computer rather than as the controller for a specialized interpreter machine. There are two common strategies for bridging the gap between higher -level languages and register -machine languages. The explicit-control evaluator illustrates the strategy of interpretation. An interpreter written in the native language of a machine configures the machine to execute programs written in a language (called the source language ) that may dif fer from the native language of the machine performing the evaluation. The primitive procedures of the source language


key: chroma:document
string_value:
 are implemented as a library of subroutines written in the native language of the given machine. A program to be interpreted (called the source program ) is represented as a data structure. The interpreter traverses this data structure, analyzing the source program. As it does so, it simulates the intended behavior of the source program by calling appropriate primitive subroutines from the library . In this section, we explore the alternative strategy of compilation . A compiler for a given source language and machine translates a source program into anequivalent program (called the object pr ogram ) written in the machine's native language. The compiler that we implement in this section translates programs written in Scheme into sequences of instructions to be executed using the explicit-control evaluator machine's data paths.34 Compared with interpretation, compilation can provide a great increase in the efficiency of program execution, as we will explain below in the overview of the compiler . On the othe


key: chroma:document
string_value:
r hand, an interpreter provides a more powerful environment for interactive program development and debugging, because the source program being executed is available at run time to be examined and modified. In addition, because the entire library of primitives is present, new programs can be constructed and added to the system during debugging. In view of the complementary advantages of compilation and interpretation, modern program-development environments pursue a mixed strategy . Lisp interpreters are generally or ganized so that interpreted procedures and compiled procedures can call each other . This enables a programmer to compile those parts of a program that are assumed to be debugged, thus gaining the ef ficiency advantage of compilation, while retaining the interpretive mode of execution for those parts of the program that are in the flux of interactive development and debugging. In section 5.5.7 , after we have implemented the compiler , we will show how to interface it with our interpreter to prod


key: chroma:document
string_value:
uce an integrated interpreter - compiler development system. An overview of the compiler Our compiler is much like our interpreter , both in its structure and in the function it performs. Accordingly , the mechanisms used by the compiler for analyzing expressions will be similar to those used by the interpreter . Moreover , to make it easy to interface compiled and interpreted code, we will design the compiler to generate code that obeys the same conventions of register usage as the interpreter: The environment will be kept in the env register , argument lists will be accumulated in argl , a procedure to be applied will be in proc , procedures will return their answers in val, and the location to which a procedure should return will be kept in continue . In general, the compiler translates a source program into an object program that performs essentially the same register operations as would the interpreter in evaluating the same source program. This description suggests a strategy for implementing a rudiment


key: chroma:document
string_value:
ary compiler: We traverse the expression in the same way the interpreter does. When weencounter a register instruction that the interpreter would perform in evaluating the expression, we do not execute the instruction but instead accumulate it into a sequence. The resulting sequence of instructions will be the object code. Observe the efficiency advantage of compilation over interpretation. Each time the interpreter evaluates an expression – for example, (f 84 96)  – it performs the work of classifying the expression (discovering that this is a procedure application) and testing for the end of the operand list (discovering that there are two operands). With a compiler , the expression is analyzed only once, when the instruction sequence is generated at compile time. The object code produced by the compiler contains only the instructions that evaluate the operator and the two operands, assemble the ar gument list, and apply the procedure (in proc ) to the arguments (in argl ). This is the same kind of optimiza


key: chroma:document
string_value:
tion we implemented in the analyzing evaluator of section 4.1.7 . But there are further opportunities to gain ef ficiency in compiled code. As the interpreter runs, it follows a process that must be applicable to any expression in the language. In contrast, a given segment of compiled code is meant to execute some particular expression. This can make a big dif ference, for example in the use of the stack to save registers. When the interpreter evaluates an expression, it must be prepared for any contingency . Before evaluating a subexpression, the interpreter saves all registers that will be needed later , because the subexpression might require an arbitrary evaluation. A compiler , on the other hand, can exploit the structure of the particular expression it is processing to generate code that avoids unnecessary stack operations. As a case in point, consider the combination (f 84 96) . Before the interpreter evaluates the operator of the combination, it prepares for this evaluation by saving the registers con


key: chroma:document
string_value:
taining the operands and the environment, whose values will be needed later . The interpreter then evaluates the operator to obtain the result in val, restores the saved registers, and finally moves the result from val to proc . However , in the particular expression we are dealing with, the operator is the symbol f, whose evaluation is accomplished by the machine operation lookup-variable-value , which does not alter any registers. The compiler that we implement in this section will take advantage of this fact and generate code that evaluates the operator using the instruction (assign proc (op lookup-variable-value) (const f) (reg env))   This code not only avoids the unnecessary saves and restores but also assigns the value of the lookup directly to proc , whereas the interpreter would obtain theresult in val and then move this to proc . A compiler can also optimize access to the environment. Having analyzed the code, the compiler can in many cases know in which frame a particular variable will be located a


key: chroma:document
string_value:
nd access that frame directly , rather than performing the lookup- variable-value  search. We will discuss how to implement such variable access in section 5.5.6 . Until then, however , we will focus on the kind of register and stack optimizations described above. There are many other optimizations that can be performed by a compiler , such as coding primitive operations “in line” instead of using a general apply  mechanism (see exercise 5.38); but we will not emphasize these here. Our main goal in this section is to illustrate the compilation process in a simplified (but still interesting) context. 5.5.1  Structur e of the Compiler In section 4.1.7  we modified our original metacircular interpreter to separate analysis from execution. We analyzed each expression to produce an execution procedure that took an environment as ar gument and performed the required operations. In our compiler , we will do essentially the same analysis. Instead of producing execution procedures, however , we will generate sequences


key: chroma:document
string_value:
 of instructions to be run by our register machine. The procedure compile  is the top-level dispatch in the compiler . It corresponds to the eval  procedure of section 4.1.1 , the analyze  procedure of section 4.1.7 , and the eval-dispatch  entry point of the explicit-control-evaluator in section 5.4.1 . The compiler , like the interpreters, uses the expression-syntax procedures defined in section 4.1.2 .35 Compile  performs a case analysis on the syntactic type of the expression to be compiled. For each type of expression, it dispatches to a specialized code generator : (define (compile exp target linkage)     (cond ((self-evaluating? exp)            (compile-self-evaluating exp target linkage))           ((quoted? exp) (compile-quoted exp target linkage))           ((variable? exp)            (compile-variable exp target linkage))           ((assignment? exp)            (compile-assignment exp target linkage))           ((definition? exp)            (compile-definition exp target linkage))          ((if? ex


key: chroma:document
string_value:
p) (compile-if exp target linkage))           ((lambda? exp) (compile-lambda exp target linkage))           ((begin? exp)            (compile-sequence (begin-actions exp)                              target                              linkage))           ((cond? exp) (compile (cond->if exp) target linkage))           ((application? exp)            (compile-application exp target linkage))           (else            (error "Unknown expression type -- COMPILE" exp))))   Targets and linkages Compile  and the code generators that it calls take two ar guments in addition to the expression to compile. There is a target, which specifies the register in which the compiled code is to return the value of the expression. There is also a linkage descriptor , which describes how the code resulting from the compilation of the expression should proceed when it has finished its execution. The linkage descriptor can require that the code do one of the following three things: continue at the next instruction in sequence (this


key: chroma:document
string_value:
 is specified by the linkage descriptor next ), return from the procedure being compiled (this is specified by the linkage descriptor return ), or jump to a named entry point (this is specified by using the designated label as the linkage descriptor). For example, compiling the expression 5 (which is self-evaluating) with a tar get of the val register and a linkage of next  should produce the instruction (assign val (const 5))   Compiling the same expression with a linkage of return  should produce the instructions (assign val (const 5))   (goto (reg continue))  In the first case, execution will continue with the next instruction in the sequence. In the second case, we will return from a procedure call. In both cases, the value of the expression will be placed into the tar get val register . Instruction sequences and stack usage Each code generator returns an instruction sequence  containing the object code it has generated for the expression. Code generation for a compound expression is accomplished by combi


key: chroma:document
string_value:
ning the output from simpler code generators for component expressions, just as evaluation of a compound expression is accomplished by evaluating the component expressions. The simplest method for combining instruction sequences is a procedure called append-instruction-sequences . It takes as ar guments any number of instruction sequences that are to be executed sequentially; it appends them and returns the combined sequence. That is, if < seq1> and < seq2> are sequences of instructions, then evaluating (append-instruction-sequences < seq1> <seq2>)  produces the sequence <seq1>  <seq2>  Whenever registers might need to be saved, the compiler's code generators use preserving , which is a more subtle method for combining instruction sequences. Preserving  takes three ar guments: a set of registers and two instruction sequences that are to be executed sequentially . It appends the sequences in such a way that the contents of each register in the set is preserved over the execution of the first sequence, if this 


key: chroma:document
string_value:
is needed for the execution of the second sequence. That is, if the first sequence modifies the register and the second sequence actually needs the register's original contents, then preserving  wraps a save  and a restore  of the register around the first sequence before appending the sequences. Otherwise, preserving  simply returns the appended instruction sequences. Thus, for example, (preserving (list < reg1> <reg2>) <seq1> <seq2>) produces one of the following four sequences of instructions, depending on how <seq1> and < seq2> use < reg1> and < reg2>: By using preserving  to combine instruction sequences the compiler avoids unnecessary stack operations. This also isolates the details of whether or not to generate save  and restore  instructions within the preserving  procedure, separating them from the concerns that arise in writing each of the individual code generators. In fact no save  or restore  instructions are explicitly produced by the code generators. In principle, we could represent an instruct


key: chroma:document
string_value:
ion sequence simply as a list of instructions. Append-instruction-sequences  could then combine instruction sequences by performing an ordinary list append . However , preserving  would then be a complex operation, because it would have to analyze each instruction sequence to determine how the sequence uses its registers. Preserving  would be inefficient as well as complex, because it would have to analyze each of its instruction sequence ar guments, even though these sequences might themselves have been constructed by calls to preserving , in which case their parts would have already been analyzed. To avoid such repetitious analysis we will associate with each instruction sequence some information about its register use. When we construct a basic instruction sequence we will provide this information explicitly , and the procedures that combine instruction sequences will derive register -use information for the combined sequence from the information associated with the component sequences. An instruction sequ


key: chroma:document
string_value:
ence will contain three pieces of information: the set of registers that must be initialized before the instructions in the sequence are executed (these registers are said to be needed  by the sequence), the set of registers whose values are modified by the instructions in the sequence, and the actual instructions (also called statements ) in the sequence.We will represent an instruction sequence as a list of its three parts. The constructor for instruction sequences is thus (define (make-instruction-sequence needs modifies statements)     (list needs modifies statements))   For example, the two-instruction sequence that looks up the value of the variable x in the current environment, assigns the result to val, and then returns, requires registers env and continue  to have been initialized, and modifies register val. This sequence would therefore be constructed as (make-instruction-sequence '(env continue) '(val)    '((assign val              (op lookup-variable-value) (const x) (reg env))      (goto (reg con


key: chroma:document
string_value:
tinue))))   We sometimes need to construct an instruction sequence with no statements: (define (empty-instruction-sequence)     (make-instruction-sequence '() '() '()))   The procedures for combining instruction sequences are shown in section 5.5.4 . Exer cise 5.31.   In evaluating a procedure application, the explicit-control evaluator always saves and restores the env register around the evaluation of the operator , saves and restores env around the evaluation of each operand (except the final one), saves and restores argl  around the evaluation of each operand, and saves and restores proc  around the evaluation of the operand sequence. For each of the following combinations, say which of these save  and restore operations are superfluous and thus could be eliminated by the compiler's preserving  mechanism: (f 'x 'y)     ((f) 'x 'y)     (f (g 'x) y)     (f (g 'x) 'y)  Exer cise 5.32.   Using the preserving  mechanism, the compiler will avoid saving and restoring env around the evaluation of the operator of 


key: chroma:document
string_value:
a combination in the case where the operator is a symbol. We could also build such optimizations into the evaluator . Indeed, the explicit-control evaluator of section 5.4 already performs a similar optimization, by treating combinations with no operands as a special case. a. Extend the explicit-control evaluator to recognize as a separate class of expressions combinations whose operator is a symbol, and to take advantage of this fact in evaluating such expressions. b. Alyssa P . Hacker suggests that by extending the evaluator to recognize more and more special cases we could incorporate all the compiler's optimizations, and that this would eliminate the advantage of compilation altogether . What do you think of this idea? 5.5.2  Compiling Expr essions In this section and the next we implement the code generators to which the compile  procedure dispatches. Compiling linkage code In general, the output of each code generator will end with instructions – generated by the procedure compile-linkage  – that implem


key: chroma:document
string_value:
ent the required linkage. If the linkage is return  then we must generate the instruction (goto (reg continue)) . This needs the continue  register and does not modify any registers. If the linkage is next , then we needn't include any additional instructions. Otherwise, the linkage is a label, and we generate a goto  to that label, an instruction that does not need or modify any registers.36 (define (compile-linkage linkage)     (cond ((eq? linkage 'return)            (make-instruction-sequence '(continue) '()             '((goto (reg continue)))))           ((eq? linkage 'next)            (empty-instruction-sequence))           (else            (make-instruction-sequence '() '()             `((goto (label ,linkage)))))))  The linkage code is appended to an instruction sequence by preserving  the continue  register , since a return  linkage will require the continue  register: If the given instruction sequence modifies continue  and the linkage code needs it, continue  will be saved and restored. (define (en


key: chroma:document
string_value:
d-with-linkage linkage instruction-sequence)     (preserving '(continue)      instruction-sequence      (compile-linkage linkage)))   Compiling simple expr essions The code generators for self-evaluating expressions, quotations, and variables construct instruction sequences that assign the required value to the tar get register and then proceed as specified by the linkage descriptor . (define (compile-self-evaluating exp target linkage)     (end-with-linkage linkage      (make-instruction-sequence '() (list target)       `((assign ,target (const ,exp))))))   (define (compile-quoted exp target linkage)     (end-with-linkage linkage      (make-instruction-sequence '() (list target)       `((assign ,target (const ,(text-of-quotation exp)))))))   (define (compile-variable exp target linkage)     (end-with-linkage linkage      (make-instruction-sequence '(env) (list target)       `((assign ,target                 (op lookup-variable-value)                 (const ,exp)                 (reg env))))))   All these ass


key: chroma:document
string_value:
ignment instructions modify the tar get register , and the one that looks up a variable needs the env register . Assignments and definitions are handled much as they are in the interpreter . We recursively generate code that computes the value to be assigned to the variable, and append to it a two-instruction sequence that actually sets or defines the variable and assigns the value of the whole expression (the symbol ok) to the target register . The recursive compilation has tar get val and linkage next  so thatthe code will put its result into val and continue with the code that is appended after it. The appending is done preserving env, since the environment is needed for setting or defining the variable and the code for the variable value could be the compilation of a complex expression that might modify the registers in arbitrary ways. (define (compile-assignment exp target linkage)     (let ((var (assignment-variable exp))           (get-value-code            (compile (assignment-value exp) 'val 'next)))


key: chroma:document
string_value:
       (end-with-linkage linkage        (preserving '(env)         get-value-code         (make-instruction-sequence '(env val) (list target)          `((perform (op set-variable-value!)                     (const ,var)                     (reg val)                     (reg env))            (assign ,target (const ok))))))))   (define (compile-definition exp target linkage)     (let ((var (definition-variable exp))           (get-value-code            (compile (definition-value exp) 'val 'next)))       (end-with-linkage linkage        (preserving '(env)         get-value-code         (make-instruction-sequence '(env val) (list target)          `((perform (op define-variable!)                     (const ,var)                     (reg val)                     (reg env))            (assign ,target (const ok))))))))   The appended two-instruction sequence requires env and val and modifies the target. Note that although we preserve env for this sequence, we do not preserve val, because the get-value-code  is design


key: chroma:document
string_value:
ed to explicitly place its result in val for use by this sequence. (In fact, if we did preserve val, we would have a bug, because this would cause the previous contents of val to be restored right after the get-value-code  is run.)Compiling conditional expr essions The code for an if expression compiled with a given tar get and linkage has the form  <compilation of predicate, target val, linkage next>   (test (op false?) (reg val))    (branch (label false-branch))   true-branch    <compilation of consequent with given target and given linkage or  after-if >  false-branch    <compilation of alternative with given target and linkage >  after-if   To generate this code, we compile the predicate, consequent, and alternative, and combine the resulting code with instructions to test the predicate result and with newly generated labels to mark the true and false branches and the end of the conditional.37 In this arrangement of code, we must branch around the true branch if the test is false. The only slight complica


key: chroma:document
string_value:
tion is in how the linkage for the true branch should be handled. If the linkage for the conditional is return  or a label, then the true and false branches will both use this same linkage. If the linkage is next , the true branch ends with a jump around the code for the false branch to the label at the end of the conditional. (define (compile-if exp target linkage)     (let ((t-branch (make-label 'true-branch))           (f-branch (make-label 'false-branch))                              (after-if (make-label 'after-if)))       (let ((consequent-linkage              (if (eq? linkage 'next) after-if linkage)))         (let ((p-code (compile (if-predicate exp) 'val 'next))               (c-code                (compile                 (if-consequent exp) target consequent-linkage))               (a-code                (compile (if-alternative exp) target linkage)))           (preserving '(env continue)            p-code            (append-instruction-sequences            (make-instruction-sequence '(val) '()    


key: chroma:document
string_value:
          `((test (op false?) (reg val))                (branch (label ,f-branch))))             (parallel-instruction-sequences              (append-instruction-sequences t-branch c-code)              (append-instruction-sequences f-branch a-code))             after-if))))))   Env is preserved around the predicate code because it could be needed by the true and false branches, and continue  is preserved because it could be needed by the linkage code in those branches. The code for the true and false branches (which are not executed sequentially) is appended using a special combiner parallel- instruction-sequences  described in section 5.5.4 . Note that cond  is a derived expression, so all that the compiler needs to do handle it is to apply the cond->if  transformer (from section 4.1.2 ) and compile the resulting if expression. Compiling sequences The compilation of sequences (from procedure bodies or explicit begin expressions) parallels their evaluation. Each expression of the sequence is compiled – the la


key: chroma:document
string_value:
st expression with the linkage specified for the sequence, and the other expressions with linkage next  (to execute the rest of the sequence). The instruction sequences for the individual expressions are appended to form a single instruction sequence, such that env (needed for the rest of the sequence) and continue  (possibly needed for the linkage at the end of the sequence) are preserved. (define (compile-sequence seq target linkage)     (if (last-exp? seq)         (compile (first-exp seq) target linkage)         (preserving '(env continue)          (compile (first-exp seq) target 'next)          (compile-sequence (rest-exps seq) target linkage))))   Compiling lambda  expr essions Lambda  expressions construct procedures. The object code for a lambda expression must have the form<construct procedure object and assign it to target register >  <linkage>  When we compile the lambda  expression, we also generate the code for the procedure body . Although the body won't be executed at the time of procedure const


key: chroma:document
string_value:
ruction, it is convenient to insert it into the object code right after the code for the lambda . If the linkage for the lambda  expression is a label or return , this is fine. But if the linkage is next , we will need to skip around the code for the procedure body by using a linkage that jumps to a label that is inserted after the body . The object code thus has the form  <construct procedure object and assign it to target register >   <code for given linkage >or (goto (label after-lambda))    <compilation of procedure body >  after-lambda   Compile-lambda  generates the code for constructing the procedure object followed by the code for the procedure body . The procedure object will be constructed at run time by combining the current environment (the environment at the point of definition) with the entry point to the compiled procedure body (a newly generated label).38 (define (compile-lambda exp target linkage)     (let ((proc-entry (make-label 'entry))           (after-lambda (make-label 'after-lambda))) 


key: chroma:document
string_value:
      (let ((lambda-linkage              (if (eq? linkage 'next) after-lambda linkage)))         (append-instruction-sequences          (tack-on-instruction-sequence           (end-with-linkage lambda-linkage            (make-instruction-sequence '(env) (list target)             `((assign ,target                       (op make-compiled-procedure)                       (label ,proc-entry)                       (reg env)))))           (compile-lambda-body exp proc-entry))          after-lambda))))   Compile-lambda  uses the special combiner tack-on-instruction-sequence (section 5.5.4 ) rather than append-instruction-sequences  to append theprocedure body to the lambda  expression code, because the body is not part of the sequence of instructions that will be executed when the combined sequence is entered; rather , it is in the sequence only because that was a convenient place to put it. Compile-lambda-body  constructs the code for the body of the procedure. This code begins with a label for the entry point. Nex


key: chroma:document
string_value:
t come instructions that will cause the run-time evaluation environment to switch to the correct environment for evaluating the procedure body – namely , the definition environment of the procedure, extended to include the bindings of the formal parameters to the arguments with which the procedure is called. After this comes the code for the sequence of expressions that makes up the procedure body . The sequence is compiled with linkage return  and tar get val so that it will end by returning from the procedure with the procedure result in val. (define (compile-lambda-body exp proc-entry)     (let ((formals (lambda-parameters exp)))       (append-instruction-sequences        (make-instruction-sequence '(env proc argl) '(env)         `(,proc-entry           (assign env (op compiled-procedure-env) (reg proc))           (assign env                   (op extend-environment)                   (const ,formals)                   (reg argl)                   (reg env))))        (compile-sequence (lambda-body exp) 'va


key: chroma:document
string_value:
l 'return))))   5.5.3  Compiling Combinations The essence of the compilation process is the compilation of procedure applications. The code for a combination compiled with a given tar get and linkage has the form <compilation of operator, target proc, linkage next>  <evaluate operands and construct argument list in argl>  <compilation of procedure call with given target and linkage >  The registers env, proc , and argl  may have to be saved and restored during evaluation of the operator and operands. Note that this is the only place in thecompiler where a tar get other than val is specified. The required code is generated by compile-application . This recursively compiles the operator , to produce code that puts the procedure to be applied into proc , and compiles the operands, to produce code that evaluates the individual operands of the application. The instruction sequences for the operands are combined (by construct-arglist ) with code that constructs the list of arguments in argl , and the resulting ar g


key: chroma:document
string_value:
ument-list code is combined with the procedure code and the code that performs the procedure call (produced by compile-procedure-call ). In appending the code sequences, the env register must be preserved around the evaluation of the operator (since evaluating the operator might modify env, which will be needed to evaluate the operands), and the proc  register must be preserved around the construction of the ar gument list (since evaluating the operands might modify proc , which will be needed for the actual procedure application). Continue  must also be preserved throughout, since it is needed for the linkage in the procedure call. (define (compile-application exp target linkage)     (let ((proc-code (compile (operator exp) 'proc 'next))           (operand-codes            (map (lambda (operand) (compile operand 'val 'next))                 (operands exp))))       (preserving '(env continue)        proc-code        (preserving '(proc continue)         (construct-arglist operand-codes)         (compile-proced


key: chroma:document
string_value:
ure-call target linkage)))))   The code to construct the ar gument list will evaluate each operand into val and then cons  that value onto the ar gument list being accumulated in argl . Since we cons  the ar guments onto argl  in sequence, we must start with the last ar gument and end with the first, so that the ar guments will appear in order from first to last in the resulting list. Rather than waste an instruction by initializing argl  to the empty list to set up for this sequence of evaluations, we make the first code sequence construct the initial argl . The general form of the ar gument-list construction is thus as follows: <compilation of last operand, targeted to val>  (assign argl (op list) (reg val))   <compilation of next operand, targeted to val> (assign argl (op cons) (reg val) (reg argl))   ...<compilation of first operand, targeted to val>  (assign argl (op cons) (reg val) (reg argl))   Argl  must be preserved around each operand evaluation except the first (so that arguments accumulated so far


key: chroma:document
string_value:
 won't be lost), and env must be preserved around each operand evaluation except the last (for use by subsequent operand evaluations). Compiling this ar gument code is a bit tricky , because of the special treatment of the first operand to be evaluated and the need to preserve argl  and env in different places. The construct-arglist  procedure takes as ar guments the code that evaluates the individual operands. If there are no operands at all, it simply emits the instruction (assign argl (const ()))   Otherwise, construct-arglist  creates code that initializes argl  with the last argument, and appends code that evaluates the rest of the ar guments and adjoins them to argl  in succession. In order to process the ar guments from last to first, we must reverse the list of operand code sequences from the order supplied by compile-application . (define (construct-arglist operand-codes)     (let ((operand-codes (reverse operand-codes)))       (if (null? operand-codes)           (make-instruction-sequence '() '(argl


key: chroma:document
string_value:
)            '((assign argl (const ()))))           (let ((code-to-get-last-arg                  (append-instruction-sequences                   (car operand-codes)                   (make-instruction-sequence '(val) '(argl)                    '((assign argl (op list) (reg val)))))))             (if (null? (cdr operand-codes))                 code-to-get-last-arg                 (preserving '(env)                  code-to-get-last-arg                  (code-to-get-rest-args                   (cdr operand-codes))))))))   (define (code-to-get-rest-args operand-codes)    (let ((code-for-next-arg            (preserving '(argl)             (car operand-codes)             (make-instruction-sequence '(val argl) '(argl)              '((assign argl                 (op cons) (reg val) (reg argl)))))))       (if (null? (cdr operand-codes))           code-for-next-arg           (preserving '(env)            code-for-next-arg            (code-to-get-rest-args (cdr operand-codes))))))   Applying pr ocedur es After evaluati


key: chroma:document
string_value:
ng the elements of a combination, the compiled code must apply the procedure in proc  to the ar guments in argl . The code performs essentially the same dispatch as the apply  procedure in the metacircular evaluator of section 4.1.1  or the apply-dispatch  entry point in the explicit-control evaluator of section 5.4.1 . It checks whether the procedure to be applied is a primitive procedure or a compiled procedure. For a primitive procedure, it uses apply- primitive-procedure ; we will see shortly how it handles compiled procedures. The procedure-application code has the following form:  (test (op primitive-procedure?) (reg proc))    (branch (label primitive-branch))   compiled-branch    <code to apply compiled procedure with given target and appropriat e linkage >  primitive-branch    (assign < target>           (op apply-primitive-procedure)            (reg proc)            (reg argl))    <linkage>  after-call   Observe that the compiled branch must skip around the primitive branch. Therefore, if the linkage


key: chroma:document
string_value:
 for the original procedure call was next , the compound branch must use a linkage that jumps to a label that is inserted after the primitive branch. (This is similar to the linkage used for the true branch in compile-if .)(define (compile-procedure-call target linkage)     (let ((primitive-branch (make-label 'primitive-branch))           (compiled-branch (make-label 'compiled-branch))           (after-call (make-label 'after-call)))       (let ((compiled-linkage              (if (eq? linkage 'next) after-call linkage)))         (append-instruction-sequences          (make-instruction-sequence '(proc) '()           `((test (op primitive-procedure?) (reg proc))             (branch (label ,primitive-branch))))          (parallel-instruction-sequences           (append-instruction-sequences            compiled-branch            (compile-proc-appl target compiled-linkage))           (append-instruction-sequences            primitive-branch            (end-with-linkage linkage             (make-instruction-sequenc


key: chroma:document
string_value:
e '(proc argl)                                        (list target)              `((assign ,target                        (op apply-primitive-procedure)                        (reg proc)                        (reg argl)))))))          after-call))))   The primitive and compound branches, like the true and false branches in compile-if , are appended using parallel-instruction-sequences  rather than the ordinary append-instruction-sequences , because they will not be executed sequentially . Applying compiled pr ocedur es The code that handles procedure application is the most subtle part of the compiler , even though the instruction sequences it generates are very short. A compiled procedure (as constructed by compile-lambda ) has an entry point, which is a label that designates where the code for the procedure starts. The code at this entry point computes a result in val and returns by executing the instruction (goto (reg continue)) . Thus, we might expect the code for a compiled-procedure application (to be 


key: chroma:document
string_value:
generated by compile-proc-appl ) with a given tar get and linkage to look like this if the linkage is a label (assign continue (label proc-return))    (assign val (op compiled-procedure-entry) (reg proc))    (goto (reg val))   proc-return    (assign < target> (reg val))   ; included if target is not val   (goto (label < linkage>))   ; linkage code   or like this if the linkage is return .  (save continue)    (assign continue (label proc-return))    (assign val (op compiled-procedure-entry) (reg proc))    (goto (reg val))   proc-return    (assign < target> (reg val))   ; included if target is not val   (restore continue)    (goto (reg continue))   ; linkage code   This code sets up continue  so that the procedure will return to a label proc- return  and jumps to the procedure's entry point. The code at proc-return transfers the procedure's result from val to the tar get register (if necessary) and then jumps to the location specified by the linkage. (The linkage is always return  or a label, because compile-pr


key: chroma:document
string_value:
ocedure-call  replaces a next  linkage for the compound-procedure branch by an after-call  label.) In fact, if the tar get is not val, that is exactly the code our compiler will generate.39 Usually , however , the tar get is val (the only time the compiler specifies a dif ferent register is when tar geting the evaluation of an operator to proc ), so the procedure result is put directly into the tar get register and there is no need to return to a special location that copies it. Instead, we simplify the code by setting up continue  so that the procedure will “return” directly to the place specified by the caller's linkage: <set up continue  for linkage >  (assign val (op compiled-procedure-entry) (reg proc))   (goto (reg val))   If the linkage is a label, we set up continue  so that the procedure will return to that label. (That is, the (goto (reg continue))  the procedure ends with becomes equivalent to the (goto (label < linkage>)) at proc-return  above.)(assign continue (label < linkage>))  (assign val (op


key: chroma:document
string_value:
 compiled-procedure-entry) (reg proc))   (goto (reg val))   If the linkage is return , we don't need to set up continue  at all: It already holds the desired location. (That is, the (goto (reg continue))  the procedure ends with goes directly to the place where the (goto (reg continue))  at proc- return  would have gone.) (assign val (op compiled-procedure-entry) (reg proc))   (goto (reg val))   With this implementation of the return  linkage, the compiler generates tail- recursive code. Calling a procedure as the final step in a procedure body does a direct transfer , without saving any information on the stack. Suppose instead that we had handled the case of a procedure call with a linkage of return  and a tar get of val as shown above for a non- val target. This would destroy tail recursion. Our system would still give the same value for any expression. But each time we called a procedure, we would save continue  and return after the call to undo the (useless) save. These extra saves would accumulate durin


key: chroma:document
string_value:
g a nest of procedure calls.40 Compile-proc-appl  generates the above procedure-application code by considering four cases, depending on whether the tar get for the call is val and whether the linkage is return . Observe that the instruction sequences are declared to modify all the registers, since executing the procedure body can change the registers in arbitrary ways.41 Also note that the code sequence for the case with tar get val and linkage return  is declared to need continue : Even though continue  is not explicitly used in the two-instruction sequence, we must be sure that continue  will have the correct value when we enter the compiled procedure. (define (compile-proc-appl target linkage)     (cond ((and (eq? target 'val) (not (eq? linkage 'return)))            (make-instruction-sequence '(proc) all-regs              `((assign continue (label ,linkage))                (assign val (op compiled-procedure-entry)                            (reg proc))                (goto (reg val)))))          ((and (no


key: chroma:document
string_value:
t (eq? target 'val))                 (not (eq? linkage 'return)))            (let ((proc-return (make-label 'proc-return)))              (make-instruction-sequence '(proc) all-regs               `((assign continue (label ,proc-return))                 (assign val (op compiled-procedure-entry)                             (reg proc))                 (goto (reg val))                 ,proc-return                 (assign ,target (reg val))                 (goto (label ,linkage))))))           ((and (eq? target 'val) (eq? linkage 'return))            (make-instruction-sequence '(proc continue) all-regs             '((assign val (op compiled-procedure-entry)                           (reg proc))               (goto (reg val)))))           ((and (not (eq? target 'val)) (eq? linkage 'return))            (error "return linkage, target not val -- COMPILE"                   target))))   5.5.4  Combining Instruction Sequences This section describes the details on how instruction sequences are represented and combined. Rec


key: chroma:document
string_value:
all from section 5.5.1  that an instruction sequence is represented as a list of the registers needed, the registers modified, and the actual instructions. We will also consider a label (symbol) to be a degenerate case of an instruction sequence, which doesn't need or modify any registers. So to determine the registers needed and modified by instruction sequences we use the selectors (define (registers-needed s)     (if (symbol? s) '() (car s)))   (define (registers-modified s)     (if (symbol? s) '() (cadr s)))   (define (statements s)     (if (symbol? s) (list s) (caddr s)))   and to determine whether a given sequence needs or modifies a given register we use the predicates(define (needs-register? seq reg)     (memq reg (registers-needed seq)))   (define (modifies-register? seq reg)     (memq reg (registers-modified seq)))   In terms of these predicates and selectors, we can implement the various instruction sequence combiners used throughout the compiler . The basic combiner is append-instruction-sequences


key: chroma:document
string_value:
 . This takes as ar guments an arbitrary number of instruction sequences that are to be executed sequentially and returns an instruction sequence whose statements are the statements of all the sequences appended together . The subtle point is to determine the registers that are needed and modified by the resulting sequence. It modifies those registers that are modified by any of the sequences; it needs those registers that must be initialized before the first sequence can be run (the registers needed by the first sequence), together with those registers needed by any of the other sequences that are not initialized (modified) by sequences preceding it. The sequences are appended two at a time by append-2-sequences . This takes two instruction sequences seq1  and seq2  and returns the instruction sequence whose statements are the statements of seq1  followed by the statements of seq2 , whose modified registers are those registers that are modified by either seq1  or seq2 , and whose needed registers are the reg


key: chroma:document
string_value:
isters needed by seq1  together with those registers needed by seq2  that are not modified by seq1 . (In terms of set operations, the new set of needed registers is the union of the set of registers needed by seq1  with the set dif ference of the registers needed by seq2  and the registers modified by seq1 .) Thus, append-instruction-sequences  is implemented as follows: (define (append-instruction-sequences . seqs)     (define (append-2-sequences seq1 seq2)       (make-instruction-sequence        (list-union (registers-needed seq1)                    (list-difference (registers-needed seq2)                                     (registers-modified seq1)))        (list-union (registers-modified seq1)                    (registers-modified seq2))        (append (statements seq1) (statements seq2))))     (define (append-seq-list seqs)       (if (null? seqs)          (empty-instruction-sequence)           (append-2-sequences (car seqs)                               (append-seq-list (cdr seqs)))))     (append-seq-l


key: chroma:document
string_value:
ist seqs))   This procedure uses some simple operations for manipulating sets represented as lists, similar to the (unordered) set representation described in section 2.3.3 : (define (list-union s1 s2)     (cond ((null? s1) s2)           ((memq (car s1) s2) (list-union (cdr s1) s2))           (else (cons (car s1) (list-union (cdr s1) s2)))))   (define (list-difference s1 s2)     (cond ((null? s1) '())           ((memq (car s1) s2) (list-difference (cdr s1) s2))           (else (cons (car s1)                       (list-difference (cdr s1) s2)))))   Preserving , the second major instruction sequence combiner , takes a list of registers regs  and two instruction sequences seq1  and seq2  that are to be executed sequentially . It returns an instruction sequence whose statements are the statements of seq1  followed by the statements of seq2 , with appropriate save and restore  instructions around seq1  to protect the registers in regs  that are modified by seq1  but needed by seq2 . To accomplish this, preserving


key: chroma:document
string_value:
  first creates a sequence that has the required save s followed by the statements of seq1 followed by the required restore s. This sequence needs the registers being saved and restored in addition to the registers needed by seq1 , and modifies the registers modified by seq1  except for the ones being saved and restored. This augmented sequence and seq2  are then appended in the usual way . The following procedure implements this strategy recursively , walking down the list of registers to be preserved:42 (define (preserving regs seq1 seq2)     (if (null? regs)         (append-instruction-sequences seq1 seq2)         (let ((first-reg (car regs)))           (if (and (needs-register? seq2 first-reg)                    (modifies-register? seq1 first-reg))               (preserving (cdr regs)                (make-instruction-sequence                (list-union (list first-reg)                             (registers-needed seq1))                 (list-difference (registers-modified seq1)                           


key: chroma:document
string_value:
       (list first-reg))                 (append `((save ,first-reg))                         (statements seq1)                         `((restore ,first-reg))))                seq2)               (preserving (cdr regs) seq1 seq2)))))   Another sequence combiner , tack-on-instruction-sequence , is used by compile-lambda  to append a procedure body to another sequence. Because the procedure body is not “in line” to be executed as part of the combined sequence, its register use has no impact on the register use of the sequence in which it is embedded. We thus ignore the procedure body's sets of needed and modified registers when we tack it onto the other sequence. (define (tack-on-instruction-sequence seq body-seq)     (make-instruction-sequence      (registers-needed seq)      (registers-modified seq)      (append (statements seq) (statements body-seq))))   Compile-if  and compile-procedure-call  use a special combiner called parallel-instruction-sequences  to append the two alternative branches that follow a 


key: chroma:document
string_value:
test. The two branches will never be executed sequentially; for any particular evaluation of the test, one branch or the other will be entered. Because of this, the registers needed by the second branch are still needed by the combined sequence, even if these are modified by the first branch. (define (parallel-instruction-sequences seq1 seq2)     (make-instruction-sequence      (list-union (registers-needed seq1)                  (registers-needed seq2))      (list-union (registers-modified seq1)                  (registers-modified seq2))      (append (statements seq1) (statements seq2))))   5.5.5  An Example of Compiled CodeNow that we have seen all the elements of the compiler , let us examine an example of compiled code to see how things fit together . We will compile the definition of a recursive factorial  procedure by calling compile : (compile    '(define (factorial n)       (if (= n 1)           1           (* (factorial (- n 1)) n)))    'val   'next)  We have specified that the value of the define  


key: chroma:document
string_value:
expression should be placed in the val register . We don't care what the compiled code does after executing the define , so our choice of next  as the linkage descriptor is arbitrary . Compile  determines that the expression is a definition, so it calls compile- definition  to compile code to compute the value to be assigned (tar geted to val), followed by code to install the definition, followed by code to put the value of the define  (which is the symbol ok) into the tar get register , followed finally by the linkage code. Env is preserved around the computation of the value, because it is needed in order to install the definition. Because the linkage is next , there is no linkage code in this case. The skeleton of the compiled code is thus   <save env if modified by code to compute value >    <compilation of definition value, target val, linkage next>    <restore env if saved above >    (perform (op define-variable!)              (const factorial)              (reg val)              (reg env))     (assign 


key: chroma:document
string_value:
val (const ok))   The expression that is to be compiled to produce the value for the variable factorial  is a lambda  expression whose value is the procedure that computes factorials. Compile  handles this by calling compile-lambda , which compiles the procedure body , labels it as a new entry point, and generates the instruction that will combine the procedure body at the new entry point with the run-time environment and assign the result to val. The sequence then skips around the compiled procedure code, which is inserted at this point. The procedure codeitself begins by extending the procedure's definition environment by a frame that binds the formal parameter n to the procedure ar gument. Then comes the actual procedure body . Since this code for the value of the variable doesn't modify the env register , the optional save  and restore  shown above aren't generated. (The procedure code at entry2  isn't executed at this point, so its use of env is irrelevant.) Therefore, the skeleton for the compiled code 


key: chroma:document
string_value:
becomes   (assign val (op make-compiled-procedure)                 (label entry2)                 (reg env))     (goto (label after-lambda1))   entry2    (assign env (op compiled-procedure-env) (reg proc))     (assign env (op extend-environment)                 (const (n))                 (reg argl)                 (reg env))     <compilation of procedure body >  after-lambda1     (perform (op define-variable!)              (const factorial)              (reg val)              (reg env))     (assign val (const ok))   A procedure body is always compiled (by compile-lambda-body ) as a sequence with tar get val and linkage return . The sequence in this case consists of a single if expression: (if (= n 1)       1      (* (factorial (- n 1)) n))   Compile-if  generates code that first computes the predicate (tar geted to val), then checks the result and branches around the true branch if the predicate is false. Env and continue  are preserved around the predicate code, since they may be needed for the rest of the 


key: chroma:document
string_value:
if expression. Since the if expression is the final expression (and only expression) in the sequence making up the procedure body , its tar get is val and its linkage is return , so the true and false branches are both compiled with tar get val and linkage return . (That is, the value of theconditional, which is the value computed by either of its branches, is the value of the procedure.)   <save continue , env if modified by predicate and needed by branch es>    <compilation of predicate, target val, linkage next>    <restore continue , env if saved above >    (test (op false?) (reg val))     (branch (label false-branch4))   true-branch5     <compilation of true branch, target val, linkage return>  false-branch4     <compilation of false branch, target val, linkage return>  after-if3   The predicate (= n 1)  is a procedure call. This looks up the operator (the symbol =) and places this value in proc . It then assembles the ar guments 1 and the value of n into argl . Then it tests whether proc  contains a pri


key: chroma:document
string_value:
mitive or a compound procedure, and dispatches to a primitive branch or a compound branch accordingly . Both branches resume at the after-call  label. The requirements to preserve registers around the evaluation of the operator and operands don't result in any saving of registers, because in this case those evaluations don't modify the registers in question.   (assign proc             (op lookup-variable-value) (const =) (reg env))     (assign val (const 1))     (assign argl (op list) (reg val))     (assign val (op lookup-variable-value) (const n) (reg env))     (assign argl (op cons) (reg val) (reg argl))     (test (op primitive-procedure?) (reg proc))     (branch (label primitive-branch17))   compiled-branch16     (assign continue (label after-call15))     (assign val (op compiled-procedure-entry) (reg proc))     (goto (reg val))   primitive-branch17     (assign val (op apply-primitive-procedure)                 (reg proc)                (reg argl))   after-call15   The true branch, which is the constant 1,


key: chroma:document
string_value:
 compiles (with tar get val and linkage return ) to   (assign val (const 1))     (goto (reg continue))   The code for the false branch is another a procedure call, where the procedure is the value of the symbol *, and the ar guments are n and the result of another procedure call (a call to factorial ). Each of these calls sets up proc  and argl and its own primitive and compound branches. Figure 5.17 shows the complete compilation of the definition of the factorial  procedure. Notice that the possible save  and restore  of continue  and env around the predicate, shown above, are in fact generated, because these registers are modified by the procedure call in the predicate and needed for the procedure call and the return linkage in the branches. Exer cise 5.33.   Consider the following definition of a factorial procedure, which is slightly dif ferent from the one given above: (define (factorial-alt n)     (if (= n 1)         1        (* n (factorial-alt (- n 1)))))   Compile this procedure and compare the resu


key: chroma:document
string_value:
lting code with that produced for factorial . Explain any dif ferences you find. Does either program execute more efficiently than the other? Exer cise 5.34.   Compile the iterative factorial procedure (define (factorial n)     (define (iter product counter)       (if (> counter n)           product           (iter (* counter product)                 (+ counter 1))))     (iter 1 1))  Annotate the resulting code, showing the essential dif ference between the code for iterative and recursive versions of factorial  that makes one process build up stack space and the other run in constant stack space. ;; construct the procedure and skip over code for the procedure body     (assign val             (op make-compiled-procedure) (label entry2) (reg env))     (goto (label after-lambda1))     entry2     ; calls to factorial  will enter here     (assign env (op compiled-procedure-env) (reg proc))     (assign env             (op extend-environment) (const (n)) (reg argl) (reg env))   ;; begin actual procedure body     (s


key: chroma:document
string_value:
ave continue)     (save env)     ;; compute (= n 1)    (assign proc (op lookup-variable-value) (const =) (reg env))     (assign val (const 1))     (assign argl (op list) (reg val))     (assign val (op lookup-variable-value) (const n) (reg env))     (assign argl (op cons) (reg val) (reg argl))     (test (op primitive-procedure?) (reg proc))     (branch (label primitive-branch17))   compiled-branch16     (assign continue (label after-call15))     (assign val (op compiled-procedure-entry) (reg proc))     (goto (reg val))   primitive-branch17     (assign val (op apply-primitive-procedure) (reg proc) (reg argl))     after-call15   ; val now contains result of (= n 1)    (restore env)     (restore continue)     (test (op false?) (reg val))     (branch (label false-branch4))  Figur e 5.17:   Compilation of the definition of the factorial  procedure (continued on next page).true-branch5  ; return 1     (assign val (const 1))     (goto (reg continue))     false-branch4   ;; compute and return (* (factorial (- n 1)) n)


key: chroma:document
string_value:
     (assign proc (op lookup-variable-value) (const *) (reg env))     (save continue)     (save proc)   ; save * procedure     (assign val (op lookup-variable-value) (const n) (reg env))     (assign argl (op list) (reg val))     (save argl)   ; save partial argument list for *    ;; compute (factorial (- n 1)) , which is the other argument for *    (assign proc             (op lookup-variable-value) (const factorial) (reg env))     (save proc)  ; save factorial  procedure   ;; compute (- n 1), which is the argument for factorial     (assign proc (op lookup-variable-value) (const -) (reg env))     (assign val (const 1))     (assign argl (op list) (reg val))     (assign val (op lookup-variable-value) (const n) (reg env))     (assign argl (op cons) (reg val) (reg argl))     (test (op primitive-procedure?) (reg proc))     (branch (label primitive-branch8))   compiled-branch7     (assign continue (label after-call6))     (assign val (op compiled-procedure-entry) (reg proc))     (goto (reg val))   primitive-branch8


key: chroma:document
string_value:
     (assign val (op apply-primitive-procedure) (reg proc) (reg argl))     after-call6   ; val now contains result of (- n 1)    (assign argl (op list) (reg val))     (restore proc) ; restore factorial   ;; apply factorial  Figur e 5.17:   (continued)  (test (op primitive-procedure?) (reg proc))     (branch (label primitive-branch11))   compiled-branch10     (assign continue (label after-call9))     (assign val (op compiled-procedure-entry) (reg proc))     (goto (reg val))   primitive-branch11     (assign val (op apply-primitive-procedure) (reg proc) (reg argl))     after-call9      ; val now contains result of (factorial (- n 1))     (restore argl) ; restore partial argument list for *    (assign argl (op cons) (reg val) (reg argl))     (restore proc) ; restore *    (restore continue)   ;; apply * and return its value     (test (op primitive-procedure?) (reg proc))     (branch (label primitive-branch14))   compiled-branch13   ;; note that a compound procedure here is called tail-recursively     (assign val (


key: chroma:document
string_value:
op compiled-procedure-entry) (reg proc))     (goto (reg val))   primitive-branch14     (assign val (op apply-primitive-procedure) (reg proc) (reg argl))     (goto (reg continue))   after-call12   after-if3   after-lambda1   ;; assign the procedure to the variable factorial     (perform      (op define-variable!) (const factorial) (reg val) (reg env))     (assign val (const ok))   Exer cise 5.35.   What expression was compiled to produce the code shown in figure 5.18? Figur e 5.18:   An example of compiler output (continued on next page). See exercise 5.35.  (assign val (op make-compiled-procedure) (label entry16)                                              (reg env))     (goto (label after-lambda15))   entry16    (assign env (op compiled-procedure-env) (reg proc))     (assign env             (op extend-environment) (const (x)) (reg argl) (reg env))     (assign proc (op lookup-variable-value) (const +) (reg env))     (save continue)     (save proc)     (save env)     (assign proc (op lookup-variable-value) (c


key: chroma:document
string_value:
onst g) (reg env))     (save proc)     (assign proc (op lookup-variable-value) (const +) (reg env))     (assign val (const 2))     (assign argl (op list) (reg val))     (assign val (op lookup-variable-value) (const x) (reg env))     (assign argl (op cons) (reg val) (reg argl))     (test (op primitive-procedure?) (reg proc))     (branch (label primitive-branch19))   compiled-branch18     (assign continue (label after-call17))     (assign val (op compiled-procedure-entry) (reg proc))     (goto (reg val))   primitive-branch19     (assign val (op apply-primitive-procedure) (reg proc) (reg argl))   after-call17     (assign argl (op list) (reg val))     (restore proc)     (test (op primitive-procedure?) (reg proc))     (branch (label primitive-branch22))   compiled-branch21     (assign continue (label after-call20))     (assign val (op compiled-procedure-entry) (reg proc))     (goto (reg val))   primitive-branch22     (assign val (op apply-primitive-procedure) (reg proc) (reg argl))   Figur e 5.18:   (continued)aft


key: chroma:document
string_value:
er-call20     (assign argl (op list) (reg val))     (restore env)     (assign val (op lookup-variable-value) (const x) (reg env))     (assign argl (op cons) (reg val) (reg argl))     (restore proc)     (restore continue)     (test (op primitive-procedure?) (reg proc))     (branch (label primitive-branch25))   compiled-branch24     (assign val (op compiled-procedure-entry) (reg proc))     (goto (reg val))   primitive-branch25     (assign val (op apply-primitive-procedure) (reg proc) (reg argl))     (goto (reg continue))   after-call23   after-lambda15     (perform (op define-variable!) (const f) (reg val) (reg env))     (assign val (const ok))   Exer cise 5.36.   What order of evaluation does our compiler produce for operands of a combination? Is it left-to-right, right-to-left, or some other order? Where in the compiler is this order determined? Modify the compiler so that it produces some other order of evaluation. (See the discussion of order of evaluation for the explicit-control evaluator in section 5.4.1


key: chroma:document
string_value:
 .) How does changing the order of operand evaluation af fect the ef ficiency of the code that constructs the ar gument list? Exer cise 5.37.   One way to understand the compiler's preserving  mechanism for optimizing stack usage is to see what extra operations would be generated if we did not use this idea. Modify preserving  so that it always generates the save and restore  operations. Compile some simple expressions and identify the unnecessary stack operations that are generated. Compare the code to that generated with the preserving  mechanism intact. Exer cise 5.38.   Our compiler is clever about avoiding unnecessary stack operations, but it is not clever at all when it comes to compiling calls to the primitive procedures of the language in terms of the primitive operationssupplied by the machine. For example, consider how much code is compiled to compute (+ a 1) : The code sets up an ar gument list in argl , puts the primitive addition procedure (which it finds by looking up the symbol + in the environ


key: chroma:document
string_value:
ment) into proc , and tests whether the procedure is primitive or compound. The compiler always generates code to perform the test, as well as code for primitive and compound branches (only one of which will be executed). We have not shown the part of the controller that implements primitives, but we presume that these instructions make use of primitive arithmetic operations in the machine's data paths. Consider how much less code would be generated if the compiler could open-code  primitives – that is, if it could generate code to directly use these primitive machine operations. The expression (+ a 1)  might be compiled into something as simple as 43 (assign val (op lookup-variable-value) (const a) (reg env))   (assign val (op +) (reg val) (const 1))   In this exercise we will extend our compiler to support open coding of selected primitives. Special-purpose code will be generated for calls to these primitive procedures instead of the general procedure-application code. In order to support this, we will augm


key: chroma:document
string_value:
ent our machine with special ar gument registers arg1  and arg2 . The primitive arithmetic operations of the machine will take their inputs from arg1  and arg2 . The results may be put into val, arg1 , or arg2 . The compiler must be able to recognize the application of an open-coded primitive in the source program. We will augment the dispatch in the compile procedure to recognize the names of these primitives in addition to the reserved words (the special forms) it currently recognizes.44 For each special form our compiler has a code generator . In this exercise we will construct a family of code generators for the open-coded primitives. a.  The open-coded primitives, unlike the special forms, all need their operands evaluated. Write a code generator spread-arguments  for use by all the open- coding code generators. Spread-arguments  should take an operand list and compile the given operands tar geted to successive ar gument registers. Note that an operand may contain a call to an open-coded primitive, so ar


key: chroma:document
string_value:
 gument registers will have to be preserved during operand evaluation. b.  For each of the primitive procedures =, *, -, and +, write a code generator that takes a combination with that operator , together with a tar get and a linkage descriptor , and produces code to spread the ar guments into the registers and thenperform the operation tar geted to the given tar get with the given linkage. You need only handle expressions with two operands. Make compile  dispatch to these code generators. c.  Try your new compiler on the factorial  example. Compare the resulting code with the result produced without open coding. d.  Extend your code generators for + and * so that they can handle expressions with arbitrary numbers of operands. An expression with more than two operands will have to be compiled into a sequence of operations, each with only two inputs. 5.5.6  Lexical Addr essing One of the most common optimizations performed by compilers is the optimization of variable lookup. Our compiler , as we have implemen


key: chroma:document
string_value:
ted it so far , generates code that uses the lookup-variable-value  operation of the evaluator machine. This searches for a variable by comparing it with each variable that is currently bound, working frame by frame outward through the run-time environment. This search can be expensive if the frames are deeply nested or if there are many variables. For example, consider the problem of looking up the value of x while evaluating the expression (* x y z)  in an application of the procedure that is returned by (let ((x 3) (y 4))     (lambda (a b c d e)       (let ((y (* a b x))             (z (+ c d x)))         (* x y z))))   Since a let expression is just syntactic sugar for a lambda  combination, this expression is equivalent to ((lambda (x y)      (lambda (a b c d e)        ((lambda (y z) (* x y z))         (* a b x)         (+ c d x))))    3   4) Each time lookup-variable-value  searches for x, it must determine that the symbol x is not eq? to y or z (in the first frame), nor to a, b, c, d, or e (in the seco


key: chroma:document
string_value:
nd frame). We will assume, for the moment, that our programs do not use define  – that variables are bound only with lambda . Because our language is lexically scoped, the run-time environment for any expression will have a structure that parallels the lexical structure of the program in which the expression appears.45 Thus, the compiler can know , when it analyzes the above expression, that each time the procedure is applied the variable x in (* x y z) will be found two frames out from the current frame and will be the first variable in that frame. We can exploit this fact by inventing a new kind of variable-lookup operation, lexical-address-lookup , that takes as ar guments an environment and a lexical address that consists of two numbers: a frame number , which specifies how many frames to pass over , and a displacement number , which specifies how many variables to pass over in that frame. Lexical-address-lookup  will produce the value of the variable stored at that lexical address relative to the current


key: chroma:document
string_value:
 environment. If we add the lexical-address-lookup  operation to our machine, we can make the compiler generate code that references variables using this operation, rather than lookup-variable-value . Similarly , our compiled code can use a new lexical-address-set!  operation instead of set-variable- value! . In order to generate such code, the compiler must be able to determine the lexical address of a variable it is about to compile a reference to. The lexical address of a variable in a program depends on where one is in the code. For example, in the following program, the address of x in expression < e1> is (2,0) – two frames back and the first variable in the frame. At that point y is at address (0,0) and c is at address (1,2). In expression < e2>, x is at (1,0), y is at (1,1), and c is at (0,2). ((lambda (x y)      (lambda (a b c d e)        ((lambda (y z) < e1>)        <e2>        (+ c d x))))    3   4)  One way for the compiler to produce code that uses lexical addressing is to maintain a data structur


key: chroma:document
string_value:
e called a compile-time envir onment . This keeps track ofwhich variables will be at which positions in which frames in the run-time environment when a particular variable-access operation is executed. The compile-time environment is a list of frames, each containing a list of variables. (There will of course be no values bound to the variables, since values are not computed at compile time.) The compile-time environment becomes an additional ar gument to compile  and is passed along to each code generator . The top-level call to compile  uses an empty compile-time environment. When a lambda  body is compiled, compile-lambda-body  extends the compile-time environment by a frame containing the procedure's parameters, so that the sequence making up the body is compiled with that extended environment. At each point in the compilation, compile-variable  and compile-assignment  use the compile-time environment in order to generate the appropriate lexical addresses. Exercises 5.39 through 5.43 describe how to compl


key: chroma:document
string_value:
ete this sketch of the lexical- addressing strategy in order to incorporate lexical lookup into the compiler . Exercise 5.44 describes another use for the compile-time environment. Exer cise 5.39.   Write a procedure lexical-address-lookup  that implements the new lookup operation. It should take two ar guments – a lexical address and a run-time environment – and return the value of the variable stored at the specified lexical address. Lexical-address-lookup  should signal an error if the value of the variable is the symbol *unassigned* .46 Also write a procedure lexical-address-set!  that implements the operation that changes the value of the variable at a specified lexical address. Exer cise 5.40.   Modify the compiler to maintain the compile-time environment as described above. That is, add a compile-time-environment ar gument to compile  and the various code generators, and extend it in compile-lambda-body . Exer cise 5.41.   Write a procedure find-variable  that takes as ar guments a variable and a compi


key: chroma:document
string_value:
le-time environment and returns the lexical address of the variable with respect to that environment. For example, in the program fragment that is shown above, the compile-time environment during the compilation of expression < e1> is ((y z) (a b c d e) (x y)) . Find-variable  should produce (find-variable 'c '((y z) (a b c d e) (x y)))   (1 2)   (find-variable 'x '((y z) (a b c d e) (x y)))   (2 0)    (find-variable 'w '((y z) (a b c d e) (x y)))   not-found   Exer cise 5.42.   Using find-variable  from exercise 5.41, rewrite compile- variable  and compile-assignment  to output lexical-address instructions. In cases where find-variable  returns not-found  (that is, where the variable is not in the compile-time environment), you should have the code generators use the evaluator operations, as before, to search for the binding. (The only place a variable that is not found at compile time can be is in the global environment, which is part of the run-time environment but is not part of the compile-time environme


key: chroma:document
string_value:
nt.47 Thus, if you wish, you may have the evaluator operations look directly in the global environment, which can be obtained with the operation (op get-global-environment) , instead of having them search the whole run- time environment found in env.) Test the modified compiler on a few simple cases, such as the nested lambda  combination at the beginning of this section. Exer cise 5.43.   We argued in section 4.1.6  that internal definitions for block structure should not be considered “real” define s. Rather , a procedure body should be interpreted as if the internal variables being defined were installed as ordinary lambda  variables initialized to their correct values using set! . Section 4.1.6  and exercise 4.16 showed how to modify the metacircular interpreter to accomplish this by scanning out internal definitions. Modify the compiler to perform the same transformation before it compiles a procedure body . Exer cise 5.44.   In this section we have focused on the use of the compile-time environment to p


key: chroma:document
string_value:
roduce lexical addresses. But there are other uses for compile- time environments. For instance, in exercise 5.38 we increased the ef ficiency of compiled code by open-coding primitive procedures. Our implementation treated the names of open-coded procedures as reserved words. If a program were to rebind such a name, the mechanism described in exercise 5.38 would still open- code it as a primitive, ignoring the new binding. For example, consider the procedure (lambda (+ * a b x y)     (+ (* a x) (* b y)))  which computes a linear combination of x and y. We might call it with ar guments +matrix , *matrix , and four matrices, but the open-coding compiler would still open-code the + and the * in (+ (* a x) (* b y))  as primitive + and *. Modify the open-coding compiler to consult the compile-time environment in order to compile the correct code for expressions involving the names of primitive procedures. (The code will work correctly as long as the program does not define  or set!  these names.) 5.5.7  Interfaci


key: chroma:document
string_value:
ng Compiled Code to the Evaluator We have not yet explained how to load compiled code into the evaluator machine or how to run it. We will assume that the explicit-control-evaluator machine has been defined as in section 5.4.4 , with the additional operations specified in footnote 38. We will implement a procedure compile-and-go  that compiles a Scheme expression, loads the resulting object code into the evaluator machine, and causes the machine to run the code in the evaluator global environment, print the result, and enter the evaluator's driver loop. We will also modify the evaluator so that interpreted expressions can call compiled procedures as well as interpreted ones. We can then put a compiled procedure into the machine and use the evaluator to call it: (compile-and-go    '(define (factorial n)       (if (= n 1)           1           (* (factorial (- n 1)) n))))    ;;; EC-Eval value:   ok   ;;; EC-Eval input:   (factorial 5)   ;;; EC-Eval value:   120  To allow the evaluator to handle compiled procedu


key: chroma:document
string_value:
res (for example, to evaluate the call to factorial  above), we need to change the code at apply-dispatch (section 5.4.1 ) so that it recognizes compiled procedures (as distinct from compound or primitive procedures) and transfers control directly to the entry point of the compiled code:48apply-dispatch     (test (op primitive-procedure?) (reg proc))     (branch (label primitive-apply))     (test (op compound-procedure?) (reg proc))      (branch (label compound-apply))     (test (op compiled-procedure?) (reg proc))      (branch (label compiled-apply))     (goto (label unknown-procedure-type))   compiled-apply     (restore continue)     (assign val (op compiled-procedure-entry) (reg proc))     (goto (reg val))   Note the restore of continue  at compiled-apply . Recall that the evaluator was arranged so that at apply-dispatch , the continuation would be at the top of the stack. The compiled code entry point, on the other hand, expects the continuation to be in continue , so continue  must be restored before the


key: chroma:document
string_value:
 compiled code is executed. To enable us to run some compiled code when we start the evaluator machine, we add a branch  instruction at the beginning of the evaluator machine, which causes the machine to go to a new entry point if the flag  register is set.49   (branch (label external-entry))      ; branches if flag is set  read-eval-print-loop     (perform (op initialize-stack))     ... External-entry  assumes that the machine is started with val containing the location of an instruction sequence that puts a result into val and ends with (goto (reg continue)) . Starting at this entry point jumps to the location designated by val, but first assigns continue  so that execution will return to print-result , which prints the value in val and then goes to the beginning of the evaluator's read-eval-print loop.50 external-entry     (perform (op initialize-stack))     (assign env (op get-global-environment))     (assign continue (label print-result))     (goto (reg val))  Now we can use the following procedure to co


key: chroma:document
string_value:
mpile a procedure definition, execute the compiled code, and run the read-eval-print loop so we can try the procedure. Because we want the compiled code to return to the location in continue  with its result in val, we compile the expression with a tar get of val and a linkage of return . In order to transform the object code produced by the compiler into executable instructions for the evaluator register machine, we use the procedure assemble  from the register -machine simulator (section 5.2.2 ). We then initialize the val register to point to the list of instructions, set the flag  so that the evaluator will go to external-entry , and start the evaluator . (define (compile-and-go expression)     (let ((instructions            (assemble (statements                       (compile expression 'val 'return))                      eceval)))       (set! the-global-environment (setup-environment))       (set-register-contents! eceval 'val instructions)       (set-register-contents! eceval 'flag true)       (start e


key: chroma:document
string_value:
ceval)))   If we have set up stack monitoring, as at the end of section 5.4.4 , we can examine the stack usage of compiled code: (compile-and-go    '(define (factorial n)       (if (= n 1)           1           (* (factorial (- n 1)) n))))     (total-pushes = 0 maximum-depth = 0)    ;;; EC-Eval value:   ok   ;;; EC-Eval input:   (factorial 5)   (total-pushes = 31 maximum-depth = 14)   ;;; EC-Eval value:   120  Compare this example with the evaluation of (factorial 5)  using the interpreted version of the same procedure, shown at the end of section 5.4.4 . Theinterpreted version required 144 pushes and a maximum stack depth of 28. This illustrates the optimization that results from our compilation strategy . Interpr etation and compilation With the programs in this section, we can now experiment with the alternative execution strategies of interpretation and compilation.51 An interpreter raises the machine to the level of the user program; a compiler lowers the user program to the level of the machine language


key: chroma:document
string_value:
. We can regard the Scheme language (or any programming language) as a coherent family of abstractions erected on the machine language. Interpreters are good for interactive program development and debugging because the steps of program execution are or ganized in terms of these abstractions, and are therefore more intelligible to the programmer . Compiled code can execute faster , because the steps of program execution are organized in terms of the machine language, and the compiler is free to make optimizations that cut across the higher -level abstractions.52 The alternatives of interpretation and compilation also lead to different strategies for porting languages to new computers. Suppose that we wish to implement Lisp for a new machine. One strategy is to begin with the explicit-control evaluator of section 5.4 and translate its instructions to instructions for the new machine. A dif ferent strategy is to begin with the compiler and change the code generators so that they generate code for the new machin


key: chroma:document
string_value:
e. The second strategy allows us to run any Lisp program on the new machine by first compiling it with the compiler running on our original Lisp system, and linking it with a compiled version of the run-time library .53 Better yet, we can compile the compiler itself, and run this on the new machine to compile other Lisp programs.54 Or we can compile one of the interpreters of section 4.1 to produce an interpreter that runs on the new machine. Exer cise 5.45.   By comparing the stack operations used by compiled code to the stack operations used by the evaluator for the same computation, we can determine the extent to which the compiler optimizes use of the stack, both in speed (reducing the total number of stack operations) and in space (reducing the maximum stack depth). Comparing this optimized stack use to the performance of a special-purpose machine for the same computation gives some indication of the quality of the compiler . a. Exercise 5.27 asked you to determine, as a function of n, the number of push


key: chroma:document
string_value:
es and the maximum stack depth needed by the evaluator to compute n! using therecursive factorial procedure given above. Exercise 5.14 asked you to do the same measurements for the special-purpose factorial machine shown in figure 5.11. Now perform the same analysis using the compiled factorial procedure. Take the ratio of the number of pushes in the compiled version to the number of pushes in the interpreted version, and do the same for the maximum stack depth. Since the number of operations and the stack depth used to compute n! are linear in n, these ratios should approach constants as n becomes lar ge. What are these constants? Similarly , find the ratios of the stack usage in the special-purpose machine to the usage in the interpreted version. Compare the ratios for special-purpose versus interpreted code to the ratios for compiled versus interpreted code. You should find that the special-purpose machine does much better than the compiled code, since the hand-tailored controller code should be much bette


key: chroma:document
string_value:
r than what is produced by our rudimentary general-purpose compiler . b. Can you suggest improvements to the compiler that would help it generate code that would come closer in performance to the hand-tailored version? Exer cise 5.46.   Carry out an analysis like the one in exercise 5.45 to determine the ef fectiveness of compiling the tree-recursive Fibonacci procedure (define (fib n)     (if (< n 2)         n        (+ (fib (- n 1)) (fib (- n 2)))))   compared to the ef fectiveness of using the special-purpose Fibonacci machine of figure 5.12. (For measurement of the interpreted performance, see exercise 5.29.) For Fibonacci, the time resource used is not linear in n; hence the ratios of stack operations will not approach a limiting value that is independent of n. Exer cise 5.47.   This section described how to modify the explicit-control evaluator so that interpreted code can call compiled procedures. Show how to modify the compiler so that compiled procedures can call not only primitive procedures and com


key: chroma:document
string_value:
piled procedures, but interpreted procedures as well. This requires modifying compile-procedure-call  to handle the case of compound (interpreted) procedures. Be sure to handle all the same target  and linkage combinations as in compile-proc-appl . To do the actual procedure application,the code needs to jump to the evaluator's compound-apply  entry point. This label cannot be directly referenced in object code (since the assembler requires that all labels referenced by the code it is assembling be defined there), so we will add a register called compapp  to the evaluator machine to hold this entry point, and add an instruction to initialize it:   (assign compapp (label compound-apply))     (branch (label external-entry))      ; branches if flag is set  read-eval-print-loop     ... To test your code, start by defining a procedure f that calls a procedure g. Use compile-and-go  to compile the definition of f and start the evaluator . Now , typing at the evaluator , define g and try to call f. Exer cise 5.48.  


key: chroma:document
string_value:
 The compile-and-go  interface implemented in this section is awkward, since the compiler can be called only once (when the evaluator machine is started). Augment the compiler -interpreter interface by providing a compile-and-run  primitive that can be called from within the explicit-control evaluator as follows: ;;; EC-Eval input:   (compile-and-run    '(define (factorial n)       (if (= n 1)           1           (* (factorial (- n 1)) n))))   ;;; EC-Eval value:   ok  ;;; EC-Eval input:   (factorial 5)   ;;; EC-Eval value:   120  Exer cise 5.49.   As an alternative to using the explicit-control evaluator's read- eval-print loop, design a register machine that performs a read-compile-execute- print loop. That is, the machine should run a loop that reads an expression, compiles it, assembles and executes the resulting code, and prints the result. This is easy to run in our simulated setup, since we can arrange to call the procedures compile  and assemble  as “register -machine operations.”Exer cise 5.50.   Us


key: chroma:document
string_value:
e the compiler to compile the metacircular evaluator of section 4.1 and run this program using the register -machine simulator . (To compile more than one definition at a time, you can package the definitions in a begin .) The resulting interpreter will run very slowly because of the multiple levels of interpretation, but getting all the details to work is an instructive exercise. Exer cise 5.51.   Develop a rudimentary implementation of Scheme in C (or some other low-level language of your choice) by translating the explicit-control evaluator of section 5.4 into C. In order to run this code you will need to also provide appropriate storage-allocation routines and other run-time support. Exer cise 5.52.   As a counterpoint to exercise 5.51, modify the compiler so that it compiles Scheme procedures into sequences of C instructions. Compile the metacircular evaluator of section 4.1 to produce a Scheme interpreter written in C. 33 This is a theoretical statement. We are not claiming that the evaluator's data pat


key: chroma:document
string_value:
hs are a particularly convenient or ef ficient set of data paths for a general-purpose computer . For example, they are not very good for implementing high-performance floating-point calculations or calculations that intensively manipulate bit vectors. 34 Actually , the machine that runs compiled code can be simpler than the interpreter machine, because we won't use the exp and unev  registers. The interpreter used these to hold pieces of unevaluated expressions. With the compiler , however , these expressions get built into the compiled code that the register machine will run. For the same reason, we don't need the machine operations that deal with expression syntax. But compiled code will use a few additional machine operations (to represent compiled procedure objects) that didn't appear in the explicit-control evaluator machine. 35 Notice, however , that our compiler is a Scheme program, and the syntax procedures that it uses to manipulate expressions are the actual Scheme procedures used with the metacirc


key: chroma:document
string_value:
ular evaluator . For the explicit-control evaluator , in contrast, we assumed that equivalent syntax operations were available as operations for the register machine. (Of course, when we simulated the register machine in Scheme, we used the actual Scheme procedures in our register machine simulation.) 36 This procedure uses a feature of Lisp called backquote  (or quasiquote ) that is handy for constructing lists. Preceding a list with a backquote symbol is much like quoting it, except that anything in the list that is flagged with a comma is evaluated. For example, if the value of linkage  is the symbol branch25 , then the expression `((goto (label ,linkage)))  evaluates to the list ((goto (label branch25))) . Similarly , if the value of x is the list (a b c), then `(1 2 ,(car x))  evaluates to the list (1 2 a) . 37 We can't just use the labels true-branch , false-branch , and after-if  as shown above, because there might be more than one if in the program. The compiler uses the procedure make-label  to gener


key: chroma:document
string_value:
ate labels. Make-label  takes a symbol as ar gument and returns a new symbol that begins with the given symbol. Forexample, successive calls to (make-label 'a)  would return a1, a2, and so on. Make-label  can be implemented similarly to the generation of unique variable names in the query language, as follows: (define label-counter 0)     (define (new-label-number)     (set! label-counter (+ 1 label-counter))     label-counter)     (define (make-label name)     (string->symbol       (string-append (symbol->string name)                      (number->string (new-label-number)))))   38 We need machine operations to implement a data structure for representing compiled procedures, analogous to the structure for compound procedures described in section 4.1.3 : (define (make-compiled-procedure entry env)     (list 'compiled-procedure entry env))     (define (compiled-procedure? proc)     (tagged-list? proc 'compiled-procedure))     (define (compiled-procedure-entry c-proc) (cadr c-proc))     (define (compiled-proced


key: chroma:document
string_value:
ure-env c-proc) (caddr c-proc))   39 Actually , we signal an error when the tar get is not val and the linkage is return , since the only place we request return  linkages is in compiling procedures, and our convention is that procedures return their values in val. 40 Making a compiler generate tail-recursive code might seem like a straightforward idea. But most compilers for common languages, including C and Pascal, do not do this, and therefore these languages cannot represent iterative processes in terms of procedure call alone. The dif ficulty with tail recursion in these languages is that their implementations use the stack to store procedure ar guments and local variables as well as return addresses. The Scheme implementations described in this book store ar guments and variables in memory to be garbage-collected. The reason for using the stack for variables and ar guments is that it avoids the need for garbage collection in languages that would not otherwise require it, and is generally believed to be 


key: chroma:document
string_value:
more ef ficient. Sophisticated Lisp compilers can, in fact, use the stack for arguments without destroying tail recursion. (See Hanson 1990 for a description.) There is also some debate about whether stack allocation is actually more ef ficient than garbage collection in the first place, but the details seem to hinge on fine points of computer architecture. (See Appel 1987 and Miller and Rozas 1994 for opposing views on this issue.) 41 The variable all-regs  is bound to the list of names of all the registers: (define all-regs '(env proc val argl continue))   42 Note that preserving  calls append  with three arguments. Though the definition of append  shown in this book accepts only two ar guments, Scheme standardly provides an append  procedure that takes an arbitrary number of ar guments. 43 We have used the same symbol + here to denote both the source-language procedure and the machine operation. In general there will not be a one-to-one correspondence between primitives of the sourcelanguage and primitives


key: chroma:document
string_value:
 of the machine. 44 Making the primitives into reserved words is in general a bad idea, since a user cannot then rebind these names to dif ferent procedures. Moreover , if we add reserved words to a compiler that is in use, existing programs that define procedures with these names will stop working. See exercise 5.44 for ideas on how to avoid this problem. 45 This is not true if we allow internal definitions, unless we scan them out. See exercise 5.43. 46 This is the modification to variable lookup required if we implement the scanning method to eliminate internal definitions (exercise 5.43). We will need to eliminate these definitions in order for lexical addressing to work. 47 Lexical addresses cannot be used to access variables in the global environment, because these names can be defined and redefined interactively at any time. With internal definitions scanned out, as in exercise 5.43, the only definitions the compiler sees are those at top level, which act on the global environment. Compilation of a def


key: chroma:document
string_value:
inition does not cause the defined name to be entered in the compile-time environment. 48 Of course, compiled procedures as well as interpreted procedures are compound (nonprimitive). For compatibility with the terminology used in the explicit-control evaluator , in this section we will use “compound” to mean interpreted (as opposed to compiled). 49 Now that the evaluator machine starts with a branch , we must always initialize the flag  register before starting the evaluator machine. To start the machine at its ordinary read-eval-print loop, we could use (define (start-eceval)     (set! the-global-environment (setup-environment))     (set-register-contents! eceval 'flag false)     (start eceval))   50 Since a compiled procedure is an object that the system may try to print, we also modify the system print operation user-print  (from section 4.1.4 ) so that it will not attempt to print the components of a compiled procedure: (define (user-print object)     (cond ((compound-procedure? object)            (displ


key: chroma:document
string_value:
ay (list 'compound-procedure                           (procedure-parameters object)                           (procedure-body object)                           '<procedure-env>)))           ((compiled-procedure? object)            (display '<compiled-procedure>))           (else (display object))))   51 We can do even better by extending the compiler to allow compiled code to call interpreted procedures. See exercise 5.47. 52 Independent of the strategy of execution, we incur significant overhead if we insist that errors encountered in execution of a user program be detected and signaled, rather than being allowed to kill the system or produce wrong answers. For example, an out-of-bounds array reference can be detected by checking the validity of the reference before performing it. The overhead of checking, however , can be many times the cost of the array reference itself, and a programmer should weigh speed against safety in determining whether such a check is desirable. A good compiler should be able to p


key: chroma:document
string_value:
roduce code with such checks,should avoid redundant checks, and should allow programmers to control the extent and type of error checking in the compiled code. Compilers for popular languages, such as C and C++, put hardly any error -checking operations into running code, so as to make things run as fast as possible. As a result, it falls to programmers to explicitly provide error checking. Unfortunately , people often neglect to do this, even in critical applications where speed is not a constraint. Their programs lead fast and dangerous lives. For example, the notorious “Worm” that paralyzed the Internet in 1988 exploited the UNIXTM operating system's failure to check whether the input buffer has overflowed in the finger daemon. (See Spaf ford 1989.) 53 Of course, with either the interpretation or the compilation strategy we must also implement for the new machine storage allocation, input and output, and all the various operations that we took as “primitive” in our discussion of the evaluator and compiler 


key: chroma:document
string_value:
. One strategy for minimizing work here is to write as many of these operations as possible in Lisp and then compile them for the new machine. Ultimately , everything reduces to a small kernel (such as garbage collection and the mechanism for applying actual machine primitives) that is hand-coded for the new machine. 54 This strategy leads to amusing tests of correctness of the compiler , such as checking whether the compilation of a program on the new machine, using the compiled compiler , is identical with the compilation of the program on the original Lisp system. Tracking down the source of dif ferences is fun but often frustrating, because the results are extremely sensitive to minuscule details.  References Abelson, Harold, Andrew Berlin, Jacob Katzenelson, William McAllister , Guillermo Rozas, Gerald Jay Sussman, and Jack W isdom. 1992. The Supercomputer T oolkit: A general framework for special-purpose computing. International Journal of High-Speed Electr onics  3(3):337-361. Allen, John. 1978. Anatom


key: chroma:document
string_value:
y of Lisp.  New Y ork: McGraw-Hill. ANSI X3.226-1994. American National Standar d for Information Systems – Programming Language – Common Lisp. Appel, Andrew W . 1987. Garbage collection can be faster than stack allocation. Information Pr ocessing Letters  25(4):275-279. Backus, John. 1978. Can programming be liberated from the von Neumann style? Communications of the ACM  21(8):613-641. Baker , Henry G., Jr . 1978. List processing in real time on a serial computer . Communications of the ACM  21(4):280-293. Batali, John, Neil Mayle, Howard Shrobe, Gerald Jay Sussman, and Daniel Weise. 1982. The Scheme-81 architecture – System and chip. In Proceedings of the MIT Confer ence on Advanced Resear ch in VLSI,  edited by Paul Penfield, Jr . Dedham, MA: Artech House. Borning, Alan. 1977. ThingLab – An object-oriented system for building simulations using constraints. In Proceedings of the 5th International Joint Confer ence on Artificial Intelligence. Borodin, Alan, and Ian Munro. 1975. The Computational Complexity 


key: chroma:document
string_value:
of Algebraic and Numeric Pr oblems.  New Y ork: American Elsevier . Chaitin, Gregory J. 1975. Randomness and mathematical proof. Scientific American  232(5):47-52.Church, Alonzo. 1941. The Calculi of Lambda-Conversion.  Princeton, N.J.: Princeton University Press. Clark, Keith L. 1978. Negation as failure. In Logic and Data Bases.  New York: Plenum Press, pp. 293-322. Clinger , William. 1982. Nondeterministic call by need is neither lazy nor by name. In Proceedings of the ACM Symposium on Lisp and Functional Programming,  pp. 226-234. Clinger , William, and Jonathan Rees. 1991. Macros that work. In Proceedings of the 1991 ACM Confer ence on Principles of Pr ogramming Languages,  pp. 155-162. Colmerauer A., H. Kanoui, R. Pasero, and P . Roussel. 1973. Un système de communication homme-machine en français. Technical report, Groupe Intelligence Artificielle, Université d'Aix Marseille, Luminy . Cormen, Thomas, Charles Leiserson, and Ronald Rivest. 1990. Introduction to Algorithms.  Cambridge, MA: MIT Press. Darl


key: chroma:document
string_value:
ington, John, Peter Henderson, and David T urner . 1982. Functional Programming and Its Applications.  New Y ork: Cambridge University Press. Dijkstra, Edsger W . 1968a. The structure of the “THE” multiprogramming system. Communications of the ACM  11(5):341-346. Dijkstra, Edsger W . 1968b. Cooperating sequential processes. In Programming Languages , edited by F . Genuys. New Y ork: Academic Press, pp. 43-1 12. Dinesman, Howard P . 1968. Superior Mathematical Puzzles . New York: Simon and Schuster . deKleer , Johan, Jon Doyle, Guy Steele, and Gerald J. Sussman. 1977. AMORD: Explicit control of reasoning. In Proceedings of the ACM Symposium on Artificial Intelligence and Pr ogramming Languages,  pp. 116-125.Doyle, Jon. 1979. A truth maintenance system. Artificial Intelligence 12:231-272. Feigenbaum, Edward, and Howard Shrobe. 1993. The Japanese National Fifth Generation Project: Introduction, survey , and evaluation. In Futur e Generation Computer Systems,  vol. 9, pp. 105-1 17. Feeley , Marc. 1986. Deux appro


key: chroma:document
string_value:
ches à l'implantation du language Scheme. Masters thesis, Université de Montréal. Feeley , Marc and Guy Lapalme. 1987. Using closures for code generation. Journal of Computer Languages  12(1):47-66. Feller , William. 1957. An Intr oduction to Pr obability Theory and Its Applications,  volume 1. New Y ork: John W iley & Sons. Fenichel, R., and J. Y ochelson. 1969. A Lisp garbage collector for virtual memory computer systems. Communications of the ACM  12(1 1):61 1-612. Floyd, Robert. 1967. Nondeterministic algorithms. JACM,  14(4):636-644. Forbus, Kenneth D., and Johan deKleer . 1993. Building Pr oblem Solvers. Cambridge, MA: MIT Press. Friedman, Daniel P ., and David S. W ise. 1976. CONS should not evaluate its ar guments. In Automata, Languages, and Pr ogramming: Thir d International Colloquium,  edited by S. Michaelson and R. Milner , pp. 257- 284. Friedman, Daniel P ., Mitchell W and, and Christopher T . Haynes. 1992. Essentials of Pr ogramming Languages.  Cambridge, MA: MIT Press/McGraw-Hill. Gabriel, Ric


key: chroma:document
string_value:
hard P . 1988. The Why of Y. Lisp Pointers  2(2):15-25. Goldber g, Adele, and David Robson. 1983. Smalltalk-80: The Language and Its Implementation.  Reading, MA: Addison-W esley .Gordon, Michael, Robin Milner , and Christopher W adsworth. 1979. Edinbur gh LCF . Lecture Notes in Computer Science, volume 78. New York: Springer -Verlag. Gray , Jim, and Andreas Reuter . 1993. Transaction Pr ocessing: Concepts and Models.  San Mateo, CA: Mor gan-Kaufman. Green, Cordell. 1969. Application of theorem proving to problem solving. In Proceedings of the International Joint Confer ence on Artificial Intelligence,  pp. 219-240. Green, Cordell, and Bertram Raphael. 1968. The use of theorem-proving techniques in question-answering systems. In Proceedings of the ACM National Confer ence,  pp. 169-181. Griss, Martin L. 1981. Portable Standard Lisp, a brief overview . Utah Symbolic Computation Group Operating Note 58, University of Utah. Guttag, John V . 1977. Abstract data types and the development of data structures. Commun


key: chroma:document
string_value:
ications of the ACM  20(6):397-404. Hamming, Richard W . 1980. Coding and Information Theory . Englewood Cliffs, N.J.: Prentice-Hall. Hanson, Christopher P . 1990. Efficient stack allocation for tail-recursive languages. In Proceedings of ACM Confer ence on Lisp and Functional Programming,  pp. 106-1 18. Hanson, Christopher P . 1991. A syntactic closures macro facility . Lisp Pointers,  4(3). Hardy , Godfrey H. 1921. Srinivasa Ramanujan. Proceedings of the London Mathematical Society  XIX(2). Hardy , Godfrey H., and E. M. W right. 1960. An Intr oduction to the Theory of Numbers.  4th edition. New Y ork: Oxford University Press. Havender , J. 1968. A voiding deadlocks in multi-tasking systems. IBM Systems Journal  7(2):74-84.Hearn, Anthony C. 1969. Standard Lisp. Technical report AIM-90, Artificial Intelligence Project, Stanford University . Henderson, Peter . 1980. Functional Pr ogramming: Application and Implementation.  Englewood Clif fs, N.J.: Prentice-Hall. Henderson. Peter . 1982. Functional Geometry . I


key: chroma:document
string_value:
n Confer ence Recor d of the 1982 ACM Symposium on Lisp and Functional Pr ogramming,  pp. 179-187. Hewitt, Carl E. 1969. PLANNER: A language for proving theorems in robots. In Proceedings of the International Joint Confer ence on Artificial Intelligence,  pp. 295-301. Hewitt, Carl E. 1977. Viewing control structures as patterns of passing messages. Journal of Artificial Intelligence  8(3):323-364. Hoare, C. A. R. 1972. Proof of correctness of data representations. Acta Informatica  1(1). Hodges, Andrew . 1983. Alan T uring: The Enigma.  New Y ork: Simon and Schuster . Hofstadter , Douglas R. 1979. Gödel, Escher , Bach: An Eternal Golden Braid.  New Y ork: Basic Books. Hughes, R. J. M. 1990. Why functional programming matters. In Resear ch Topics in Functional Pr ogramming , edited by David T urner . Reading, MA: Addison-W esley , pp. 17-42. IEEE Std 1 178-1990. 1990. IEEE Standar d for the Scheme Pr ogramming Language. Ingerman, Peter , Edgar Irons, Kirk Sattley , and W allace Feurzeig; assisted by M. Lind, H


key: chroma:document
string_value:
erbert Kanner , and Robert Floyd. 1960. THUNKS: A way of compiling procedure statements, with some comments on procedure declarations. Unpublished manuscript. (Also, private communication from Wallace Feurzeig.)Kaldewaij, Anne. 1990. Programming: The Derivation of Algorithms.  New York: Prentice-Hall. Kohlbecker , Eugene Edmund, Jr . 1986. Syntactic extensions in the programming language Lisp. Ph.D. thesis, Indiana University . Konopasek, Milos, and Sundaresan Jayaraman. 1984. The TK!Solver Book: A Guide to Pr oblem-Solving in Science, Engineering, Business, and Education.  Berkeley , CA: Osborne/McGraw-Hill. Knuth, Donald E. 1973. Fundamental Algorithms.  Volume 1 of The Art of Computer Pr ogramming.  2nd edition. Reading, MA: Addison-W esley . Knuth, Donald E. 1981. Seminumerical Algorithms.  Volume 2 of The Art of Computer Pr ogramming.  2nd edition. Reading, MA: Addison-W esley . Kowalski, Robert. 1973. Predicate logic as a programming language. Technical report 70, Department of Computational Logic, Scho


key: chroma:document
string_value:
ol of Artificial Intelligence, University of Edinbur gh. Kowalski, Robert. 1979. Logic for Pr oblem Solving.  New Y ork: North- Holland. Lamport, Leslie. 1978. Time, clocks, and the ordering of events in a distributed system. Communications of the ACM  21(7):558-565. Lampson, Butler , J. J. Horning, R. London, J. G. Mitchell, and G. K. Popek. 1981. Report on the programming language Euclid. Technical report, Computer Systems Research Group, University of T oronto. Landin, Peter . 1965. A correspondence between Algol 60 and Church's lambda notation: Part I. Communications of the ACM  8(2):89-101. Lieberman, Henry , and Carl E. Hewitt. 1983. A real-time garbage collector based on the lifetimes of objects. Communications of the ACM  26(6):419- 429. Liskov , Barbara H., and Stephen N. Zilles. 1975. Specification techniques for data abstractions. IEEE T ransactions on Softwar e Engineering  1(1):7-19. McAllester , David Allen. 1978. A three-valued truth-maintenance system. Memo 473, MIT Artificial Intelligence Lab


key: chroma:document
string_value:
oratory . McAllester , David Allen. 1980. An outlook on truth maintenance. Memo 551, MIT Artificial Intelligence Laboratory . McCarthy , John. 1960. Recursive functions of symbolic expressions and their computation by machine. Communications of the ACM  3(4):184-195. McCarthy , John. 1967. A basis for a mathematical theory of computation. In Computer Pr ograming and Formal Systems , edited by P . Braf fort and D. Hirschber g. North-Holland. McCarthy , John. 1978. The history of Lisp. In Proceedings of the ACM SIGPLAN Confer ence on the History of Pr ogramming Languages. McCarthy , John, P . W. Abrahams, D. J. Edwards, T . P. Hart, and M. I. Levin. 1965. Lisp 1.5 Pr ogrammer's Manual.  2nd edition. Cambridge, MA: MIT Press. McDermott, Drew , and Gerald Jay Sussman. 1972. Conniver reference manual. Memo 259, MIT Artificial Intelligence Laboratory . Miller , Gary L. 1976. Riemann's Hypothesis and tests for primality . Journal of Computer and System Sciences  13(3):300-317. Miller , James S., and Guillermo J. Roz


key: chroma:document
string_value:
as. 1994. Garbage collection is fast, but a stack is faster . Memo 1462, MIT Artificial Intelligence Laboratory . Moon, David. 1978. MacLisp reference manual, V ersion 0. Technical report, MIT Laboratory for Computer Science. Moon, David, and Daniel W einreb. 1981. Lisp machine manual. Technical report, MIT Artificial Intelligence Laboratory . Morris, J. H., Eric Schmidt, and Philip W adler . 1980. Experience with an applicative string processing language. In Proceedings of the 7th AnnualACM SIGACT/SIGPLAN Symposium on the Principles of Pr ogramming Languages. Phillips, Hubert. 1934. The Sphinx Pr oblem Book . London: Faber and Faber . Pitman, Kent. 1983. The revised MacLisp Manual (Saturday evening edition). Technical report 295, MIT Laboratory for Computer Science. Rabin, Michael O. 1980. Probabilistic algorithm for testing primality . Journal of Number Theory  12:128-138. Raymond, Eric. 1993. The New Hacker's Dictionary . 2nd edition. Cambridge, MA: MIT Press. Raynal, Michel. 1986. Algorithms for Mutual Ex


key: chroma:document
string_value:
clusion.  Cambridge, MA: MIT Press. Rees, Jonathan A., and Norman I. Adams IV . 1982. T: A dialect of Lisp or , lambda: The ultimate software tool. In Confer ence Recor d of the 1982 ACM Symposium on Lisp and Functional Pr ogramming,  pp. 1 14-122. Rees, Jonathan, and W illiam Clinger (eds). 1991. The revised4 report on the algorithmic language Scheme. Lisp Pointers,  4(3). Rivest, Ronald, Adi Shamir , and Leonard Adleman. 1977. A method for obtaining digital signatures and public-key cryptosystems. T echnical memo LCS/TM82, MIT Laboratory for Computer Science. Robinson, J. A. 1965. A machine-oriented logic based on the resolution principle. Journal of the ACM  12(1):23. Robinson, J. A. 1983. Logic programming – Past, present, and future. New Generation Computing  1:107-124. Spafford, Eugene H. 1989. The Internet W orm: Crisis and aftermath. Communications of the ACM  32(6):678-688.Steele, Guy Lewis, Jr . 1977. Debunking the “expensive procedure call” myth. In Proceedings of the National Confer ence of the AC


key: chroma:document
string_value:
M,  pp. 153-62. Steele, Guy Lewis, Jr . 1982. An overview of Common Lisp. In Proceedings of the ACM Symposium on Lisp and Functional Pr ogramming,  pp. 98-107. Steele, Guy Lewis, Jr . 1990. Common Lisp: The Language.  2nd edition. Digital Press. Steele, Guy Lewis, Jr ., and Gerald Jay Sussman. 1975. Scheme: An interpreter for the extended lambda calculus. Memo 349, MIT  Artificial Intelligence Laboratory . Steele, Guy Lewis, Jr ., Donald R. W oods, Raphael A. Finkel, Mark R. Crispin, Richard M. Stallman, and Geof frey S. Goodfellow . 1983. The Hacker's Dictionary . New Y ork: Harper & Row . Stoy, Joseph E. 1977. Denotational Semantics.  Cambridge, MA: MIT Press. Sussman, Gerald Jay , and Richard M. Stallman. 1975. Heuristic techniques in computer -aided circuit analysis. IEEE T ransactions on Cir cuits and Systems  CAS-22(1 1):857-865. Sussman, Gerald Jay , and Guy Lewis Steele Jr . 1980. Constraints – A language for expressing almost-hierachical descriptions. AI Journal  14:1- 39. Sussman, Gerald Jay , and J


key: chroma:document
string_value:
ack W isdom. 1992. Chaotic evolution of the solar system. Science  257:256-262. Sussman, Gerald Jay , Terry W inograd, and Eugene Charniak. 1971. Microplanner reference manual. Memo 203A, MIT Artificial Intelligence Laboratory . Sutherland, Ivan E. 1963. SKETCHP AD: A man-machine graphical communication system. Technical report 296, MIT Lincoln Laboratory . Teitelman, W arren. 1974. Interlisp reference manual. Technical report, Xerox Palo Alto Research Center .Thatcher , James W ., Eric G. W agner , and Jesse B. W right. 1978. Data type specification: Parameterization and the power of specification techniques. In Confer ence Recor d of the T enth Annual ACM Symposium on Theory of Computing , pp. 1 19-132. Turner , David. 1981. The future of applicative languages. In Proceedings of the 3r d Eur opean Confer ence on Informatics, Lecture Notes in Computer Science, volume 123. New Y ork: Springer - Verlag, pp. 334-348. Wand, Mitchell. 1980. Continuation-based program transformation strategies. Journal of the ACM 


key: chroma:document
string_value:
 27(1):164-180. Waters, Richard C. 1979. A method for analyzing loop programs. IEEE Transactions on Softwar e Engineering  5(3):237-247. Winograd, T erry. 1971. Procedures as a representation for data in a computer program for understanding natural language. Technical report AI TR-17, MIT Artificial Intelligence Laboratory . Winston, Patrick. 1992. Artificial Intelligence . 3rd edition. Reading, MA: Addison-W esley . Zabih, Ramin, David McAllester , and David Chapman. 1987. Non- deterministic Lisp with dependency-directed backtracking. AAAI-87 , pp. 59-64. Zippel, Richard. 1979. Probabilistic algorithms for sparse polynomials. Ph.D. dissertation, Department of Electrical Engineering and Computer Science, MIT . Zippel, Richard. 1993. Effective Polynomial Computation.  Boston, MA: Kluwer Academic Publishers.  List of Exercises 1.1  1.2  1.3  1.4  1.5  1.6  1.7  1.8  1.9  1.10  1.11  1.12  1.13  1.14  1.15  1.16  1.17  1.18  1.19  1.20  1.21  1.22  1.23  1.24  1.25  1.26  1.27  1.28  1.29  1.30  1.31  1.32 1.33 


key: chroma:document
string_value:
 1.34  1.35  1.36  1.37  1.38  1.39  1.40  1.41  1.42  1.43  1.44  1.45  1.46  2.1  2.2  2.3  2.4  2.5  2.6  2.7  2.8  2.9  2.10  2.11  2.12  2.13  2.14  2.15  2.16  2.17  2.18  2.19  2.20  2.21  2.22  2.23 2.24  2.25  2.26  2.27  2.28  2.29  2.30  2.31  2.32  2.33  2.34  2.35  2.36  2.37  2.38  2.39  2.40  2.41  2.42  2.43  2.44  2.45  2.46  2.47  2.48  2.49  2.50  2.51  2.52  2.53  2.54  2.55  2.56  2.57  2.58  2.59  2.60 2.61  2.62  2.63  2.64  2.65  2.66  2.67  2.68  2.69  2.70  2.71  2.72  2.73  2.74  2.75  2.76  2.77  2.78  2.79  2.80  2.81  2.82  2.83  2.84  2.85  2.86  2.87  2.88  2.89  2.90  2.91  2.92  2.93  2.94  2.95  2.96  2.97 3.1  3.2  3.3  3.4  3.5  3.6  3.7  3.8  3.9  3.10  3.11  3.12  3.13  3.14  3.15  3.16  3.17  3.18  3.19  3.20  3.21  3.22  3.23  3.24  3.25  3.26  3.27  3.28  3.29  3.30  3.31  3.32  3.33  3.34  3.35  3.36  3.37 3.38  3.39  3.40  3.41  3.42  3.43  3.44  3.45  3.46  3.47  3.48  3.49  3.50  3.51  3.52  3.53  3.54  3.55  3.56  3.57  3.58  3.59  3.60  3.61  3.62  3.63  3.64  3


key: chroma:document
string_value:
.65  3.66  3.67  3.68  3.69  3.70  3.71  3.72  3.73  3.74 3.75  3.76  3.77  3.78  3.79  3.80  3.81  3.82  4.1  4.2  4.3  4.4  4.5  4.6  4.7  4.8  4.9  4.10  4.11  4.12  4.13  4.14  4.15  4.16  4.17  4.18  4.19  4.20  4.21  4.22  4.23  4.24  4.25  4.26  4.27  4.28  4.29 4.30  4.31  4.32  4.33  4.34  4.35  4.36  4.37  4.38  4.39  4.40  4.41  4.42  4.43  4.44  4.45  4.46  4.47  4.48  4.49  4.50  4.51  4.52  4.53  4.54  4.55  4.56  4.57  4.58  4.59  4.60  4.61  4.62  4.63  4.64  4.65  4.66 4.67  4.68  4.69  4.70  4.71  4.72  4.73  4.74  4.75  4.76  4.77  4.78  4.79  5.1  5.2  5.3  5.4  5.5  5.6  5.7  5.8  5.9  5.10  5.11  5.12  5.13  5.14  5.15  5.16  5.17  5.18  5.19  5.20  5.21  5.22  5.23  5.24 5.25  5.26  5.27  5.28  5.29  5.30  5.31  5.32  5.33  5.34  5.35  5.36  5.37  5.38  5.39  5.40  5.41  5.42  5.43  5.44  5.45  5.46  5.47  5.48  5.49  5.50  5.51  5.52   Index Any inaccuracies in this index may be explained by the fact that it has been prepared with the help of a computer . Donald E. Knuth, Fundamental A


key: chroma:document
string_value:
lgorithms  (Volume 1 of The Art of Computer Pr ogramming )   ! in names   " (double quote)   λ calculus, see lambda calculus   ⟼ notation for mathematical function   π , see pi   Σ (sigma) notation   θ, see theta   ' (single quote)       read  and, [2]  * (primitive multiplication procedure)   + (primitive addition procedure)   , (comma, used with backquote)   - (primitive subtraction procedure)       as negation   / (primitive division procedure)   < (primitive numeric comparison predicate) = (primitive numeric equality predicate)   =number?   =zero?  (generic)       for polynomials   > (primitive numeric comparison predicate) >=, [2]  ? , in predicate names   #f  #t ` (backquote)   ;, see semicolon   Abelson, Harold   abs, [2], [3]  absolute value   abstract data , see also  data abstraction   abstract models for data   abstract syntax       in metacircular evaluator       in query interpreter   abstraction, see also  means of abstraction; data abstraction; higher -order procedures       common pattern and 


key: chroma:document
string_value:
      metalinguistic       procedural       in register -machine design       of search in nondeterministic programming   abstraction barriers , [2], [3]      in complex-number system       in generic arithmetic system   accelerated-sequence   accumulate , [2]      same as fold-right   accumulate-n   accumulator , [2]  Áchárya, Bháscara   Ackermann's function   acquire a mutex   actions, in register machine   actual-value   Ada      recursive procedures   Adams, Norman I., IV   add (generic)       used for polynomial coef ficients , [2] add-action! , [2]  add-binding-to-frame!   add-complex   add-complex-to-schemenum   add-interval   add-lists   add-poly   add-rat   add-rule-or-assertion!   add-streams   add-terms   add-to-agenda! , [2]  add-vect   addend   adder       full      half      ripple-carry   adder  (primitive constraint)   additivity , [2], [3], [4]  address   address arithmetic   Adelman, Leonard   adjoin-arg   adjoin-set       binary-tree representation       ordered-list representation       un


key: chroma:document
string_value:
ordered-list representation       for weighted sets   adjoin-term , [2]  advance-pc   after-delay , [2]  agenda, see digital-circuit simulation   A'h-mose   algebra, symbolic, see symbolic algebra   algebraic expression       differentiating      representing       simplifying   algebraic specification for data   Algol       block structure       call-by-name ar gument passing , [2]      thunks , [2]      weakness in handling compound objects   algorithm       optimal       probabilistic , [2]  aliasing   all-regs  (compiler)   Allen, John   alternative of if  always-true   amb  amb evaluator , see nondeterministic evaluator   ambeval   an-element-of   an-integer-starting-from   analog computer   analyze        metacircular       nondeterministic   analyze-...        metacircular , [2]      nondeterministic   analyze-amb   analyzing evaluator       as basis for nondeterministic evaluator       let  and (query language)       evaluation of , [2], [3]  and (special form)       evaluation of       why a special 


key: chroma:document
string_value:
form      with no subexpressions   and-gate       and-gate   angle        data-directed       polar representation       rectangular representation       with tagged data   angle-polar   angle-rectangular   announce-output   APL   Appel, Andrew W .  append , [2], [3]      as accumulation       append!  vs.      with arbitrary number of ar guments       as register machine       “what is” (rules) vs. “how to” (procedure)   append!       as register machine   append-instruction-sequences , [2]  append-to-form  (rules)   application?   applicative-order evaluation       in Lisp       normal order vs. , [2], [3]  apply  (lazy)   apply  (metacircular)       primitive apply  vs.  apply  (primitive procedure)   apply-dispatch       modified for compiled code   apply-generic       with coercion , [2]      with coercion by raising       with coercion of multiple ar guments      with coercion to simplify       with message passing       with tower of types   apply-primitive-procedure , [2], [3]  apply-rules   arbiter  


key: chroma:document
string_value:
 arctangent   argl  register   argument passing, see call-by-name ar gument passing; call-by-need argument passing   argument(s)       arbitrary number of , [2]      delayed   Aristotle's De caelo  (Buridan's commentary on)   arithmetic       address arithmetic       generic , see also  generic arithmetic operations       on complex numbers       on intervals       on polynomials, see polynomial arithmetic       on power series , [2]      on rational numbers       primitive procedures for   articles   ASCII code   assemble , [2]  assembler , [2]  assert!  (query interpreter)   assertion       implicit   assign  (in register machine)       simulating       storing label in register   assign-reg-name   assign-value-exp   assignment , see also  set!        benefits of      bugs associated with , [2]      costs of   assignment operator , see also  set!    assignment-value   assignment-variable   assignment?   assoc   atan  (primitive procedure)   atomic operations supported in hardware   atomic requirement for te


key: chroma:document
string_value:
st-and-set!   attach-tag       using Scheme data types   augend   automagically   automatic search , see also  search       history of   automatic storage allocation   average   average damping   average-damp   averager  (constraint)   B-tree   backquote   backtracking , see also  nondeterministic computing   Backus, John   Baker , Henry G., Jr .  balanced binary tree , see also  binary tree   balanced mobile   bank account , [2]      exchanging balances       joint, [2]      joint, modeled with streams       joint, with concurrent access       password-protected       serialized      stream model       transferring money   barrier synchronization   Barth, John   Basic       restrictions on compound data       weakness in handling compound objects   Batali, John Dean   begin  (special form)       implicit in consequent of cond  and in procedure body   begin-actions   begin?   below , [2]  Bertrand's Hypothesis beside , [2]  bignum   binary numbers, addition of, see adder   binary search   binary tree       ba


key: chroma:document
string_value:
lanced       converting a list to a       converting to a list       for Huf fman encoding       represented with lists       sets represented as       table structured as   bind  binding       deep   binomial coef ficients   black box   block structure , [2]      in environment model       in query language   blocked process   body of a procedure   Bolt Beranek and Newman Inc.  Borning, Alan   Borodin, Alan   bound variable   box-and-pointer notation       end-of-list marker   branch  (in register machine)       simulating   branch of a tree   branch-dest   breakpoint   broken heart   bug      capturing a free variable       order of assignments       side ef fect with aliasing   bureaucracy   Buridan, Jean   busy-waiting   C       compiling Scheme into       error handling , [2]      recursive procedures       restrictions on compound data       Scheme interpreter written in , [2]  ca...r  cache-coherence protocols   cadr   calculator , fixed points with   call-by-name ar gument passing , [2]  call-by-need 


key: chroma:document
string_value:
ar gument passing , [2]      memoization and   call-each   cancer of the semicolon   canonical form, for polynomials   capturing a free variable  car (primitive procedure)       axiom for       implemented with vectors       as list operation       origin of the name       procedural implementation of , [2], [3], [4], [5]  Carmichael numbers , [2]  case analysis       data-directed programming vs.       general , see also  cond        with two cases ( if)  cd...r  cdr (primitive procedure)       axiom for       implemented with vectors       as list operation       origin of the name       procedural implementation of , [2], [3], [4], [5]  cdr down a list   cell, in serializer implementation   celsius-fahrenheit-converter       expression-oriented   center   Cesàro, Ernesto   cesaro-stream   cesaro-test   Chaitin, Gregory   Chandah-sutra   change and sameness       meaning of       shared data and   changing money , see counting change   chaos in the Solar System   Chapman, David   character strings       pri


key: chroma:document
string_value:
mitive procedures for , [2]      quotation of  character , ASCII encoding   Charniak, Eugene   Chebyshev , Pafnutii L'vovich   chess, eight-queens puzzle , [2]  chip implementation of Scheme , [2]  chronological backtracking   Chu Shih-chieh   Church numerals   Church, Alonzo , [2]  Church-T uring thesis   circuit       digital, see digital-circuit simulation       modeled with streams , [2]  Clark, Keith L.   clause, of a cond       additional syntax   Clinger , William , [2]  closed world assumption   closure       in abstract algebra       closure property of cons       closure property of picture-language operations , [2]      lack of in many languages   coal, bituminous   code       ASCII       fixed-length       Huf fman, see Huffman code       Morse       prefix       variable-length   code generator       arguments of       value of   coeff , [2]  coercion       in algebraic manipulation      in polynomial arithmetic       procedure       table   Colmerauer , Alain   combination       combination as o


key: chroma:document
string_value:
perator of       compound expression as operator of       evaluation of       lambda  expression as operator of       as operator of combination       as a tree   combination, means of , see also  closure   comma, used with backquote   comments in programs   Common Lisp       treatment of nil  compacting garbage collector   compilation, see compiler   compile   compile-and-go , [2]  compile-and-run   compile-application   compile-assignment   compile-definition   compile-if   compile-lambda   compile-linkage   compile-proc-appl   compile-procedure-call   compile-quoted   compile-self-evaluating   compile-sequence   compile-time environment , [2], [3]      open coding and   compile-variable   compiled-apply   compiled-procedure-entry  compiled-procedure-env   compiled-procedure?   compiler       interpreter vs. , [2]      tail recursion, stack allocation, and garbage-collection   compiler for Scheme , see also  code generator; compile-time environment; instruction sequence; linkage descriptor; tar get register


key: chroma:document
string_value:
       analyzing evaluator vs. , [2]      assignments       code generators, see compile-...        combinations       conditionals       definitions       efficiency       example compilation       explicit-control evaluator vs. , [2], [3]      expression-syntax procedures       interfacing to evaluator       label generation       lambda  expressions       lexical addressing       linkage code       machine-operation use       monitoring performance (stack use) of compiled code , [2], [3]      open coding of primitives , [2]      order of operand evaluation       procedure applications       quotations       register use , [2], [3]      running compiled code       scanning out internal definitions , [2]      self-evaluating expressions       sequences of expressions       stack usage , [2], [3]      structure of       tail-recursive code generated by       variables  complex  package   complex numbers       polar representation       rectangular representation       rectangular vs. polar form       represen


key: chroma:document
string_value:
ted as tagged data   complex->complex   complex-number arithmetic       interfaced to generic arithmetic system       structure of system   composition of functions   compound data, need for   compound expression , see also  combination; special form       as operator of combination   compound procedure , see also  procedure       used like primitive procedure   compound query       processing , [2], [3], [4], [5]  compound-apply   compound-procedure?   computability , [2]  computational process , see also  process   computer science , [2]      mathematics vs. , [2]  concrete data representation   concurrency       correctness of concurrent programs       deadlock       functional programming and       mechanisms for controlling   cond  (special form)       additional clause syntax       clause       evaluation of       if vs.      implicit begin  in consequent   cond->if  cond-actions   cond-clauses   cond-else-clause?   cond-predicate   cond?   conditional expression       cond       if  congruent modulo n 


key: chroma:document
string_value:
 conjoin   connect , [2]  connector(s), in constraint system       operations on       representing   Conniver   cons  (primitive procedure)       axiom for       closure property of       implemented with mutators       implemented with vectors       as list operation       meaning of the name       procedural implementation of , [2], [3], [4], [5], [6]  cons  up a list   cons-stream  (special form) , [2]      lazy evaluation and       why a special form   consciousness, expansion of   consequent       of cond  clause       of if  const  (in register machine)       simulating       syntax of   constant  (primitive constraint)   constant, specifying in register machine   constant-exp  constant-exp-value   constraint network   constraint(s)       primitive       propagation of   construct-arglist   constructor       as abstraction barrier   contents       using Scheme data types   continuation       in nondeterministic evaluator , [2], see also  failure continuation; success continuation       in register -mac


key: chroma:document
string_value:
hine simulator   continue  register       in explicit-control evaluator       recursion and   continued fraction       e as      golden ratio as       tangent as   control structure   controller for register machine       controller diagram   conventional interface       sequence as   Cormen, Thomas H.   corner-split   correctness of a program   cos (primitive procedure)   cosine       fixed point of       power series for   cosmic radiation   count-change   count-leaves , [2]      as accumulation      as register machine   count-pairs   counting change , [2]  credit-card accounts, international   Cressey , David   cross-type operations   cryptography   cube , [2], [3]  cube root       as fixed point       by Newton's method   cube-root   current time, for simulation agenda   current-time , [2]  cycle in list       detecting   Darlington, John   data, [2]      abstract , see also  data abstraction       abstract models for       algebraic specification for       compound       concrete representation of      


key: chroma:document
string_value:
 hierarchical , [2]      list-structured       meaning of       mutable, see mutable data objects       numerical       procedural representation of       as program       shared       symbolic       tagged , [2]  data abstraction , [2], [3], [4], [5], see also  metacircular evaluator       for queue  data base       data-directed programming and       indexing , [2]      Insatiable Enterprises personnel       logic programming and       Microshaft personnel       as set of records   data paths for register machine       data-path diagram   data types       in Lisp       in strongly typed languages   data-directed programming , [2]      case analysis vs.       in metacircular evaluator       in query interpreter   data-directed recursion   deadlock       avoidance       recovery   debug   decimal point in numbers   declarative vs. imperative knowledge , [2]      logic programming and , [2]      nondeterministic computing and   decode   decomposition of program into parts   deep binding   deep-reverse   deferr


key: chroma:document
string_value:
ed operations   define  (special form)       with dotted-tail notation       environment model of       lambda  vs.      for procedures , [2]      syntactic sugar       value of      why a special form   define  (special form)       internal, see internal definition   define-variable! , [2]  definite integral       estimated with Monte Carlo simulation , [2]  definition, see define ; internal definition   definition-value   definition-variable   definition?   deKleer , Johan , [2]  delay  (special form)       explicit       explicit vs. automatic       implementation using lambda       lazy evaluation and       memoized , [2]      why a special form   delay , in digital circuit   delay-it   delayed ar gument delayed evaluation , [2]      assignment and       explicit vs. automatic       in lazy evaluator       normal-order evaluation and       printing and       streams and   delayed object   delete-queue! , [2]  denom , [2]      axiom for       reducing to lowest terms   dense polynomial   dependency-directe


key: chroma:document
string_value:
d backtracking   deposit  , with external serializer   deposit  message for bank account  depth-first search   deque   deriv  (numerical)   deriv  (symbolic)       data-directed   derivative of a function   derived expressions in evaluator       adding to explicit-control evaluator   design, stratified   differential equation , see also  solve        second-order , [2]  differentiation       numerical       rules for , [2]      symbolic , [2]  diffusion, simulation of   digital signal   digital-circuit simulation       agenda       agenda implementation       primitive function boxes       representing wires       sample simulation   Dijkstra, Edsger W ybe  Dinesman, Howard P .  Diophantus's Arithmetic , Fermat's copy of   disjoin   dispatching       comparing dif ferent styles       on type , see also  data-directed programming   display  (primitive procedure) , [2]  display-line   display-stream   distinct?   div (generic)   div-complex   div-interval      division by zero   div-poly   div-rat   div-series 


key: chroma:document
string_value:
  div-terms   divides?   divisible?   division of integers   dog, perfectly rational, behavior of   DOS/W indows   dot-product   dotted-tail notation       for procedure parameters , [2]      in query pattern , [2]      in query-language rule       read  and  Doyle, Jon   draw-line   driver loop       in explicit-control evaluator       in lazy evaluator       in metacircular evaluator       in nondeterministic evaluator , [2]      in query interpreter , [2]  driver-loop        for lazy evaluator       for metacircular evaluator       for nondeterministic evaluator   e       as continued fraction       as solution to dif ferential equation   ex, power series for   Earth, measuring circumference of   edge1-frame   edge2-frame  efficiency , see also  order of growth, see also  order of growth       of compilation       of data-base access       of evaluation       of Lisp       of query processing       of tree-recursive process   EIEIO   eight-queens puzzle , [2]  electrical circuits, modeled with streams , [2


key: chroma:document
string_value:
]  element-of-set?       binary-tree representation       ordered-list representation       unordered-list representation   else  (special symbol in cond )  embedded language, language design using   empty list       denoted as '()      recognizing with null?   empty stream   empty-agenda? , [2]  empty-arglist   empty-instruction-sequence   empty-queue? , [2]  empty-termlist? , [2]  encapsulated name   enclosing environment   enclosing-environment   encode   end-of-list marker   end-segment , [2]  end-with-linkage   engineering vs. mathematics   entry   enumerate-interval   enumerate-tree   enumerator  env register   environment , [2]      compile-time, see compile-time environment       as context for evaluation       enclosing       global, see global environment       lexical scoping and       in query interpreter       renaming vs.   environment model of evaluation , [2]     environment structure       internal definitions       local state       message passing       metacircular evaluator and       proc


key: chroma:document
string_value:
edure-application example       rules for evaluation       tail recursion and   eq? (primitive procedure)       for arbitrary objects       as equality of pointers , [2]      implementation for symbols       numerical equality and   equ?  (generic predicate)   equal-rat?   equal?   equality       in generic arithmetic system       of lists       of numbers , [2], [3]      referential transparency and       of symbols   equation, solving, see half-interval method; Newton's method; solve    Eratosthenes   error  (primitive procedure)   error handling       in compiled code      in explicit-control evaluator , [2]  Escher , Maurits Cornelis   estimate-integral   estimate-pi , [2]  Euclid's Algorithm , [2], see also  greatest common divisor       order of growth       for polynomials   Euclid's Elements   Euclid's proof of infinite number of primes   Euclidean ring   Euler , Leonhard       proof of Fermat's Little Theorem       series accelerator   euler-transform   ev-application   ev-assignment   ev-begin   ev-


key: chroma:document
string_value:
definition   ev-if   ev-lambda   ev-quoted   ev-self-eval   ev-sequence        with tail recursion       without tail recursion   ev-variable   eval  (lazy)   eval  (metacircular) , [2]      analyzing version       data-directed       primitive eval  vs.  eval  (primitive procedure)       MIT Scheme       used in query interpreter   eval-assignment   eval-definition   eval-dispatch  eval-if  (lazy)   eval-if  (metacircular)   eval-sequence   evaluation       applicative-order , see applicative-order evaluation       delayed, see delayed evaluation       environment model of, see environment model of evaluation       models of       normal-order , see normal-order evaluation       of a combination       of and      of cond       of if      of or      of primitive expressions       of special forms       order of subexpression evaluation, see order of evaluation       substitution model of, see substitution model of procedure application   evaluator , see also  interpreter       as abstract machine       metaci


key: chroma:document
string_value:
rcular       as universal machine   evaluators, see metacircular evaluator; analyzing evaluator; lazy evaluator; nondeterministic evaluator; query interpreter; explicit-control evaluator   even-fibs , [2]  even?   evening star , see Venus   event-driven simulation   evlis tail recursion   exact integer   exchange   exclamation point in names   execute   execute-application        metacircular       nondeterministic   execution procedure      in analyzing evaluator       in nondeterministic evaluator , [2], [3]      in register -machine simulator , [2]  exp register   expand-clauses   explicit-control evaluator for Scheme       assignments       combinations       compound procedures       conditionals       controller       data paths       definitions       derived expressions       driver loop       error handling , [2]      expressions with no subexpressions to evaluate       as machine-language program       machine model       modified for compiled code       monitoring performance (stack use)       norm


key: chroma:document
string_value:
al-order evaluation       operand evaluation       operations       optimizations (additional)       primitive procedures       procedure application       registers       running       sequences of expressions       special forms (additional) , [2]      stack usage       tail recursion , [2], [3]      as universal machine   expmod , [2], [3]  exponential growth       of tree-recursive Fibonacci-number computation  exponentiation       modulo n  expression, see also  compound expression; primitive expression       algebraic, see algebraic expressions       self-evaluating       symbolic , see also  symbol(s)   expression-oriented vs. imperative programming style   expt        linear iterative version       linear recursive version       register machine for   extend-environment , [2]  extend-if-consistent   extend-if-possible   external-entry   extract-labels , [2]   #f  factorial , see also  factorial        infinite stream       with letrec       without letrec  or define   factorial        as an abstract m


key: chroma:document
string_value:
achine       compilation of , [2]      environment structure in evaluating       linear iterative version       linear recursive version       register machine for (iterative) , [2]      register machine for (recursive) , [2]      stack usage, compiled       stack usage, interpreted , [2]      stack usage, register machine     with assignment       with higher -order procedures   failure continuation (nondeterministic evaluator) , [2]     constructed by amb      constructed by assignment       constructed by driver loop   failure, in nondeterministic computation       bug vs.       searching and   false   false   false?   fast-expt   fast-prime?   feedback loop, modeled with streams   Feeley , Marc   Feigenbaum, Edward   Fenichel, Robert   Fermat, Pierre de   Fermat test for primality       variant of   Fermat's Little Theorem       alternate form       proof   fermat-test   fetch-assertions   fetch-rules   fib       linear iterative version       logarithmic version       register machine for (tree-recursive


key: chroma:document
string_value:
) , [2]      stack usage, compiled       stack usage, interpreted       tree-recursive version , [2]      with memoization       with named let  Fibonacci numbers , see also  fib       Euclid's GCD algorithm and       infinite stream of, see fibs    fibs  (infinite stream)      implicit definition   FIFO buf fer  filter , [2]  filter   filtered-accumulate   find-assertions   find-divisor   first-agenda-item , [2]  first-class elements in language   first-exp   first-frame   first-operand   first-segment   first-term , [2]  fixed point       computing with calculator       of cosine       cube root as       fourth root as       golden ratio as       as iterative improvement       in Newton's method       nth root as       square root as , [2], [3]      of transformed function       unification and   fixed-length code   fixed-point       as iterative improvement   fixed-point-of-transform   flag  register   flatmap   flatten-stream   flip-horiz , [2]  flip-vert , [2]  flipped-pairs , [2], [3]  Floyd, Robert  fo


key: chroma:document
string_value:
ld-left   fold-right   for-each , [2]  for-each-except   Forbus, Kenneth D.   force , [2]      forcing a thunk vs.   force a thunk   force-it       memoized version   forget-value! , [2]  formal parameters       names of       scope of   formatting input expressions   Fortran , [2]      inventor of       restrictions on compound data   forwarding address   fourth root, as fixed point   fraction, see rational number(s)   frame (environment model)       as repository of local state       global   frame (picture language) , [2]      coordinate map   frame (query interpreter) , see also  pattern matching; unification       representation   frame-coord-map   frame-values   frame-variables   framed-stack discipline   Franz Lisp   free  register , [2]  free list   free variable       capturing      in internal definition   Friedman, Daniel P ., [2]  fringe       as a tree enumeration   front-ptr   front-queue , [2]  full-adder       full-adder   function (mathematical)        ⟼ notation for       Ackermann's       c


key: chroma:document
string_value:
omposition of       derivative of       fixed point of       procedure vs.       rational       repeated application of       smoothing of   function box, in digital circuit   functional programming , [2]      concurrency and       functional programming languages       time and   Gabriel, Richard P .  garbage collection       memoization and       mutation and       tail recursion and   garbage collector       compacting       mark-sweep       stop-and-copy   GCD, see greatest common divisor   gcd      register machine for , [2]gcd-terms   general-purpose computer , as universal machine   generate-huffman-tree   generating sentences   generic arithmetic operations       structure of system   generic operation   generic procedure , [2]      generic selector , [2] Genesis   get, [2]  get-contents   get-global-environment   get-register   get-register-contents , [2]  get-signal , [2]  get-value , [2]  glitch   global environment , [2]      in metacircular evaluator   global frame   Goguen, Joseph   golden ratio


key: chroma:document
string_value:
       as continued fraction       as fixed point   Gordon, Michael   goto  (in register machine)       label as destination       simulating   goto-dest   grammar   graphics, see picture language   Gray , Jim   greatest common divisor , see also  gcd       generic       of polynomials       used to estimate π      used in rational-number arithmetic   Green, Cordell   Griss, Martin Lewis   Guttag, John V ogel   half-adder       half-adder       simulation of   half-interval method       half-interval-method       Newton's method vs.   halting problem   Halting Theorem   Hamming, Richard W esley , [2]  Hanson, Christopher P ., [2]  Hardy , Godfrey Harold , [2]  has-value? , [2]  Hassle   Havender , J.  Haynes, Christopher T .  headed list , [2]  Hearn, Anthony C.   Henderson, Peter , [2], [3]      Henderson diagram   Heraclitus   Heron of Alexandria   Hewitt, Carl Eddie , [2], [3], [4]  hiding principle   hierarchical data structures , [2]  hierarchy of types       in symbolic algebra       inadequacy of   hig


key: chroma:document
string_value:
h-level language, machine language vs.   higher -order procedures       in metacircular evaluator       procedure as ar gument      procedure as general method       procedure as returned value       strong typing and   Hilfinger , Paul   Hoare, Charles Antony Richard   Hodges, Andrew   Hofstadter , Douglas R.   Horner , W. G.  Horner's rule   “how to” vs. “what is” description, see imperative vs. declarative knowledge   Huffman code       optimality of       order of growth of encoding   Huffman, David   Hughes, R. J. M.   IBM 704   identity   if (special form)       cond  vs.      evaluation of       normal-order evaluation of       one-armed (without alternative)       predicate, consequent, and alternative of       why a special form   if-alternative   if-consequent   if-predicate   if?  imag-part        data-directed       polar representation       rectangular representation       with tagged data   imag-part-polar  imag-part-rectangular   imperative programming   imperative vs. declarative knowledge , 


key: chroma:document
string_value:
[2]      logic programming and , [2]      nondeterministic computing and   imperative vs. expression-oriented programming style   implementation dependencies, see also  unspecified values       numbers       order of subexpression evaluation   inc  incremental development of programs   indeterminate of a polynomial   indexing a data base , [2]  inference, method of   infinite series   infinite stream(s)       merging, [2], [3], [4]      merging as a relation       of factorials       of Fibonacci numbers, see fibs        of integers, see integers        of pairs       of prime numbers, see primes        of random numbers       representing power series       to model signals       to sum a series   infix notation, prefix notation vs.   inform-about-no-value   inform-about-value   information retrieval, see data base   Ingerman, Peter   initialize-stack  operation in register machine , [2]  insert!        in one-dimensional table       in two-dimensional table   insert-queue! , [2] install-complex-package   in


key: chroma:document
string_value:
stall-polar-package   install-polynomial-package   install-rational-package   install-rectangular-package   install-scheme-number-package   instantiate   instantiate a pattern   instruction counting   instruction execution procedure   instruction sequence , [2]  instruction tracing   instruction-execution-proc   instruction-text   integer(s)       dividing       exact   integerizing factor   integers  (infinite stream)       implicit definition       lazy-list version   integers-starting-from   integral, see also  definite integral; Monte Carlo integration       of a power series   integral , [2], [3]      with delayed ar gument       with lambda       lazy-list version       need for delayed evaluation   integrate-series   integrated-circuit implementation of Scheme , [2]  integrator , for signals   interleave   interleave-delayed   Interlisp   internal definition       in environment model      free variable in       let vs.      in nondeterministic evaluator       position of       restrictions on       sc


key: chroma:document
string_value:
anning out       scope of name   Internet “W orm”   interning symbols   interpreter , see also  evaluator       compiler vs. , [2]      read-eval-print loop   intersection-set       binary-tree representation       ordered-list representation       unordered-list representation   interval arithmetic   invariant quantity of an iterative process   inverter       inverter   iteration contructs, see looping constructs   iterative improvement   iterative process       as a stream process       design of algorithm       implemented by procedure call , [2], [3], see also  tail recursion       linear , [2]      recursive process vs. , [2], [3], [4]      register machine for   Jayaraman, Sundaresan   Kaldewaij, Anne   Karr, Alphonse   Kepler , Johannes  key  key of a record       in a data base       in a table       testing equality of   Khayyam, Omar   Knuth, Donald E. , [2], [3], [4], [5], [6], [7]  Kohlbecker , Eugene Edmund, Jr .  Kolmogorov , A. N.   Konopasek, Milos   Kowalski, Robert   KRC , [2]   label  (in r


key: chroma:document
string_value:
egister machine)       simulating   label-exp   label-exp-label   Lagrange interpolation formula   λ calculus (lambda calculus)   lambda  (special form)       define  vs.      with dotted-tail notation   lambda  expression       as operator of combination       value of   lambda-body   lambda-parameters   lambda?   Lambert, J.H.   Lamé, Gabriel   Lamé's Theorem   Lamport, Leslie   Lampson, Butler   Landin, Peter , [2]  language, see natural language; programming language   Lapalme, Guy  last-exp?   last-operand?   last-pair , [2]      rules   lazy evaluation   lazy evaluator   lazy list   lazy pair   lazy tree   leaf?   least commitment, principle of   lecture, something to do during   left-branch , [2]  Leibniz, Baron Gottfried W ilhelm von       proof of Fermat's Little Theorem       series for π , [2]  Leiserson, Charles E. , [2]  length       as accumulation       iterative version       recursive version   let (special form)       evaluation model       internal definition vs.       named       scope of 


key: chroma:document
string_value:
variables       as syntactic sugar , [2]  let*  (special form)   letrec  (special form)   lexical addressing       lexical address   lexical scoping       environment structure and   lexical-address-lookup , [2]  lexical-address-set! , [2] Lieberman, Henry   LIFO buf fer, see stack  line segment       represented as pair of points       represented as pair of vectors   linear growth , [2]  linear iterative process       order of growth   linear recursive process       order of growth   linkage descriptor   Liskov , Barbara Huberman   Lisp       acronym for LISt Processing       applicative-order evaluation in       on DEC PDP-1     efficiency of , [2]      first-class procedures in       Fortran vs.       history of       internal type system       original implementation on IBM 704       Pascal vs.       suitability for writing evaluators       unique features of   Lisp dialects       Common Lisp       Franz Lisp       Interlisp       MacLisp       MDL       Portable Standard Lisp       Scheme       Zetalisp


key: chroma:document
string_value:
   lisp-value  (query interpreter)   lisp-value  (query language) , [2]      evaluation of , [2], [3]  list  (primitive procedure)   list structure      list vs.       mutable       represented using vectors   list(s)       backquote with       cdring down       combining with append       cons ing up       converting a binary tree to a       converting to a binary tree       empty , see empty list       equality of       headed , [2]      last pair of       lazy      length of       list structure vs.       manipulation with car, cdr, and cons       mapping over       nth element of       operations on       printed representation of       quotation of       reversing       techniques for manipulating   list->tree   list-difference   list-of-arg-values   list-of-delayed-args   list-of-values   list-ref , [2]  list-structured memory   list-union   lives-near  (rule) , [2]  local evolution of a process   local name , [2]  local state      maintained in frames   local state variable   local variable   location 


key: chroma:document
string_value:
  Locke, John   log (primitive procedure)   logarithm, approximating ln 2  logarithmic growth , [2], [3]  logic programming , see also  query language; query interpreter       computers for       history of , [2]      in Japan       logic programming languages       mathematical logic vs.   logic puzzles   logical and   logical or   logical-not   lookup        in one-dimensional table       in set of records       in two-dimensional table   lookup-label   lookup-prim   lookup-variable-value , [2]      for scanned-out definitions   looping constructs , [2]      implementing in metacircular evaluator   lower-bound   machine language       high-level language vs.   Macintosh   MacLisp   macro , see also  reader macro character   magician, see numerical analyst  magnitude        data-directed       polar representation       rectangular representation       with tagged data   magnitude-polar   magnitude-rectangular   make-account       in environment model       with serialization , [2], [3]  make-account-and-ser


key: chroma:document
string_value:
ializer   make-accumulator   make-agenda , [2]  make-assign   make-begin   make-branch   make-center-percent   make-center-width   make-code-tree   make-compiled-procedure   make-complex-from-mag-ang   make-complex-from-real-imag   make-connector   make-cycle   make-decrementer   make-execution-procedure   make-frame , [2], [3]  make-from-mag-ang , [2]      message-passing       polar representation       rectangular representation   make-from-mag-ang-polar   make-from-mag-ang-rectangular   make-from-real-imag , [2]      message-passing       polar representation       rectangular representation  make-from-real-imag-polar   make-from-real-imag-rectangular   make-goto   make-if   make-instruction   make-instruction-sequence   make-interval , [2]  make-joint   make-label   make-label-entry   make-lambda   make-leaf   make-leaf-set   make-machine , [2]  make-monitored   make-mutex   make-new-machine   make-operation-exp   make-perform   make-point   make-poly   make-polynomial   make-primitive-exp   make-procedu


key: chroma:document
string_value:
re   make-product , [2]  make-queue , [2]  make-rat , [2], [3]      axiom for       reducing to lowest terms   make-rational   make-register   make-restore   make-save   make-scheme-number   make-segment , [2]  make-serializer   make-simplified-withdraw , [2] make-stack       with monitored stack   make-sum , [2]  make-table        message-passing implementation       one-dimensional table   make-tableau   make-term , [2]  make-test   make-time-segment   make-tree   make-vect   make-wire , [2], [3]  make-withdraw       in environment model       using let  making change, see counting change   map, [2]      as accumulation       with multiple ar guments   map-over-symbols   map-successive-pairs   mapping       over lists       nested , [2]      as a transducer       over trees   mark-sweep garbage collector   mathematical function, see function (mathematical)   mathematics       computer science vs. , [2]      engineering vs.   matrix, represented as sequence   matrix-*-matrix   matrix-*-vector   max (primitiv


key: chroma:document
string_value:
e procedure)   McAllester , David Allen , [2] McCarthy , John , [2], [3], [4]  McDermott, Drew   MDL   means of abstraction       define   means of combination , see also  closure   measure in a Euclidean ring   member   memo-fib   memo-proc   memoization , [2]      call-by-need and       by delay       garbage collection and       of thunks   memoize   memory       in 1964       list-structured   memq   merge   merge-weighted   merging infinite streams, see infinite stream(s)   message passing , [2]      environment model and       in bank account       in digital-circuit simulation       tail recursion and   metacircular evaluator   metacircular evaluator for Scheme       analyzing version       combinations (procedure applications)       compilation of , [2]      data abstraction in , [2], [3], [4]      data-directed eval       derived expressions       driver loop      efficiency of       environment model of evaluation in       environment operations       eval  and apply       eval -apply  cycle , [2]  


key: chroma:document
string_value:
    expression representation , [2]      global environment       higher -order procedures in       implemented language vs. implementation language       job of       order of operand evaluation       primitive procedures       representation of environments       representation of procedures       representation of true and false       running       special forms (additional) , [2], [3], [4], [5], [6]      special forms as derived expressions       symbolic dif ferentiation and       syntax of evaluated language , [2], [3]      tail recursiveness unspecified in       true  and false   metalinguistic abstraction   MicroPlanner   Microshaft   midpoint-segment   Miller , Gary L.   Miller , James S.   Miller -Rabin test for primality   Milner , Robin   min (primitive procedure)   Minsky , Marvin Lee , [2]  Miranda   MIT      Artificial Intelligence Laboratory       early history of       Project MAC      Research Laboratory of Electronics , [2]  MIT Scheme       the empty stream       eval       internal defini


key: chroma:document
string_value:
tions       numbers       random       user-initial-environment       without-interrupts   ML  mobile   modeling       as a design strategy       in science and engineering   models of evaluation   modified registers, see instruction sequence   modifies-register?   modularity , [2]      along object boundaries       functional programs vs. objects       hiding principle       streams and       through dispatching on type       through infinite streams       through modeling with objects   modulo n  modus ponens   money , changing, see counting change   monitored procedure   Monte Carlo integration       stream formulation   Monte Carlo simulation       stream formulation   monte-carlo       infinite stream   Moon, David A. , [2]  morning star , see evening star  Morris, J. H.   Morse code   Mouse, Minnie and Mickey   mul (generic)       used for polynomial coef ficients   mul-complex   mul-interval       more ef ficient version   mul-poly   mul-rat   mul-series   mul-streams   mul-terms   Multics time-sharing


