Results 1  10
of
12
Java Program Verification via a Hoare Logic with Abrupt Termination
 Fundamental Approaches to Software Engineering (FASE 2000), number 1783 in LNCS
, 2000
"... This paper formalises a semantics for statements and expressions (in sequential imperative languages) which includes nontermination, normal termination and abrupt termination (e.g. because of an exception, break, return or continue). This extends the traditional semantics underlying e.g. Hoare logi ..."
Abstract

Cited by 61 (6 self)
 Add to MetaCart
This paper formalises a semantics for statements and expressions (in sequential imperative languages) which includes nontermination, normal termination and abrupt termination (e.g. because of an exception, break, return or continue). This extends the traditional semantics underlying e.g. Hoare logic, which only distinguishes termination and nontermination. An extension of Hoare logic is elaborated that includes means for reasoning about abrupt termination (and sideeffects). It prominently involves rules for reasoning about while loops, which may contain exceptions, breaks, continues and returns. This extension applies in particular to Java. As an example, a standard pattern search algorithm in Java (involving a while loop with returns) is proven correct using the prooftool PVS.
A TypeTheoretic Memory Model for Verification of Sequential Java Programs
, 1999
"... This paper explains the details of the memory model underlying the verification of sequential Java programs in the "LOOP" project ([14, 20]). The building blocks of this memory are cells, which are untyped in the sense that they can store the contents of the fields of an arbitrary Java obj ..."
Abstract

Cited by 27 (11 self)
 Add to MetaCart
This paper explains the details of the memory model underlying the verification of sequential Java programs in the "LOOP" project ([14, 20]). The building blocks of this memory are cells, which are untyped in the sense that they can store the contents of the fields of an arbitrary Java object. The main memory is modeled as three infinite series of such cells, one for storing instance variables on a heap, one for local variables and parameters on a stack, and and one for static (or class) variables. Verification on the basis of this memory model is illustrated both in PVS and in Isabelle/HOL, via several examples of Java programs, involving various subtleties of the language (wrt. memory storage).
A Formalisation of Java's Exception Mechanism
 Programming Languages and Systems (ESOP), number 2028 in Lect. Notes Comp. Sci
, 2000
"... This paper examines Java's exception mechanism, and formalises its main operations (throw, trycatch and trycatchfinally) in a typetheoretic setting. This formalisation uses socalled coalgebras for modeling Java statements and expressions, thus providing a convenient setting for handling th ..."
Abstract

Cited by 16 (5 self)
 Add to MetaCart
(Show Context)
This paper examines Java's exception mechanism, and formalises its main operations (throw, trycatch and trycatchfinally) in a typetheoretic setting. This formalisation uses socalled coalgebras for modeling Java statements and expressions, thus providing a convenient setting for handling the various termination options that may arise in exception handling (closely following the Java Language Specification). This semantics of exceptions is used within the LOOP project on Java program verification. It is illustrated in two example verifications in PVS.
Coalgebras and Monads in the Semantics of Java
 Theoretical Computer Science
, 2002
"... This paper describes the basic structures in the denotational and axiomatic semantics of sequential Java, both from a monadic and a coalgebraic perspective. This semantics is an abstraction of the one used for the verification of (sequential) Java programs using proof tools in the LOOP project at th ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
(Show Context)
This paper describes the basic structures in the denotational and axiomatic semantics of sequential Java, both from a monadic and a coalgebraic perspective. This semantics is an abstraction of the one used for the verification of (sequential) Java programs using proof tools in the LOOP project at the University of Nijmegen. It is shown how the monadic perspective gives rise to the relevant computational structure in Java (composition, extension and repetition), and how the coalgebraic perspective o#ers an associated program logic (with invariants, bisimulations, and Hoare logics) for reasoning about the computational structure provided by the monad.
Formalising the Safety of Java, the Java Virtual Machine and Java Card
"... State Machine Semantics (ASM), Axiomatic Semantics (AS), Context Rewriting semantics (CR), Continuation or monad Semantics (CS), Denotational Semantics (DS), Natural Semantics (NS), Operational Semantics (OS), Structural Operational Semantics (SOS), or a semantic embedding in a higher odrder logic ( ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
State Machine Semantics (ASM), Axiomatic Semantics (AS), Context Rewriting semantics (CR), Continuation or monad Semantics (CS), Denotational Semantics (DS), Natural Semantics (NS), Operational Semantics (OS), Structural Operational Semantics (SOS), or a semantic embedding in a higher odrder logic (HOL).
Building verification condition generators by compositional extensions
, 2004
"... This paper describes a technique that combines algebraic specifications and monads to build derivative verification condition generators (VCGs) by extending a base VCG. Extensions are compositional and can be stacked while the base VCG is left unchanged. The technique can be used to build a set of w ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
This paper describes a technique that combines algebraic specifications and monads to build derivative verification condition generators (VCGs) by extending a base VCG. Extensions are compositional and can be stacked while the base VCG is left unchanged. The technique can be used to build a set of weaker VCGs, which are useful to support light weight verification. Moreover, it enables us to add an ability to generate validation traces. The paper explains the technique through an example that extends a simple language L0 with new constructs to handle exceptions. To deal with exceptions, not only that the logic of L0 has to be extended with new rules, its structure also needs to be changed. We show that using our technique the extension can be implemented in a simple and compositional way, without any change to the underlying logic.
LPS: A Language Prototyping System Using Modular Monadic Semantics
, 2001
"... This paper describes LPS, a Language Prototyping System that facilitates the modular development of interpreters from semantic building blocks. The system is based on the integration of ideas from Modular Monadic Semantics and Generic Programming. To define a new programming language, the abstract s ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
This paper describes LPS, a Language Prototyping System that facilitates the modular development of interpreters from semantic building blocks. The system is based on the integration of ideas from Modular Monadic Semantics and Generic Programming. To define a new programming language, the abstract syntax is described as the fixpoint of nonrecursive pattern functors. For each functor an algebra is defined whose carrier is the computational monad obtained from the application of several monad transformers to a base monad. The interpreter is automatically generated by a catamorphism or, in some special cases, a monadic catamorphism. The system has been implemented as a domainspecific language embedded in Haskell and we have also implemented an interactive framework for language testing. 1
Abstract Coalgebras and Monads in the Semantics of Java ⋆
"... This paper describes the basic structures in the denotational and axiomatic semantics of sequential Java, both from a monadic and a coalgebraic perspective. This semantics is an abstraction of the one used for the verification of (sequential) Java programs using proof tools in the LOOP project at th ..."
Abstract
 Add to MetaCart
(Show Context)
This paper describes the basic structures in the denotational and axiomatic semantics of sequential Java, both from a monadic and a coalgebraic perspective. This semantics is an abstraction of the one used for the verification of (sequential) Java programs using proof tools in the LOOP project at the University of Nijmegen. It is shown how the monadic perspective gives rise to the relevant computational structure in Java (composition, extension and repetition), and how the coalgebraic perspective offers an associated program logic (with invariants, bisimulations, and Hoare logics) for reasoning about the computational structure provided by the monad.
Incremental Implementation of Syntax Driven Logics
, 2006
"... This paper describes a technique combining higher order functions, algebraic datatypes, and monads to incrementally implement syntax driven logics. Extensions can be compositionally stacked while the base logic is left unchanged. The technique can furthermore be used to build a set of weaker logic ..."
Abstract
 Add to MetaCart
(Show Context)
This paper describes a technique combining higher order functions, algebraic datatypes, and monads to incrementally implement syntax driven logics. Extensions can be compositionally stacked while the base logic is left unchanged. The technique can furthermore be used to build a set of weaker logics for light weight verification or to generate validation traces. The paper explains the technique through an example: a Hoare logic for a simple command language. The example also shows how exceptions can be treated as an extension, without having to change the underlying logic.