Abstract. We present a new algorithm for checking the shape-safety of pointer manipulation programs. In our model, an abstract, data-less pointer structure is a graph. Ashape is a language of graphs. A pointer manipulation program is modelled abstractly as a set of graph rewrite rules over such graphs where each rule corresponds to a pointer manipulation step. Each rule is annotated with the intended shape of its domain and range and our algorithm checks these annotations. We formally define the algorithm and apply it to a binary search tree insertion program. Shape-safety is undecidable in general, but our method is more widely applicable than previous checkers, in particular, it can check programs that temporarily violate a shape by the introduction of intermediate shape definitions. 1

Shapely nested graph transformation is the computational model for DiaPlan, a language for programming with graphs that represent diagrams. It supports nested structuring of graphs, structural graph types (shapes), and graph variables. In this paper, we extend the model by two concepts that are essential for programming: abstraction allows compound transformations to be named and parameterized, and control allows the order of rule application to be specified. These concepts combine neatly with the underlying computational model, and preserve its rule-based and graph-ical nature.

Abstract. We investigate the narrowing relation in a wide class of (cyclic) term-graph rewrite systems. We propose a new sound and complete narrowing-based algorithm able to solve goals in presence of data structures with pointers (e.g., circular lists, doubly linked lists etc.). We first define the class of rewrite systems we consider. Our rules provide features such as pointer (edge) redirections, relabeling of existing nodes, in addition to the creation of new nodes. Moreover, we split the set of nodes of term-graphs in two (possibly empty) subsets: (i) variables and (ii) names. Variable nodes can be mapped against any other node whereas names act as constants and thus they are supposed to match themselves. This distinction between nodes allows us to synthesize, through the narrowing process, data-structures with circular shapes. In a second step, we define the rewriting and narrowing relations. We then show the soundness and completeness of narrowing. 1

The project Safe Pointers by Graph Transformation at the University of York has developed a method for specifying the shape of pointer-data structures by graph reduction, and a static checking algorithm for proving the shape safety of graph transformation rules modelling operations on pointer structures. In this paper, we outline how to apply this approach to the C programming language. We extend ANSI C with so-called transformers which model graph transformation rules, and with shape specifications for pointer structures. For the resulting language C-GRS, we present both a translation to C and and an abstraction to graph transformation. Our main result is that the abstraction of transformers to graph transformation rules is correct in that the C code implementing transformers is compatible with the semantics of graph transformation.

DIAPLAN is a language for programming with graphs representing diagrams that is currently being developed. The computational model of the languages, nested graph transformation, supports nested structuring of graphs, and graph variables, but is--hopefully--still intuitive. This paper is about structural typing of nested graphs and nested graph transformation systems by shape rules. We extend the context-free shape rules proposed in earlier work to context-exploiting shape rules by which many relevant graph structures can be specified. The conformance of a nested graph to shape rules is decidable. If a transformation system conforms to shape rules as well, it can be shown to preserve shape conformance of the graphs it is applied to. This sets up a static type discipline for nested graph transformation.

The notion of confluence is prevalent in graph transformation systems (GTS) as well as constraint handling rules (CHR). This work presents a generalized embedding of GTS in CHR that allows to consider strong derivations in confluence analyses. Confluence of a terminating CHR program is decidable, but confluence of a terminating GTS is undecidable. We show that observable confluence in CHR is a sufficient criterion for confluence of the embedded GTS. For this purpose the automatic confluence check for CHR can be reused. Keywords:

Motivated by applications that require mechanisms for describing the structure of object-oriented programs, adaptive star grammars are introduced, and their fundamental properties are studied. In adaptive star grammars, rules are actually schemata which, via the cloning of so-called multiple nodes, may adapt to potentially infinitely many contexts when they are applied. This mechanism makes adaptive star grammars more powerful than context-free graph grammars. Nevertheless, they turn out to be restricted enough to share some of the basic characteristics of context-free devices. In particular, the underlying substitution operator enjoys associativity and confluence properties quite similar to those of context-free graph grammars, and the membership problem for adaptive star grammars is decidable. 1

Abstract. We present conditions under which graph transformation rules can be applied in time independent of the size of the input graph: graphs must contain a unique root label, nodes in the left-hand sides of rules must be reachable from the root, and nodes must have a bounded outdegree. We establish a constant upper bound for the time needed to construct all graphs resulting from an application of a fixed rule to an input graph. We also give an improved upper bound under the stronger condition that all edges outgoing from a node must have distinct labels. Then this result is applied to identify a class of graph reduction systems that define graph languages with a linear membership test. In a case study we prove that the (non-context-free) language of balanced binary trees with backpointers belongs to this class. 1

Abstract. The precise specification of software models is a major concern in model-driven design of object-oriented software. In this paper, we investigate how program graphs, a language-independent model of object-oriented programs, can be specified precisely, with a focus on static structure rather than behavior. Graph grammars are a natural candidate for specifying the structure of a class of graphs. However, neither star grammars—which are equivalent to the well-known hyperedge replacement grammars—nor the recently proposed adaptive star grammars allow all relevant properties of program graphs to be specified. So we extend adaptive star rules by positive and negative application conditions, and show that the resulting conditional adaptive star grammars are powerful enough to generate program graphs. 1

In general, it is undecidable whether a terminating graph-transformation system is confluent or not. We introduce the class of coverable hypergraph-transformation systems and show that confluence is decidable for coverable systems that are terminating. Intuitively, a system is coverable if its typing allows to extend each critical pair with a non-deletable context that uniquely identifies the persistent nodes of the pair. The class of coverable systems includes all hypergraphtransformation systems in which hyperedges can connect arbitrary sequences of nodes, and all graph-transformation systems with a sufficient number of unused edge labels.