![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ch12.r CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / lisp / lisplib / manual|
Return to ch12.r CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / lisp / lisplib / manual |
1.1 root 1:
2:
3:
4:
5:
6:
7:
8: CHAPTER 12
9:
10:
11: Liszt - the lisp compiler
12:
13:
14:
15:
16:
17:
18: 12.1. General strategy of the compiler
19:
20: The purpose of the lisp compiler, Liszt, is to
21: create an object module which when brought into the
22: lisp system using _f_a_s_l will have the same effect as
23: bringing in the corresponding lisp coded source module
24: with _l_o_a_d with one important exception, functions will
25: be defined as sequences of machine language instruc-
26: tions, instead of lisp S-expressions. Liszt is not a
27: function compiler, it is a _f_i_l_e compiler. Such a file
28: can contain more than function definitions; it can
29: contain other lisp S-expressions which are evaluated
30: at load time. These other S-expressions will also be
31: stored in the object module produced by Liszt and will
32: be evaluated at fasl time.
33:
34: As is almost universally true of Lisp compilers,
35: the main pass of Liszt is written in Lisp. A subse-
36: quent pass is the assembler, for which we use the
37: standard UNIX assembler.
38:
39:
40:
41: 12.2. Running the compiler
42:
43: The compiler is normally run in this manner:
44: % liszt foo
45: will compile the file foo.l or foo (the preferred way
46: to indicate a lisp source file is to end the file name
47: with `.l'). The result of the compilation will be
48: placed in the file foo.o if no fatal errors were
49: detected. All messages which Liszt generates go to
50: the standard output. Normally each function name is
51: printed before it is compiled (the -q option
52: suppresses this).
53:
54:
55:
56: 12.3. Special forms
57:
58: Liszt makes one pass over the source file. It
59: processes each form in this way:
60: 9
61:
62: 9Liszt - the lisp compiler 12-1
63:
64:
65:
66:
67:
68:
69:
70: Liszt - the lisp compiler 12-2
71:
72:
73: 12.3.1. macro expansion
74:
75: If the form is a macro invocation (i.e it is a
76: list whose car is a symbol whose function binding
77: is a macro), then that macro invocation is
78: expanded. This is repeated until the top level
79: form is not a macro invocation. When Liszt begins,
80: there are already some macros defined, in fact some
81: functions (such as defun) are actually macros. The
82: user may define his own macros as well. For a
83: macro to be used it must be defined in the Lisp
84: system in which Liszt runs.
85:
86:
87:
88: 12.3.2. classification
89:
90: After all macro expansion is done, the form is
91: classified according to its _c_a_r (if the form is not
92: a list, then it is classified as an _o_t_h_e_r).
93:
94:
95:
96: 12.3.2.1. eval-when
97:
98: The form of eval-when is (_e_v_a_l-
99: _w_h_e_n (_t_i_m_e_1 _t_i_m_e_2 ...) _f_o_r_m_1 _f_o_r_m_2 ...) where
100: the time_i are one of _e_v_a_l, _c_o_m_p_i_l_e, or _l_o_a_d.
101: The compiler examines the form_i in sequence and
102: the action taken depends on what is in the time
103: list. If _c_o_m_p_i_l_e is in the list then the com-
104: piler will invoke _e_v_a_l on each form_i as it exam-
105: ines it. If _l_o_a_d is in the list then the com-
106: pile will recursively call itself to compile
107: each form_i as it examines it. Note that if _c_o_m_-
108: _p_i_l_e and _l_o_a_d are in the time list, then the
109: compiler will both evaluate and compile each
110: form. This is useful if you need a function to
111: be defined in the compiler at both compile time
112: (perhaps to aid macro expansion) and at run time
113: (after the file is _f_a_s_led in).
114:
115:
116:
117: 12.3.2.2. declare
118:
119: Declare is used to provide information
120: about functions and variables to the compiler.
121: It is (almost) equivalent to (_e_v_a_l-
122: _w_h_e_n (_c_o_m_p_i_l_e) ...). You may declare functions
123: to be one of three types: lambda (*expr),
124: nlambda (*fexpr), lexpr (*lexpr). The names in
125: parenthesis are the Maclisp names and are
126:
127:
128: Printed: August 5, 1983
129:
130:
131:
132:
133:
134:
135:
136: Liszt - the lisp compiler 12-3
137:
138:
139: accepted by the compiler as well (and not just
140: when the compiler is in Maclisp mode). Func-
141: tions are assumed to be lambdas until they are
142: declared otherwise or are defined differently.
143: The compiler treats calls to lambdas and lexprs
144: equivalently, so you needn't worry about declar-
145: ing lexprs either. It is important to declare
146: nlambdas or define them before calling them.
147: Another attribute you can declare for a function
148: is localf which makes the function `local'. A
149: local function's name is known only to the func-
150: tions defined within the file itself. The
151: advantage of a local function is that is can be
152: entered and exited very quickly and it can have
153: the same name as a function in another file and
154: there will be no name conflict.
155:
156: Variables may be declared special or unspe-
157: cial. When a special variable is lambda bound
158: (either in a lambda, prog or do expression), its
159: old value is stored away on a stack for the
160: duration of the lambda, prog or do expression.
161: This takes time and is often not necessary.
162: Therefore the default classification for vari-
163: ables is unspecial. Space for unspecial vari-
164: ables is dynamically allocated on a stack. An
165: unspecial variable can only be accessed from
166: within the function where it is created by its
167: presence in a lambda, prog or do expression
168: variable list. It is possible to declare that
169: all variables are special as will be shown
170: below.
171:
172: You may declare any number of things in
173: each declare statement. A sample declaration is
174: (_d_e_c_l_a_r_e
175: (_l_a_m_b_d_a _f_u_n_c_1 _f_u_n_c_2)
176: (*_f_e_x_p_r _f_u_n_c_3)
177: (*_l_e_x_p_r _f_u_n_c_4)
178: (_l_o_c_a_l_f _f_u_n_c_5)
179: (_s_p_e_c_i_a_l _v_a_r_1 _v_a_r_2 _v_a_r_3)
180: (_u_n_s_p_e_c_i_a_l _v_a_r_4))
181:
182: You may also declare all variables to be
183: special with (_d_e_c_l_a_r_e (_s_p_e_c_i_a_l_s _t)). You may
184: declare that macro definitions should be com-
185: piled as well as evaluated at compile time by
186: (_d_e_c_l_a_r_e (_m_a_c_r_o_s _t)). In fact, as was mentioned
187: above, declare is much like (_e_v_a_l-
188: _w_h_e_n (_c_o_m_p_i_l_e) ...). Thus if the compiler sees
189: (_d_e_c_l_a_r_e (_f_o_o _b_a_r)) and foo is defined, then it
190: will evaluate (_f_o_o _b_a_r). If foo is not defined
191: then an undefined declare attribute warning will
192:
193:
194: Printed: August 5, 1983
195:
196:
197:
198:
199:
200:
201:
202: Liszt - the lisp compiler 12-4
203:
204:
205: be issued.
206:
207:
208:
209: 12.3.2.3. (progn 'compile form1 form2 ... formn)
210:
211: When the compiler sees this it simply com-
212: piles form1 through formn as if they too were
213: seen at top level. One use for this is to allow
214: a macro at top-level to expand into more than
215: one function definition for the compiler to com-
216: pile.
217:
218:
219:
220: 12.3.2.4. include/includef
221:
222: _I_n_c_l_u_d_e and _i_n_c_l_u_d_e_f cause another file to
223: be read and compiled by the compiler. The
224: result is the same as if the included file were
225: textually inserted into the original file. The
226: only difference between _i_n_c_l_u_d_e and _i_n_c_l_u_d_e_f is
227: that include doesn't evaluate its argument and
228: includef does. Nested includes are allowed.
229:
230:
231:
232: 12.3.2.5. def
233:
234: A def form is used to define a function.
235: The macros _d_e_f_u_n and _d_e_f_m_a_c_r_o expand to a def
236: form. If the function being defined is a
237: lambda, nlambda or lexpr then the compiler con-
238: verts the lisp definition to a sequence of
239: machine language instructions. If the function
240: being defined is a macro, then the compiler will
241: evaluate the definition, thus defining the macro
242: withing the running Lisp compiler. Furthermore,
243: if the variable _m_a_c_r_o_s is set to a non nil
244: value, then the macro definition will also be
245: translated to machine language and thus will be
246: defined when the object file is fasled in. The
247: variable _m_a_c_r_o_s is set to t by
248: (_d_e_c_l_a_r_e (_m_a_c_r_o_s _t)).
249:
250: When a function or macro definition is com-
251: piled, macro expansion is done whenever possi-
252: ble. If the compiler can determine that a form
253: would be evaluated if this function were inter-
254: preted then it will macro expand it. It will
255: not macro expand arguments to a nlambda unless
256: the characteristics of the nlambda is known (as
257: is the case with _c_o_n_d). The map functions (
258:
259:
260: Printed: August 5, 1983
261:
262:
263:
264:
265:
266:
267:
268: Liszt - the lisp compiler 12-5
269:
270:
271: _m_a_p, _m_a_p_c, _m_a_p_c_a_r, and so on) are expanded to a
272: _d_o statement. This allows the first argument to
273: the map function to be a lambda expression which
274: references local variables of the function being
275: defined.
276:
277:
278:
279: 12.3.2.6. other forms
280:
281: All other forms are simply stored in the
282: object file and are evaluated when the file is
283: _f_a_s_led in.
284:
285:
286:
287: 12.4. Using the compiler
288:
289: The previous section describes exactly what the
290: compiler does with its input. Generally you won't
291: have to worry about all that detail as files which
292: work interpreted will work compiled. Following is a
293: list of steps you should follow to insure that a file
294: will compile correctly.
295:
296: [1] Make sure all macro definitions precede their use
297: in functions or other macro definitions. If you
298: want the macros to be around when you _f_a_s_l in the
299: object file you should include this statement at
300: the beginning of the file: (_d_e_c_l_a_r_e (_m_a_c_r_o_s _t))
301:
302: [2] Make sure all nlambdas are defined or declared
303: before they are used. If the compiler comes
304: across a call to a function which has not been
305: defined in the current file, which does not
306: currently have a function binding, and whose type
307: has not been declared then it will assume that
308: the function needs its arguments evaluated (i.e.
309: it is a lambda or lexpr) and will generate code
310: accordingly. This means that you do not have to
311: declare nlambda functions like _s_t_a_t_u_s since they
312: have an nlambda function binding.
313:
314: [3] Locate all variables which are used for communi-
315: cating values between functions. These variables
316: must be declared special at the beginning of a
317: file. In most cases there won't be many special
318: declarations but if you fail to declare a vari-
319: able special that should be, the compiled code
320: could fail in mysterious ways. Let's look at a
321: common problem, assume that a file contains just
322: these three lines:
323: 9
324:
325: 9 Printed: August 5, 1983
326:
327:
328:
329:
330:
331:
332:
333: Liszt - the lisp compiler 12-6
334:
335:
336: (_d_e_f _a_a_a (_l_a_m_b_d_a (_g_l_o_b _l_o_c) (_b_b_b _l_o_c)))
337: (_d_e_f _b_b_b (_l_a_m_b_d_a (_m_y_l_o_c) (_a_d_d _g_l_o_b _m_y_l_o_c)))
338: (_d_e_f _c_c_c (_l_a_m_b_d_a (_g_l_o_b _l_o_c) (_b_b_b _l_o_c)))
339:
340:
341: We can see that if we load in these two defini-
342: tions then (aaa 3 4) is the same as (add 3 4) and
343: will give us 7. Suppose we compile the file con-
344: taining these definitions. When Liszt compiles
345: aaa, it will assume that both glob and loc are
346: local variables and will allocate space on the
347: temporary stack for their values when aaa is
348: called. Thus the values of the local variables
349: glob and loc will not affect the values of the
350: symbols glob and loc in the Lisp system. Now
351: Liszt moves on to function bbb. Myloc is assumed
352: to be local. When it sees the add statement, it
353: find a reference to a variable called glob. This
354: variable is not a local variable to this function
355: and therefore glob must refer to the value of the
356: symbol glob. Liszt will automatically declare
357: glob to be special and it will print a warning to
358: that effect. Thus subsequent uses of glob will
359: always refer to the symbol glob. Next Liszt com-
360: piles ccc and treats glob as a special and loc as
361: a local. When the object file is _f_a_s_l'ed in, and
362: (ccc 3 4) is evaluated, the symbol glob will be
363: lambda bound to 3 bbb will be called and will
364: return 7. However (aaa 3 4) will fail since when
365: bbb is called, glob will be unbound. What should
366: be done here is to put (_d_e_c_l_a_r_e (_s_p_e_c_i_a_l _g_l_o_b) at
367: the beginning of the file.
368:
369: [4] Make sure that all calls to _a_r_g are within the
370: lexpr whose arguments they reference. If _f_o_o is
371: a compiled lexpr and it calls _b_a_r then _b_a_r cannot
372: use _a_r_g to get at _f_o_o's arguments. If both _f_o_o
373: and _b_a_r are interpreted this will work however.
374: The macro _l_i_s_t_i_f_y can be used to put all of some
375: of a lexprs arguments in a list which then can be
376: passed to other functions.
377:
378:
379:
380: 12.5. Compiler options
381:
382: The compiler recognizes a number of options which
383: are described below. The options are typed anywhere
384: on the command line preceded by a minus sign. The
385: entire command line is scanned and all options
386: recorded before any action is taken. Thus
387: % liszt -mx foo
388: % liszt -m -x foo
389:
390:
391: Printed: August 5, 1983
392:
393:
394:
395:
396:
397:
398:
399: Liszt - the lisp compiler 12-7
400:
401:
402: % liszt foo -mx
403: are all equivalent. Before scanning the command line
404: for options, liszt looks for in the environment for
405: the variable LISZT, and if found scans its value as if
406: it was a string of options. The meaning of the
407: options are:
408:
409: C The assembler language output of the compiler is
410: commented. This is useful when debugging the
411: compiler and is not normally done since it slows
412: down compilation.
413:
414: I The next command line argument is taken as a
415: filename, and loaded prior to compilation.
416:
417: e Evaluate the next argument on the command line
418: before starting compilation. For example
419: % liszt -e '(setq foobar "foo string")' foo
420: will evaluate the above s-expression. Note that
421: the shell requires that the arguments be sur-
422: rounded by single quotes.
423:
424: i Compile this program in interlisp compatibility
425: mode. This is not implemented yet.
426:
427: m Compile this program in Maclisp mode. The reader
428: syntax will be changed to the Maclisp syntax and
429: a file of macro definitions will be loaded in
430: (usually named /usr/lib/lisp/machacks). This
431: switch brings us sufficiently close to Maclisp to
432: allow us to compile Macsyma, a large Maclisp pro-
433: gram. However Maclisp is a moving target and we
434: can't guarantee that this switch will allow you
435: to compile any given program.
436:
437: o Select a different object or assembler language
438: file name. For example
439: % liszt foo -o xxx.o
440: will compile foo and into xxx.o instead of the
441: default foo.o, and
442: % liszt bar -S -o xxx.s
443: will compile to assembler language into xxx.s
444: instead of bar.s.
445:
446: p place profiling code at the beginning of each
447: non-local function. If the lisp system is also
448: created with profiling in it, this allows func-
449: tion calling frequency to be determined (see
450: _p_r_o_f(_1))
451:
452: q Run in quiet mode. The names of functions being
453: compiled and various "Note"'s are not printed.
454: 9
455:
456: 9 Printed: August 5, 1983
457:
458:
459:
460:
461:
462:
463:
464: Liszt - the lisp compiler 12-8
465:
466:
467: Q print compilation statistics and warn of strange
468: constructs. This is the inverse of the q switch
469: and is the default.
470:
471: r place bootstrap code at the beginning of the
472: object file, which when the object file is exe-
473: cuted will cause a lisp system to be invoked and
474: the object file _f_a_s_led in. This is known as
475: `autorun' and is described below.
476:
477: S Create an assembler language file only.
478: % liszt -S foo
479: will create the file assembler language file
480: foo.s and will not attempt to assemble it. If
481: this option is not specified, the assembler
482: language file will be put in the temporary disk
483: area under a automatically generated name based
484: on the lisp compiler's process id. Then if there
485: are no compilation errors, the assembler will be
486: invoked to assemble the file.
487:
488: T Print the assembler language output on the stan-
489: dard output file. This is useful when debugging
490: the compiler.
491:
492: u Run in UCI-Lisp mode. The character syntax is
493: changed to that of UCI-Lisp and a UCI-Lisp compa-
494: tibility package of macros is read in.
495:
496: w Suppress warning messages.
497:
498: x Create an cross reference file.
499: % liszt -x foo
500: not only compiles foo into foo.o but also gen-
501: erates the file foo.x . The file foo.x is lisp
502: readable and lists for each function all func-
503: tions which that function could call. The pro-
504: gram lxref reads one or more of these ".x" files
505: and produces a human readable cross reference
506: listing.
507:
508:
509:
510: 12.6. autorun
511:
512: The object file which liszt writes does not con-
513: tain all the functions necessary to run the lisp pro-
514: gram which was compiled. In order to use the object
515: file, a lisp system must be started and the object
516: file _f_a_s_led in. When the -r switch is given to liszt,
517: the object file created will contain a small piece of
518: bootstrap code at the beginning, and the object file
519: will be made executable. Now, when the name of the
520:
521:
522: Printed: August 5, 1983
523:
524:
525:
526:
527:
528:
529:
530: Liszt - the lisp compiler 12-9
531:
532:
533: object file is given to the UNIX command interpreter
534: (shell) to run, the bootstrap code at the beginning of
535: the object file will cause a lisp system to be started
536: and the first action the lisp system will take is to
537: _f_a_s_l in the object file which started it. In effect
538: the object file has created an environment in which it
539: can run.
540:
541: Autorun is an alternative to _d_u_m_p_l_i_s_p. The
542: advantage of autorun is that the object file which
543: starts the whole process is typically small, whereas
544: the minimum _d_u_m_p_l_i_s_ped file is very large (one half
545: megabyte). The disadvantage of autorun is that the
546: file must be _f_a_s_led into a lisp each time it is used
547: whereas the file which _d_u_m_p_l_i_s_p creates can be run as
548: is. liszt itself is a _d_u_m_p_l_i_s_ped file since it is
549: used so often and is large enough that too much time
550: would be wasted _f_a_s_ling it in each time it was used.
551: The lisp cross reference program, lxref, uses _a_u_t_o_r_u_n
552: since it is a small and rarely used program.
553:
554: In order to have the program _f_a_s_led in begin exe-
555: cution (rather than starting a lisp top level), the
556: value of the symbol user-top-level should be set to
557: the name of the function to get control. An example
558: of this is shown next.
559:
560:
561:
562:
563:
564:
565:
566:
567:
568:
569:
570:
571:
572:
573:
574:
575:
576:
577:
578:
579:
580:
581:
582:
583:
584:
585: 9
586:
587: 9 Printed: August 5, 1983
588:
589:
590:
591:
592:
593:
594:
595: Liszt - the lisp compiler 12-10
596:
597:
598:
599: ____________________________________________________
600:
601: _w_e _w_a_n_t _t_o _r_e_p_l_a_c_e _t_h_e _u_n_i_x _d_a_t_e _p_r_o_g_r_a_m _w_i_t_h _o_n_e _w_r_i_t_t_e_n _i_n _l_i_s_p.
602:
603: % cat lispdate.l
604: (defun mydate nil
605: (patom "The date is ")
606: (patom (status ctime))
607: (terpr)
608: (exit 0))
609: (setq user-top-level 'mydate)
610:
611: % liszt -r lispdate
612: Compilation begins with Lisp Compiler 5.2
613: source: lispdate.l, result: lispdate.o
614: mydate
615: %Note: lispdate.l: Compilation complete
616: %Note: lispdate.l: Time: Real: 0:3, CPU: 0:0.28, GC: 0:0.00 for 0 gcs
617: %Note: lispdate.l: Assembly begins
618: %Note: lispdate.l: Assembly completed successfully
619: 3.0u 2.0s 0:17 29%
620:
621: _W_e _c_h_a_n_g_e _t_h_e _n_a_m_e _t_o _r_e_m_o_v_e _t_h_e "._o", (_t_h_i_s _i_s_n'_t _n_e_c_e_s_s_a_r_y)
622: % mv lispdate.o lispdate
623:
624: _N_o_w _w_e _t_e_s_t _i_t _o_u_t
625: % lispdate
626: The date is Sat Aug 1 16:58:33 1981
627: %
628: ____________________________________________________
629:
630:
631:
632:
633:
634:
635: 12.7. pure literals
636:
637: Normally the quoted lisp objects (literals) which
638: appear in functions are treated as constants. Consider
639: this function:
640:
641: (_d_e_f _f_o_o
642: (_l_a_m_b_d_a _n_i_l (_c_o_n_d ((_n_o_t (_e_q '_a (_c_a_r (_s_e_t_q _x '(_a
643: _b)))))
644: (_p_r_i_n_t '_i_m_p_o_s_s_i_b_l_e!!))
645: (_t (_r_p_l_a_c_a _x '_d)))))
646:
647: At first glance it seems that the first cond clause
648: will never be true, since the _c_a_r of (_a _b) should
649: always be _a. However if you run this function twice,
650: it will print 'impossible!!' the second time. This is
651:
652:
653: Printed: August 5, 1983
654:
655:
656:
657:
658:
659:
660:
661: Liszt - the lisp compiler 12-11
662:
663:
664: because the following clause modifies the 'constant'
665: list (_a _b) with the _r_p_l_a_c_a function. Such modifica-
666: tion of literal lisp objects can cause programs to
667: behave strangely as the above example shows, but more
668: importantly it can cause garbage collection problems
669: if done to compiled code. When a file is _f_a_s_led in,
670: if the symbol $purcopylits is non nil, the literal
671: lisp data is put in 'pure' space, that is it put in
672: space which needn't be looked at by the garabage col-
673: lector. This reduces the work the garbage collector
674: must do but it is dangerous since if the literals are
675: modified to point to non pure objects, the marker may
676: not mark the non pure objects. If the symbol $pur-
677: copylits is nil then the literal lisp data is put in
678: impure space and the compiled code will act like the
679: interpreted code when literal data is modified. The
680: default value for $purcopylits is t.
681:
682:
683:
684: 12.8. transfer tables
685:
686: A transfer table is setup by _f_a_s_l when the object
687: file is loaded in. There is one entry in the transfer
688: table for each function which is called in that object
689: file. The entry for a call to the function _f_o_o has
690: two parts whose contents are:
691:
692: [1] function address - This will initially point to
693: the internal function _q_l_i_n_k_e_r. It may some time
694: in the future point to the function _f_o_o if cer-
695: tain conditions are satisfied (more on this
696: below).
697:
698: [2] function name - This is a pointer to the symbol
699: _f_o_o. This will be used by _q_l_i_n_k_e_r.
700:
701:
702:
703: When a call is made to the function _f_o_o the call will
704: actually be made to the address in the transfer table
705: entry and will end up in the _q_l_i_n_k_e_r function.
706: _Q_l_i_n_k_e_r will determine that _f_o_o was the function being
707: called by locating the function name entry in the
708: transfer table[]. If the function being called is not
709: compiled then _q_l_i_n_k_e_r just calls _f_u_n_c_a_l_l to perform
710: ____________________
711: 9 []_Q_l_i_n_k_e_r does this by tracing back the call stack until
712: it finds the _c_a_l_l_s machine instruction which called it. The
713: address field of the _c_a_l_l_s contains the address of the
714: transfer table entry.
715:
716:
717:
718: 9 Printed: August 5, 1983
719:
720:
721:
722:
723:
724:
725:
726: Liszt - the lisp compiler 12-12
727:
728:
729: the function call. If _f_o_o is compiled and if
730: (_s_t_a_t_u_s _t_r_a_n_s_l_i_n_k) is non nil, then _q_l_i_n_k_e_r will
731: modify the function address part of the transfer table
732: to point directly to the function _f_o_o. Finally
733: _q_l_i_n_k_e_r will call _f_o_o directly . The next time a call
734: is made to _f_o_o the call will go directly to _f_o_o and
735: not through _q_l_i_n_k_e_r. This will result in a substan-
736: tial speedup in compiled code to compiled code
737: transfers. A disadvantage is that no debugging infor-
738: mation is left on the stack, so _s_h_o_w_s_t_a_c_k and _b_a_k_t_r_a_c_e
739: are useless. Another disadvantage is that if you
740: redefine a compiled function either through loading in
741: a new version or interactively defining it, then the
742: old version may still be called from compiled code if
743: the fast linking described above has already been
744: done. The solution to these problems is to use
745: (_s_s_t_a_t_u_s _t_r_a_n_s_l_i_n_k _v_a_l_u_e). If value is
746:
747: _n_i_l All transfer tables will be cleared, i.e. all
748: function addresses will be set to point to
749: _q_l_i_n_k_e_r. This means that the next time a func-
750: tion is called _q_l_i_n_k_e_r will be called and will
751: look at the current definition. Also, no fast
752: links will be set up since (_s_t_a_t_u_s _t_r_a_n_s_l_i_n_k)
753: will be nil. The end result is that _s_h_o_w_s_t_a_c_k
754: and _b_a_k_t_r_a_c_e will work and the function defini-
755: tion at the time of call will always be used.
756:
757: _o_n This causes the lisp system to go through all
758: transfer tables and set up fast links wherever
759: possible. This is normally used after you have
760: _f_a_s_led in all of your files. Furthermore since
761: (_s_t_a_t_u_s _t_r_a_n_s_l_i_n_k) is not nil, _q_l_i_n_k_e_r will make
762: new fast links if the situation arises (which
763: isn't likely unless you _f_a_s_l in another file).
764:
765: _t This or any other value not previously mentioned
766: will just make (_s_t_a_t_u_s _t_r_a_n_s_l_i_n_k) be non nil, and
767: as a result fast links will be made by _q_l_i_n_k_e_r
768: if the called function is compiled.
769:
770:
771:
772: 12.9. Fixnum functions
773:
774: The compiler will generate inline arithmetic code
775: for fixnum only functions. Such functions include +,
776: -, *, /, \, 1+ and 1-. The code generated will be
777: much faster than using _a_d_d, _d_i_f_f_e_r_e_n_c_e, etc. However
778: it will only work if the arguments to and results of
779: the functions are fixnums. No type checking is done.
780:
781: 9
782:
783: 9 Printed: August 5, 1983
784:
785:
786:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.