| blob | 1b3fe820aab01c3933248790927f95c399a60415 |
1 ;;;; This file contains code which does the translation from Lisp code
2 ;;;; to the first intermediate representation (IR1).
4 ;;;; This software is part of the SBCL system. See the README file for
5 ;;;; more information.
6 ;;;;
7 ;;;; This software is derived from the CMU CL system, which was
8 ;;;; written at Carnegie Mellon University and released into the
9 ;;;; public domain. The software is in the public domain and is
10 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
11 ;;;; files for more information.
17 ;;; the lexical environment we are currently converting in
21 ;;; *CURRENT-FORM-NUMBER* is used in FIND-SOURCE-PATHS to compute the
22 ;;; form number to associate with a source path. This should be bound
23 ;;; to an initial value of 0 before the processing of each truly
24 ;;; top level form.
28 ;;; Report as we try each transform? (either source or IR)
29 ;;; Bind to T to see the ones that didn't abort,
30 ;;; :ALL if you want to see each attempted transform.
31 ;;; :DERIVE-TYPE for newly derived types of combinations.
50 (> value
56 ;; Don't hide all the transformed paths, since we might want
57 ;; to look at the final form for error reporting.
59 ;; Avoids notes about inlined code leaking out
72 form
75 ;;; *CURRENT-COMPONENT* is the COMPONENT structure which we link
76 ;;; blocks into as we generate them. This just serves to glue the
77 ;;; emitted blocks together until local call analysis and flow graph
78 ;;; canonicalization figure out what is really going on. We need to
79 ;;; keep track of all the blocks generated so that we can delete them
80 ;;; if they turn out to be unreachable.
81 ;;;
82 ;;; FIXME: It's confusing having one variable named *CURRENT-COMPONENT*
83 ;;; and another named *COMPONENT-BEING-COMPILED*. (In CMU CL they
84 ;;; were called *CURRENT-COMPONENT* and *COMPILE-COMPONENT* respectively,
85 ;;; which was also confusing.)
89 ;;; *CURRENT-PATH* is the source path of the form we are currently
90 ;;; translating. See NODE-SOURCE-PATH in the NODE structure.
103 "Should the compiler assume that function types will never change,
104 so that it can use type information inferred from current definitions
105 to optimize code which uses those definitions? Setting this true
106 gives non-ANSI, early-CMU-CL behavior. It can be useful for improving
108 \f
109 ;;;; namespace management utilities
111 ;;; Unpack (INFO :FUNCTION :INLINING-DATA FUN-NAME). If an explicit expansion
112 ;;; is not stored but FUN-NAME is a structure constructor, reconstitute the
113 ;;; expansion from the defstruct description. Secondary value is T if the expansion
114 ;;; was explicit. See SAVE-INLINE-EXPANSION-P for why we care.
115 ;;; (Essentially, once stored then always stored, lest inconsistency result)
116 ;;; If we have just a DXABLE-ARGS, or nothing at all, return NIL and NIL.
117 ;;; If called on a string or anything that is not a function designator,
118 ;;; return NIL and NIL.
120 fun-name-inline-expansion))
124 ;; an INLINING-DATA is a DXABLE-ARGS, so test it first
139 ;; As with LEXENV-FIND, we assume use of *LEXENV*, but macroexpanders
140 ;; receive an explicit environment and should pass it.
141 ;; A declaration will trump a proclamation.
151 ;; FIXME: this seems to omit FUNCTIONAL
158 do
160 t)))))))
161 ;; If ANSWER is NIL, go for the global value
164 \f
166 ;; needed by ir1-translators
167 find-global-fun))
173 :defined-here
174 where))
176 ;;; Return a GLOBAL-VAR structure usable for referencing the global
177 ;;; function NAME.
185 ;; Slot accessors are defined just-in-time, if not already.
187 ;; In the ordinary target Lisp, it's silly to report
188 ;; undefinedness when the function is defined in the
189 ;; running Lisp. But at cross-compile time, the current
190 ;; definedness of a function is irrelevant to the
191 ;; definedness at runtime, which is what matters.
193 ;; LATEP is true when the user has indicated that
194 ;; late-late binding is desired by using eg. a quoted
195 ;; symbol -- in which case it makes little sense to
196 ;; complain about undefined functions.
204 #-sb-xc-host
212 name)))
217 :%source-name name
222 ftype
225 ftype
228 where
231 ;;; If NAME already has a valid entry in (FREE-FUNS *IR1-NAMESPACE*), then return
232 ;;; the value. Otherwise, make a new GLOBAL-VAR using information from
233 ;;; the global environment and enter it in FREE-FUNS. If NAME
234 ;;; names a macro or special form, then we error out using the
235 ;;; supplied context which indicates what we were trying to do that
236 ;;; demanded a function.
244 kind name context))
253 :%source-name name
254 :inline-expansion expansion
255 :inlinep inlinep
257 where
265 ;;; Return the LEAF structure for the lexically apparent function
266 ;;; definition of NAME.
274 var)
280 ;;; Return the LEAF node for a global variable reference to NAME. If
281 ;;; NAME is already entered in (FREE-VARS *IR1-NAMESPACE*), then we just return the
282 ;;; corresponding value. Otherwise, we make a new leaf using
283 ;;; information from the global environment and enter it in
284 ;;; FREE-VARS.
291 existing)
296 ;; For deprecated vars, warn about LET and LAMBDA bindings, SETQ, and ref.
297 ;; Don't warn again if the name was already seen by the transform
298 ;; of SYMBOL[-GLOBAL]-VALUE.
305 (:alien
307 ;; FIXME: The return value in this case should really be
308 ;; of type SB-C::LEAF. I don't feel too badly about it,
309 ;; because the MACRO idiom is scattered throughout this
310 ;; file, but it should be cleaned up so we're not
311 ;; throwing random conses around. --njf 2002-03-23
312 (:macro
316 (:constant
321 :%source-name name
322 :type type
324 \f
325 ;;; Return T if and only if OBJ's nature as an externalizable thing renders
326 ;;; it a leaf for dumping purposes. Symbols are leaflike despite havings slots
327 ;;; containing pointers; similarly (COMPLEX RATIONAL) and RATIO.
330 ;; (ARRAY NIL) is not included in UNBOXED-ARRAY
332 system-area-pointer
333 #+sb-simd-pack simd-pack
335 ;; STANDARD-OBJECT layouts use MAKE-LOAD-FORM, but all other layouts
336 ;; have the same status as symbols - composite objects but leaflike.
338 ;; PACKAGEs are also leaflike.
340 ;; The cross-compiler wants to dump CTYPE instances as leaves,
341 ;; but CLASSOIDs are excluded since they have a MAKE-LOAD-FORM method.
345 ;;; Grovel over CONSTANT checking for any sub-parts that need to be
346 ;;; processed with MAKE-LOAD-FORM. We have to be careful, because
347 ;;; CONSTANT might be circular. We also check that the constant (and
348 ;;; any subparts) are dumpable at all.
355 #-sb-xc-host
358 ;; FIXME: shouldn't this be something like SB-XC:TYPECASE ?
370 ;; Even though the (ARRAY T) branch does the exact
371 ;; same thing as this branch we do this separately
372 ;; so that the compiler can use faster versions of
373 ;; array-total-size and row-major-aref.
380 ;; Behold the wonderfully clear sense of this-
381 ;; WHEN (EMIT-MAKE-LOAD-FORM VALUE)
382 ;; meaning "when you're _NOT_ using a custom load-form"
383 ;;
384 ;; FIXME: What about funcallable instances with
385 ;; user-defined MAKE-LOAD-FORM methods?
387 #+sb-xc-host
394 "Objects of type ~/sb-impl:print-type-specifier/ can't be dumped into fasl files."
397 \f
398 ;;;; some flow-graph hacking utilities
400 ;; Bind *COMPILER-ERROR-BAILOUT* to a function that throws out of the
401 ;; body and converts a condition signalling form instead. The source
402 ;; form is converted to a string since it may contain arbitrary
403 ;; non-externalizable objects.
411 ,@body
417 ;;; This function sets up the back link between the node and the
418 ;;; ctran which continues at it.
425 ;;; This function is used to set the ctran for a node, and thus
426 ;;; determine what is evaluated next. If the ctran has no block, then
427 ;;; we make it be in the block that the node is in. If the ctran heads
428 ;;; its block, we end our block and link it to that block.
454 ;;; Insert NEW before OLD in the flow-graph.
475 ;;; This function is used to set the ctran for a node, and thus
476 ;;; determine what receives the value.
496 \f
497 ;;;; exported functions
499 ;;; This function takes a form and the top level form number for that
500 ;;; form, and returns a lambda representing the translation of that
501 ;;; form in the current global environment. The returned lambda is a
502 ;;; top level lambda that can be called to cause evaluation of the
503 ;;; forms. This lambda is in the initial component. If FOR-VALUE is T,
504 ;;; then the value of the form is returned from the function,
505 ;;; otherwise NIL is returned.
506 ;;;
507 ;;; This function may have arbitrary effects on the global environment
508 ;;; due to processing of EVAL-WHENs. All syntax error checking is
509 ;;; done, with erroneous forms being replaced by a proxy which signals
510 ;;; an error if it is evaluated. Warnings about possibly inconsistent
511 ;;; or illegal changes to the global environment will also be given.
512 ;;;
513 ;;; We make the initial component and convert the form in a PROGN (and
514 ;;; an optional NIL tacked on the end.) We then return the lambda. We
515 ;;; bind all of our state variables here, rather than relying on the
516 ;;; global value (if any) so that IR1 conversion will be reentrant.
517 ;;; This is necessary for EVAL-WHEN processing, etc.
518 ;;;
519 ;;; The hashtables used to hold global namespace info must be
520 ;;; reallocated elsewhere. Note also that *LEXENV* is not bound, so
521 ;;; that local macro definitions can be introduced by enclosing code.
536 res)))
538 ;;; This function is called on freshly read forms to record the
539 ;;; initial location of each form (and subform.) Form is the form to
540 ;;; find the paths in, and TLF-NUM is the top level form number of the
541 ;;; truly top level form.
542 ;;;
543 ;;; This gets a bit interesting when the source code is circular. This
544 ;;; can (reasonably?) happen in the case of circular list constants.
569 ;; If it's a cons, recurse.
572 ;; Don't look into quoted constants.
573 ;; KLUDGE: this can't actually know about constants.
574 ;; e.g. (let ((quote (error "foo")))) or
575 ;; (list quote (error "foo")) are not
576 ;; constants and yet are ignored.
579 ;; Otherwise store the containing form. It's not
580 ;; perfect, but better than nothing.
592 \f
593 ;;;; IR1-CONVERT, macroexpansion and special form dispatching
596 ir1-convert-combination-args reference-leaf
597 reference-constant
598 expand-compiler-macro
599 maybe-reanalyze-functional
600 ir1-convert-common-functoid))
602 ;;; Translate FORM into IR1. The code is inserted as the NEXT of the
603 ;;; CTRAN START. RESULT is the LVAR which receives the value of the
604 ;;; FORM to be translated. The translators call this function
605 ;;; recursively to translate their subnodes.
606 ;;;
607 ;;; As a special hack to make life easier in the compiler, a LEAF
608 ;;; IR1-converts into a reference to that LEAF structure. This allows
609 ;;; the creation using backquote of forms that contain leaf
610 ;;; references, without having to introduce dummy names into the
611 ;;; namespace.
629 ;;; Generate a reference to a manifest constant, creating a new leaf
630 ;;; if necessary. If we are producing a fasl file, make sure that
631 ;;; MAKE-LOAD-FORM gets used on any parts of the constant that it
632 ;;; needs to be.
633 (defun reference-constant (start next result value &optional (emit-load-forms (producing-fasl-file)))
645 ;;; Add FUNCTIONAL to the COMPONENT-REANALYZE-FUNCTIONALS, unless it's
646 ;;; some trivial type for which reanalysis is a trivial no-op.
647 ;;;
648 ;;; FUNCTIONAL is returned.
652 ;; When FUNCTIONAL is of a type for which reanalysis isn't a trivial
653 ;; no-op
657 functional)
659 ;;; Generate a REF node for LEAF, frobbing the LEAF structure as
660 ;;; needed. If LEAF represents a defined function which has already
661 ;;; been converted in the same compilation block, and is not
662 ;;; NOTINLINE, then reference the functional instead.
676 leaf))
686 (#-sb-xc-host compiler-style-warn
687 #+sb-xc-host warn
702 ;;; Convert a reference to a symbolic constant or variable. If the
703 ;;; symbol is entered in the LEXENV-VARS we use that definition,
704 ;;; otherwise we find the current global definition. This is also
705 ;;; where we pick off symbol macro and alien variable references.
716 ;; (ANSI's specification for the IGNORE declaration requires
717 ;; that this be a STYLE-WARNING, not a full WARNING.)
718 #-sb-xc-host
720 ;; there's no need for us to accept ANSI's lameness when
721 ;; processing our own code, though.
722 #+sb-xc-host
727 ;; FIXME: the following comment is probably wrong now.
728 ;; If we warn here on :early and :late deprecation
729 ;; then we get an extra warning somehow.
730 ;; This case signals {EARLY,LATE,FINAL}-DEPRECATION-WARNING
731 ;; for symbol-macros. Includes variables, constants,
732 ;; etc. in :FINAL deprecation.
735 ;; FIXME: [Free] type declarations. -- APD, 2002-01-26
741 ;;; Find a compiler-macro for a form, taking FUNCALL into account.
754 real-fun)
759 ;; CLHS tells us that local functions must shadow
760 ;; compiler-macro-functions, but since the call is
761 ;; through a name, we are obviously interested
762 ;; in the global function.
763 ;; KLUDGE: CLHS 3.2.2.1.1 also says that it can be
764 ;; "a list whose car is funcall and whose cadr is
765 ;; a list (function name)", that means that
766 ;; (funcall 'name) that gets here doesn't fit the
767 ;; definition.
776 ;;; If FORM has a usable compiler macro, use it; otherwise return FORM itself.
777 ;;; Return the name of the compiler-macro as a secondary value, if applicable.
784 ;; CLHS 3.2.2.1.3 specifies that NOTINLINE
785 ;; suppresses compiler-macros.
792 form))
793 cmacro-fun-name))
797 ;;; Picks off special forms and compiler-macro expansions, and hands
798 ;;; the rest to IR1-CONVERT-COMMON-FUNCTOID
814 ;;; Handles the "common" cases: any other forms except special forms
815 ;;; and compiler-macros.
825 lexical-def))
831 ;; Unlike inline expansion, macroexpansion is not optional,
832 ;; but we clearly can't recurse forever.
845 ;; Treat it as an global function, which is probably
846 ;; what was intended. The expansion thus far could be wrong,
847 ;; but that's not our problem.
852 ;; implicitly (LAMBDA ..) because the LAMBDA expression is
853 ;; the CAR of an executed form.
856 ;;; Convert anything that looks like a global function call.
862 "~@<There is no function named ~S. ~
863 References to ~S in some contexts (like starts of blocks) are unevaluated ~
864 expressions, but here the expression is being evaluated, which invokes ~
866 ;; FIXME: Couldn't all the INFO calls here be converted into
867 ;; standard CL functions, like MACRO-FUNCTION or something? And what
868 ;; happens with lexically-defined (MACROLET) macros here, anyway?
870 (:macro
873 form))
879 form))))
881 ;;; Expand FORM using the macro whose MACRO-FUNCTION is FUN, trapping
882 ;;; errors which occur during the macroexpansion.
885 ;; telling something about which form caused the problem.
891 "~@<~A of ~S. Use ~S to intercept.~%~:@>"
898 form
904 ;; The spec is silent on what we should do. Signaling
905 ;; a full warning but declining to expand seems like
906 ;; a conservative and sane thing to do.
913 \f
914 ;;;; conversion utilities
916 ;;; Convert a bunch of forms, discarding all the values except the
917 ;;; last. If there aren't any forms, then translate a NIL.
939 \f
940 ;;;; converting combinations
942 ;;; Does this form look like something that we should add single-stepping
943 ;;; instrumentation for?
948 ;; KLUDGE: packages we're not interested in
949 ;; stepping.
951 sb-kernel sb-pcl))
952 t)))))
959 ;;; Convert a function call where the function FUN is a LEAF. FORM is
960 ;;; the source for the call. We return the COMBINATION node so that
961 ;;; the caller can poke at it if it wants to.
975 ;; Store a string representation of the form in the
976 ;; combination node. This will let the IR2 translator know
977 ;; that we want stepper instrumentation for this node. The
978 ;; string will be stored in the debug-info by DUMP-1-LOCATION.
984 combination)))
986 ;;; Convert the arguments to a call and make the COMBINATION
987 ;;; node. FUN-LVAR yields the function to call. ARGS is the list of
988 ;;; arguments for the call, which defaults to the cdr of source. We
989 ;;; return the COMBINATION node.
992 arg-source-forms)
1023 node))
1025 ;;; Convert a call to a global function. If not NOTINLINE, then we do
1026 ;;; source transforms and try out any inline expansion. If there is no
1027 ;;; expansion, but is INLINE, then give an efficiency note (unless a
1028 ;;; known function which will quite possibly be open-coded.) Next, we
1029 ;;; go to ok-combination conversion.
1044 ;; Note that "pass" means fail. Gotta love it.
1048 var))
1060 var))))))
1062 ;;; If the function has the PREDICATE attribute, and the RESULT's DEST
1063 ;;; isn't an IF, then we convert (IF <form> T NIL), ensuring that a
1064 ;;; predicate always appears in a conditional context.
1065 ;;;
1066 ;;; If the function isn't a predicate, then we call
1067 ;;; IR1-CONVERT-COMBINATION-CHECKING-TYPE.
1080 ;;; Like (if form t nil) but without coverage and without inserting
1081 ;;; leafs coming from %funcall into *current-path*
1090 :consequent then-block
1107 ;;; Actually really convert a global function call that we are allowed
1108 ;;; to early-bind.
1109 ;;;
1110 ;;; If we know the function type of the function, then we check the
1111 ;;; call for syntactic legality with respect to the declared function
1112 ;;; type. If it is impossible to determine whether the call is correct
1113 ;;; due to non-constant keywords, then we give up, marking the call as
1114 ;;; :FULL to inhibit further error messages. We return true when the
1115 ;;; call is legal.
1116 ;;;
1117 ;;; If the call is legal, we also propagate type assertions from the
1118 ;;; function type to the arg and result lvars. We do this now so that
1119 ;;; IR1 optimize doesn't have to redundantly do the check later so
1120 ;;; that it can do the type propagation.
1134 ;;; Convert a call to a local function, or if the function has already
1135 ;;; been LET converted, then throw FUNCTIONAL to
1136 ;;; LOCALL-ALREADY-LET-CONVERTED. The THROW should only happen when we
1137 ;;; are converting inline expansions for local functions during
1138 ;;; optimization.
1142 form
1144 \f
1145 ;;;; PROCESS-DECLS
1148 find-in-bindings
1149 process-muffle-decls))
1151 ;;; Given a list of LAMBDA-VARs and a variable name, return the
1152 ;;; LAMBDA-VAR for that name, or NIL if it isn't found. We return the
1153 ;;; *last* variable with that name, since LET* bindings may be
1154 ;;; duplicated, and declarations always apply to the last.
1171 found))
1173 ;;; Called by PROCESS-DECLS to deal with a variable type declaration.
1174 ;;; If a LAMBDA-VAR being bound, we intersect the type with the var's
1175 ;;; type, otherwise we add a type restriction on the var. If a symbol
1176 ;;; macro, we just wrap a THE around the expansion.
1206 type
1208 old-type type))))
1212 'type-warning
1213 :format-control
1214 "The type declarations ~
1215 ~/sb-impl:print-type/ and ~
1216 ~/sb-impl:print-type/ for ~
1217 ~S conflict."
1218 :format-arguments
1230 ;; FIXME: non-ANSI weirdness. [See lp#309122]
1236 "~S is an alien variable, so its type can't be declared."
1237 var-name)))))
1243 res))
1244 res)))
1246 ;;; This is somewhat similar to PROCESS-TYPE-DECL, but handles
1247 ;;; declarations for function variables. In addition to allowing
1248 ;;; declarations for functions being bound, we must also deal with
1249 ;;; declarations that constrain the type of lexically apparent
1250 ;;; functions.
1259 type-specifier)
1279 type))))))
1282 res))))
1284 ;;; Process a special declaration, returning a new LEXENV. A non-bound
1285 ;;; special declaration is instantiated by throwing a special variable
1286 ;;; into the variables if POST-BINDING-LEXENV is NIL,
1287 ;;; or by mutating POST-BINDING-LEXENV if non-nil.
1288 ;;; Note that POST-BINDING-LEXENV is not actually a lexenv - it is only
1289 ;;; the contents of the 'vars' slot of a LEXENV, and moreover, as supplied
1290 ;;; to this function, it has a dummy cons in front which is later removed.
1291 ;;; The dummy cons serves a double purpose - as an indicator that this decl
1292 ;;; occurs in a LET/LET* form, and facilitating pass by reference of the list.
1297 ;; While CLHS seems to allow local SPECIAL declarations for constants,
1298 ;; whatever the semantics are supposed to be is not at all clear to me
1299 ;; -- since constants aren't allowed to be bound it should be a no-op as
1300 ;; no-one can observe the difference portably, but specials are allowed
1301 ;; to be bound... yet nowhere does it say that the special declaration
1302 ;; removes the constantness. Call it a spec bug and prohibit it. Same
1303 ;; for GLOBAL variables.
1306 "~S is not a symbol and thus can't be declared special."
1307 name))
1311 "Can't declare ~(~A~) variable locally special: ~S"
1312 kind name)))
1320 "~S is a symbol-macro and thus can't be declared special."
1321 name))
1324 ;; ANSI's definition for "Declaration IGNORE, IGNORABLE"
1325 ;; requires that this be a STYLE-WARNING, not a full WARNING.
1327 "The ignored variable ~S is being declared special."
1328 name))
1337 res)
1341 res))))
1361 ;;; Return a DEFINED-FUN which copies a GLOBAL-VAR but for its INLINEP
1362 ;;; (and TYPE if notinline), plus type-restrictions from the lexenv.
1374 type)
1383 ;; FIXME: Is this really right? Needs we not set the FUNCTIONAL
1384 ;; to the original global-var?
1385 res))
1387 ;;; Parse an inline/notinline declaration. If it's a local function we're
1388 ;;; defining, set its INLINEP. If a global function, add a new FENV entry.
1406 definition of local function:~% ~S"
1407 sense name)))
1412 new-fenv))))))))
1415 res)))
1417 ;;; like FIND-IN-BINDINGS, but looks for #'FOO in the FVARS
1431 ;;; Process an ignore/ignorable declaration, checking for various losing
1432 ;;; conditions.
1439 ;; ANSI's definition for "Declaration IGNORE, IGNORABLE"
1440 ;; requires that this be a STYLE-WARNING, not a full WARNING.
1441 ;; But, other Lisp hosts signal a full warning, so when building
1442 ;; the cross-compiler, compile it as #'WARN so that in a self-hosted
1443 ;; build we can at least crash in the same way,
1444 ;; until we resolve this question about how severe the warning is.
1447 "~A declaration for ~A: ~A"
1456 "a variable from outer scope"
1458 name)
1472 ;; Just ignore the IGNORE decl: we don't currently signal style-warnings
1473 ;; for unused macrolet or symbol-macros, so there's no need to do anything.
1474 )
1480 ;; ANSI's definition for "Declaration IGNORE, IGNORABLE"
1481 ;; requires that this be a STYLE-WARNING, not a full WARNING.
1483 name
1492 "If true (the default), the compiler believes DYNAMIC-EXTENT declarations
1493 and stack allocates otherwise inaccessible parts of the object whenever
1544 ;;; FIXME: This is non-ANSI, so the default should be T, or it should
1545 ;;; go away, I think.
1546 ;;; Or just rename the declaration to SB-C:RESULT-TYPE so that it's not
1547 ;;; a symbol in the CL package, and then eliminate this switch.
1548 ;;; It's permissible to have implementation-specific declarations.
1552 ;;; Process a single declaration spec, augmenting the specified LEXENV
1553 ;;; RES. Return RES and result type. VARS and FVARS are as described
1554 ;;; PROCESS-DECLS.
1560 ;; FIXME: we can end up with a chain of spurious parent lexenvs,
1561 ;; when logically the processing of decls should yield at most
1562 ;; two new lexenvs: one for the bindings and one for post-binding.
1563 ;; It's possible that there's a simple fix of re-linking the resulting
1564 ;; lexenv directly to *lexenv* as its parent.
1571 res)
1592 :default res
1597 :default res
1602 res)
1605 :default res
1610 :default res
1622 lambda-list)))
1623 res)
1626 res)
1629 res)
1630 ;; We may want to detect LAMBDA-LIST and VALUES decls here,
1631 ;; and report them as "Misplaced" rather than "Unrecognized".
1638 res))))
1639 optimize-qualities)))
1655 ;;; Use a list of DECLARE forms to annotate the lists of LAMBDA-VAR
1656 ;;; and FUNCTIONAL structures which are being bound. In addition to
1657 ;;; filling in slots in the leaf structures, we return a new LEXENV,
1658 ;;; which reflects pervasive special and function type declarations,
1659 ;;; (NOT)INLINE declarations and OPTIMIZE declarations, and type of
1660 ;;; VALUES declarations. If BINDING-FORM-P is true, the third return
1661 ;;; value is a list of VARs that should not apply to the lexenv of the
1662 ;;; initialization forms for the bindings, but should apply to the body.
1663 ;;;
1664 ;;; This is also called in main.lisp when PROCESS-FORM handles a use
1665 ;;; of LOCALLY.
1677 source-form
1682 spec decl))
1689 ;; Why do we allow more than one VALUES decl? I don't know.
1692 result-type
1701 ;; EXPLICIT-CHECK by itself specifies that all argument and
1702 ;; result types are checked by the function body.
1703 ;; Alternatively, a subset of arguments, and/or :RESULT,
1704 ;; can be specified to indicate that only a subset are
1705 ;; checked; in that case, the compiler asserts all others.
1713 it))
1719 ;; Used only for the current function.
1720 ;; E.g. suppressing argument checking without doing
1721 ;; so in all the subforms.
1727 post-binding-lexenv context)
1729 optimize-qualities
1734 (with-current-source-form (spec decl) ; TODO this is a slight change to the previous code. make sure the behavior is identical
1736 ;; Kludge: EVAL calls this function to deal with LOCALLY.
1741 lambda-list explicit-check source-form
1745 ;;; Return the SPECVAR for NAME to use when we see a local SPECIAL
1746 ;;; declaration. If there is a global variable of that name, then
1747 ;;; check that it isn't a constant and return it. Otherwise, create an
1748 ;;; anonymous GLOBAL-VAR.
1754 "~S is an alien variable and so can't be declared special."
1755 name))
1758 "~S is a constant and so can't be declared special."
1759 name))
1760 found))
1763 :%source-name name
1768 \f
1769 ;;;; Proclamations:
1770 ;;;
1771 ;;; PROCLAIM changes the global environment, so we must handle its
1772 ;;; compile time side effects if we are to keep the information in the
1773 ;;; (FREE-xxx *IR1-NAMESPACE*) tables up to date. When there is a var
1774 ;;; structure we disown it by replacing it with an updated copy. Uses
1775 ;;; of the variable which were translated before the PROCLAIM will get
1776 ;;; the old version, while subsequent references will get the updated
1777 ;;; information.
1779 ;;; If a special block compilation delimiter, then start or end the
1780 ;;; block as appropriate. If :BLOCK-COMPILE is T or NIL, then we
1781 ;;; ignore any start/end block declarations.
1793 :BLOCK-COMPILE is not :SPECIFIED"
1794 kind)))
1796 ;;; Update function type info cached in (FREE-FUNS *IR1-NAMESPACE*).
1797 ;;; If:
1798 ;;; -- there is a GLOBAL-VAR, then just update the type and remove the
1799 ;;; name from the list of undefined functions. Someday we should
1800 ;;; check for incompatible redeclaration.
1801 ;;; -- there is a FUNCTIONAL, then apply the type assertion to that
1802 ;;; function. This will only happen during block compilation.
1836 ;;; Replace each old var entry with one having the new type.
1845 ;; Constants cannot be redefined, and we already give the
1846 ;; constant object the tightest type possible. We will error
1847 ;; if the type is incompatible.
1855 ;;; Similar in effect to FTYPE, but change the :INLINEP. Copying the
1856 ;;; global-var ensures that when we substitute a functional for a
1857 ;;; global var (i.e. for DEFUN) that we won't clobber any uses
1858 ;;; declared :NOTINLINE.
1869 ;; Use the universal type as the local type restriction,
1870 ;; since we are processing the proclamation at the top
1871 ;; level and hence in a null lexical environment.
1874 ;;; Handle the compile-time side effects of PROCLAIM that don't happen
1875 ;;; at load time. These mostly side-effect the global state of the
1876 ;;; compiler, rather than the global environment.
1886 (:unknown