Re: handling exceptions

Maikel Pennings <m.w.m.pennings@twi.tudelft.nl> writes:
>Does anyone know how a compiler (e.g. ada95 compiler) handles
>exceptions. I have to add exception handling to a compiler for a
>project, and I'm wondering how this is done in real compilers


Below is a BiBTeX bibliography.


Joel Jones
jjones@uiuc.edu


@Article{MacLaren:1977:EHP,
    author = "M. D. MacLaren",
    title = "Exception handling in {PL/1}",
    journal = "ACM SIG{\-}PLAN Notices",
    volume = "12",
    number = "3",
    pages = "101--104",
    month = mar,
    year = "1977",
    coden = "SINODQ",
    ISSN = "0362-1340",
    bibdate = "Sat Apr 25 11:46:37 MDT 1998",
    acknowledgement = ack-nhfb,
    classification = "C6110 (Systems analysis and programming); C6140D
                                  (High level languages)",
    conflocation = "Raleigh, NC, USA; 28-30 March 1977",
    conftitle = "Proceedings of an ACM Conference on Language Design
                                  for Reliable Software",
    corpsource = "Res. and Dev., Digital Equipment Corp., Maynard, MA,
                                  USA",
    keywords = "code generation; exceptional conditions; PL/1;
                                  structured programming",
    sponsororg = "ACM",
    treatment = "P Practical",
}


@Article{Drechsler:1987:PXC,
    author = "K. H. Drechsler and M. P. Stadel",
    title = "The {Pascal-XT} code generator",
    journal = "ACM SIG{\-}PLAN Notices",
    volume = "22",
    number = "8",
    pages = "57--78",
    month = aug,
    year = "1987",
    coden = "SINODQ",
    ISSN = "0362-1340",
    bibdate = "Sat Aug 13 17:16:20 MDT 1994",
    abstract = "This paper describes the code generator concept of the
                                  Siemens Pascal-XT compilers. Pascal-XT (Pascal
                                  eXTended) is an extension of ISO-Pascal. The most
                                  important extensions are a package concept with a
                                  separate compilation facility, private access types,
                                  static expressions in constant and type definitions,
                                  aggregates, exception handling, representation
                                  specifications for record types, and inline procedures
                                  and functions. Most of these extensions are very
                                  similar to the corresponding features of the Ada
                                  programming language. There exists a family of
                                  Pascal-XT compilers for several Siemens target machines
                                  ranging from personal computers through process control
                                  computers to main frames. Currently, an automatically
                                  vectorizing Pascal-XT compiler for the vector
                                  processors of the VP series is being developed.",
    acknowledgement = ack-nhfb,
    keywords = "design; languages",
    subject = "D.3.2 Software, PROGRAMMING LANGUAGES, Language
                                  Classifications, Pascal \\ D.3.4 Software, PROGRAMMING
                                  LANGUAGES, Processors, Code generation",
}


@InProceedings{Hennessy81.2,
    author = "John Hennessy",
    title = "Program Optimization and Exception Handling",
    booktitle = "Conference Record of the Eighth Annual {ACM} Symposium
                                  on Principles of Programming Languages",
    address = "Williamsburg, Virginia",
    organization = "ACM SIGACT-SIGPLAN",
    publisher = "ACM Press",
    month = jan # " 26--28,",
    year = "1981",
    pages = "200--206",
}


@Article{Chase:JCLT-5-4-229,
    author = "David Chase",
    title = "Implementation of exception handling, {Part I}",
    journal = "The Journal of {C} Language Translation",
    volume = "5",
    number = "4",
    pages = "229--240",
    month = jun,
    year = "1994",
    ISSN = "1042-5721",
    bibdate = "Fri Nov 21 14:40:20 1997",
    acknowledgement = ack-nhfb,
    remark = "The details of handling exceptions in C++ and similar
                                  languages.",
}


@Article{Chase:JCLT-6-1-20,
    author = "David Chase",
    title = "Implementation of Exception Handling, {Part II}:
                                  Calling Conventions, Asynchrony, Optimizers, and
                                  Debuggers",
    journal = "The Journal of {C} Language Translation",
    volume = "6",
    number = "1",
    pages = "20--32",
    month = sep,
    year = "1994",
    ISSN = "1042-5721",
    bibdate = "Fri Nov 21 14:40:20 1997",
    acknowledgement = ack-nhfb,
    remark = "More on the details of handling exceptions in C++ and
                                  similar languages",
}
@InProceedings{Tiemann:1990:EHI,
    author = "M. D. Tiemann",
    title = "An exception handling implementation for {C++}",
    editor = "Anonymous",
    booktitle = "{USENIX C++} Conference",
    publisher = "USENIX Association",
    address = "Berkeley, CA, USA",
    year = "1990",
    pages = "215--232",
    year = "1990",
    bibdate = "Wed Oct 30 06:04:36 MST 1996",
    abstract = "Outlines a design for an exception handling mechanism
                                  that has been implemented in GNU C++, a free,
                                  native-code C++ compiler. Various alternatives for
                                  handling exceptions are presented. An abstraction is
                                  derived which solves problems with existing C/C++
                                  solutions. The abstraction is flexible, type-safe,
                                  works in a mixed language execution environment. Two
                                  implementations are presented: one which can be
                                  implemented by a C++ to C translator, the other which
                                  can be implemented to run efficiently under a
                                  native-code compiler. The paper concludes with a brief
                                  survey of other exception handling designs.",
    acknowledgement = ack-nhfb,
    classification = "C6140D (High level languages); C6150C (Compilers,
                                  interpreters and other processors)",
    keywords = "Exception handling mechanism; GNU C++; C++ compiler;
                                  Abstraction; Mixed language execution environment; C++
                                  to C translator; Native-code compiler",
    thesaurus = "C language; Error handling; Object-oriented
                                  programming; Program compilers",
}


@Article{Sherman:1980:ACG,
    author = "M. Sherman and A. Hisgen and D. A. Lamb and J.
                                  Rosenberg",
    title = "An {Ada} code generator for {VAX 11\slash 780} with
                                  {Unix}",
    journal = "ACM SIG{\-}PLAN Notices",
    volume = "15",
    number = "11",
    pages = "91--91",
    month = nov,
    year = "1980",
    coden = "SINODQ",
    ISSN = "0362-1340",
    bibdate = "Sat Apr 25 11:46:37 MDT 1998",
    acknowledgement = ack-nhfb,
    classification = "C6140D (High level languages); C6150C (Compilers,
                                  interpreters and other processors); C6150J (Operating
                                  interpreters and other processors); C6150J (Operating
                                  systems)",
    conflocation = "Boston, MA, USA; 9-11 Dec. 1980",
    conftitle = "Proceedings of the ACM-SIGPLAN Symposium on the Ada
                                  Programming Language",
    corpsource = "Dept. of Computer Sci., Carnegie-Mellon Univ.,
                                  Pittsburgh, PA, USA",
    keywords = "Ada; Ada compiler; code generator; exception handling;
                                  function return values; operating system; operating
                                  systems (computers); parameter passing; program
                                  compilers; subprogram calls; Unix; VAX 11/780",
    treatment = "A Application",
}


@Article{Goodenough:cacm:1975,
    author = "John B. Goodenough",
    title = "Exception Handling: Issues and a Proposed Notation",
    journal = "Communications of the ACM",
    volume = "18",
    number = "12",
    pages = "683--696",
    month = dec,
    year = "1975",
    refs = "26",
    checked = "19940905",
    source = "Dept. Library",
    keywords = "multilevel exit, goto statement, error conditions,
                                  structured programming, ON conditions, programming
                                  languages, exception handling",
    abstract = "This paper defines exception conditions, discusses the
                                  requirements exception handling language features must
                                  satisfy, and proposes some new language features for
                                  dealing with exceptions in an orderly and reliable way.
                                  The proposed language features serve to highlight
                                  exception handling issues by showing how deficiencies
                                  in current approaches can be remedied.",
    sjb = "\begin{quote} \ldots. Specifically exceptions are
                                  used: \begin{itemize} \item to permit dealing with an
                                  operation's impending or actual failure. Two types of
                                  failure are of interest: range failure, and domain
                                  failure. \item to indicate the significance of a valid
                                  result or the circumstances under which it was
                                  obtained. \item to permit an invoker to {\em monitor}
                                  an operation, e.g. to measure computational progress or
                                  to provide additional information and guidance should
                                  certain conditions arise. \end{itemize} The value of
                                  making this classification of exception uses is the
                                  insight it gives into the need for various
                                  exception-handling language capabilities. \end{quote}
                                  Goes on to describe methods of representing exception
                                  handlers: subroutines, labels, status variables,
                                  object-oriented exception handlers, handler setup
                                  calls, PL/I ON conditions. Describes an extension to
                                  PL/I where exception handlers can be attached to
                                  individual expressions. Also discusses whether handler
                                  blocks/procedures should indicate the exceptions that
                                  they deal with and/or raise and what to do with default
                                  exception handlers and exception handling
                                  hierarchies.",
    xref = "Goodenough:acm:popl:1975",
    reffrom = "Horning:pc:1978c",
    reffrom = "Lee:spe:1983",
    reffrom = "Knudsen:spe:1984",
    reffrom = "Knudsen:ieee:software:1987",
}


@Article{Liskov-Snyder79,
    key = "Liskov \& Snyder",
    author = "Barbara H. Liskov and Alan Snyder",
    title = "Exception Handling in {CLU}",
    journal = "IEEE Transactions on Software Engineering",
    year = "1979",
    volume = "SE-5",
    number = "6",
    month = nov,
    pages = "546--558",
    annote = "Describes the exception handling mechanism in CLU.
                                  Gives rationale for the termination model and an
                                  implementation. 9 references.",
}


@TechReport{Mitchell-Maybury-Sweet79,
    key = "Mitchell \& Maybury \& Sweet",
    author = "James G. Mitchell and William Maybury and Richard
                                  Sweet",
    title = "Mesa Language Manual",
    institution = "Xerox Palo Alto Research Centers",
    year = "1979",
    month = apr,
    number = "CSL-79-3",
    annote = "Mesa is a systems programming language with modules
                                  which are used to program abstract data types.",
}

Return to the comp.compilers page.
Search the comp.compilers archives again.