[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]


References:   None
Category:     ADDITION
Edit history: 29-Sep-88, Version 1 by Pitman
Status:	      For Internal Discussion

Problem Description:

  Some actions done by the compiler (and particularly the file compiler)
  are typically deferred until the "very end" of compilation.  For example,
  some compilers complain about "functions seen but not defined".

  Unfortunately, since COMPILE-FILE is the largest unit of granularity,
  and since systems often extend over more than one file, it often happens
  that the compiler needlessly complains at the end of compiling one file
  about the absence of functions defined in the next file. 


  Add the following new macro:


   Executes forms from left to right. Within the dynamic context
   of this form, actions deferred by the compiler until "the end of
   compilation" will be deferred until the end of the outermost call
   to WITH-COMPILATION-UNIT. The result(s) are the same as that of
   the last of the FORMS (or NIL if FORMS is null).

  It follows that the functions COMPILE and COMPILE-FILE should
  provide the effect of WITH-COMPILATION-UNIT around their code.

  Note that if nested, either lexically or dynamically, only the
  outer call to WITH-COMPILATION-UNIT has any effect.

  Note also that not all warnings are deferred. In some
  implementations, it may be that none are deferred. This proposal
  only creates an interface to the capability where it exists, it
  does not require the creation of the capability. An implementation
  which does not do deferred warnings may correctly implement this
  as expanding into PROGN.

Test Case:



  processes deferred warnings only after compiling all of A, B, and C.


  This will make the development of portable system-construction tools
  considerably more convenient. 

Current Practice:

  Symbolics Genera does something similar to this internally, allowing
  programs that compile whole systems of files to defer warnings until
  the end.

Cost to Implementors:

  In implementations which have no deferred warnings, there is no cost.
  In implementations which have deferred warnings, the cost is probably
  fairly small.

Cost to Users:

  None. This is a compatible addition.

Cost of Non-Adoption:

  Portable system-construction tools would continue to print lots of
  spurious warnings because they would have no way to tell the system
  that a set of files was working together.


  The cost of non-adoption is avoided.


  The ability to create a compilation unit other than a file is important.


  One could imagine a further extension which allowed user-code to be added
  to the list of things done at the end of a compilation-unit. Probably
  best to deal first with this issue and then with potentially more
  controversial extensions.

  Pitman supports this addition.