Rewriting logic is a flexible and expressive logical framework that unifies denotational semantics and SOS in a novel way, avoiding their respective limitations and allowing very succinct semantic definitions. The fact that a rewrite theory’s axioms include both equations and rewrite rules provides a very useful “abstraction knob” to find the right balance between abstraction and observability in semantic definitions. Such semantic definitions are directly executable as interpreters in a rewriting logic language such as Maude, whose generic formal tools can be used to endow those interpreters with powerful program analysis capabilities.

This paper describes in detail how to bridge the gap between theory and practice when implementing in Maude structural operational semantics described in rewriting logic, where transitions become rewrites and inference rules become conditional rewrite rules with rewrites in the conditions, as made possible by the new features in Maude 2.0. We validate this technique using it in several case studies: a functional language Fpl (evaluation and computation semantics, including an abstract machine), imperative languages WhileL (evaluation and computation semantics) and GuardL with nondeterminism (computation semantics), Kahn's functional language Mini-ML (evaluation or natural semantics), Milner's CCS (with strong and weak transitions), and Full LOTOS (including ACT ONE data type specifications). In addition, on top of CCS we develop an implementation of the Hennessy-Milner modal logic for describing local capabilities of processes, and for LOTOS we build an entire tool where Full LOTOS specifications can be entered and executed (without user knowledge of the underlying implementation of the semantics). We also compare this method based on transitions as rewrites with another one based on transitions as judgements.

We present an extension of natural semantics which can be used to describe the static semantics of imperative and object-oriented programming languages. Furthermore we show that the semantic analysis can be generated from these descriptions. As a side effect, we get a precise definition of which properties of a programming language are statically decidable and which properties can only be checked dynamically during run-time. As an example, we show how a subset of the Java programming language incorporating the full notion of inheritance can be specified within our mechanism. Keywords Natural Semantics, Semantic Analysis, Specification, Generator, Imperative and Object-Oriented Programming Languages 1 INTRODUCTION Natural semantics [Kah87] has been established as a declarative framework to specify the static and dynamic semantics of functional programming languages. Its applicability for imperative languages with simple block structure has been shown (e.g. the specifications of simple...

The coincidence between the model-theoretic and the procedural semantics of SLDresolution does not carry over to a Prolog system that also implements non-logical features like cut and whose depth-first search strategy is incomplete. The purpose of this paper is to present the key concepts of a new, simple operational semantics of Standard Prolog in the form of rewriting rules. We use a novel linear representation of the Prolog tree traversal. A derivation is represented at the level of unification and backtracking. The rewriting system presented here can easily be implemented in a rewriting logic language, giving an executable specification of Prolog. 1

. We introduce a specification language that can be used to specify semantic analysis as well as intermediate code generation. This specification language defines semantic properties by means of many-sorted inference rules. Type inference rules are just a one-sorted special case. We demonstrate that inference rules can also be used to infer other semantic information such as definitions of identifiers, scoping, inheritance relations, etc. To distinguish the different kinds of semantic information described by the rules, we use a many-sorted language to formulate the inference rules. We further show how to transform a set of inference rules algorithmically into an attribute grammar, thus proving that semantic analysis and intermediate code generation can be generated from such specifications. Keywords: Inference rules, specification language, semantic analysis, intermediate code representation, compiler generators 2 Sabine Glesner and Wolf Zimmermann 1. Introduction In the literature...

Natural semantics specifications have become mainstream in the formal specification of programming language semantics during the last ten years. In this paper, we set up sorted natural semantics as a specification framework which is able to express static semantic information of programming languages declaratively in a uniform way and allows at the same time to generate corresponding analyses. Such static semantic information comprises context-sensitive properties which are checked in the semantic analysis phase of compilers as well as further static program analyses such as e.g. classical data and control flow analyses or type and effect systems. The latter require fixed point analyses to determine their solutions. We show that, given a sorted natural semantics specification, we can generate the corresponding analysis. Therefore, we classify the solution of such an analysis by the notion of a proof tree. We show that a proof tree can be computed by solving an equivalent residuation problem. In case of the semantic analysis, this solution can be found by a basic algorithm. We show that its efficiency can be enhanced using solution strategies. We also demonstrate our prototype implementation of the basic algorithm which proves its applicability in practical situations. With the results of this paper, we have established natural semantics as a framework which closes the gap between declarative and

We follow the trend to use inference rule based specifications when describing the semantics of imperative and object-oriented programming languages. Within manysorted natural semantics it is possible to define the static semantics of imperative and object-oriented programming languages exclusively by using inference rules. During the semantic analysis we need to infer semantic information by using the inference rules of the specification so that the semantic analysis can be considered as a proof procedure. We show how this proof procedure can be implemented efficiently by exploiting techniques known from object-oriented libraries and by using concurrent constraint programming.

. We present a declarative specification method based on natural semantics which is suitable for the definition of the static and dynamic semantics of imperative and object-oriented programming languages. We show how the semantic analysis can be generated automatically by creating, for each program under consideration, a constraint problem whose solution is also a valid attribution. In contrast to previous implementations of natural semantics, our generation algorithm for the semantic analysis is more flexible because it allows us to compute a program's attributes independently from its syntax tree. For special cases, we have defined efficient solution strategies. We also describe our prototype implementation using the concurrent constraint programming language Oz. 1 Introduction In principle, specifications of the semantics of programming languages serve two different purposes. Either they are the formal basis to verify language or program properties, or they are used to g...

Modelica is an open standardized language used for modeling and simulation of complex physical systems. The language specification defines a formal concrete syntax, but the semantics is informally described using natural language. The latter makes the language hard to interpret, maintain and reason about, which affect both tool development and language evolution. Even if a completely formal semantics of the Modelica language can be seen as a natural goal, it is a well-known fact that defining understandable and concise formal semantics specifications for large and complex languages is a very hard problem. In this paper, we will discuss different aspects of formulating a Modelica specification; both in terms of what should be specified and how it can be done. Moreover, we will further argue that a ”middle-way ” strategy can make the specification both clearer and easier to reason about. A proposal is outlined, where the current informally specified semantics is complemented with several grammars, specifying intermediate representations of abstract syntax. We believe that this kind of evolutionary strategy is easier to gain acceptance for, and is more realistic in the short-term, than a revolutionary approach of using a fully formal semantics definition of the language.

types must be rebound in the module's body, whereas other types may not be rebound. 6.3 Type Structures and Type Environments A type structure (`; CE opt ) is well-formed if either CE opt = ", or CE opt = fg, or ` is of the form ff :ff t, abbreviated as t. (The latter case arises, with CE opt being a non-empty environment, in datatype specifications and declarations.) All type structures occurring in elaborations are assumed to be well-formed. A type structure (t; CE ) is said to respect equality if, whenever t admits equality, then for each CE (con) of the form 8ff (k) :(ø d)e[ff (k) t]), the type function ff (k) :ø also admits equality. (This ensures that the equality goal = will be applicable to a constructed value (con ; v ) of type ø (k) t only when it is applicable to the tuple v itself, whose type is ø fff i 7! ø i ; 1 i kg.) A type environment TE respects equality if all its type structures do so. Let TE be a type environment, and let T be th...