Janssens, G. and M. Bruynooghe: 1992, `Deriving Descriptions of Possible Values of Program Variables by Means of Abstract Interpretation'. Journal of Logic Programming 13#2-3#, 205#258.  Home/Search   Document Not in Database   Summary   Related Articles   Check

....for Sharing follows by the isomorphism. Theorem 4. Sh is a proper abstraction of Type(Sh ) 7 Related Work and Conclusion We brie y compare the approach proposed in this paper with some previous works presenting abstract domains based on regular types. Janssens and Bruynooghe present in [12] a framework for program type and mode analysis of Prolog programs based on type graphs. The abstract domains based on rigid types and integrated types are capable of inferring types and modes of a program. The later domain can track freeness as an additional mode, thus signi cantly improving the ....

....types are capable of inferring types and modes of a program. The later domain can track freeness as an additional mode, thus signi cantly improving the precision of analysis for programs manipulating partially instantiated structures. The work of Mulkers et al. 16] applies the framework of [12] for tracking liveness of Prolog structures. The abstract domain developed in this work models the execution environment of a predicate using type graphs and special arcs representing structure sharing. In Bruynooghe et al. 1] the framework of [16] is further extended and applied to liveness ....

[Article contains additional citation context not shown here]

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. JLP, 13(2 & 3):205-258, 1992.

....1 ; t 2 )j t 1 is a nil terminated list and t 2 is a free variableg. Then, Call(P; S) S [ fdelete(t 1 ; t 2 ; t 3 )j t 1 ; t 3 are free variables and t 2 is a nil terminated listg: Such information about S could for instance be expressed in terms of the rigid types of Janssens and Bruynooghe [21] and Call(P; S) could be computed using the type inference of [21] 2 6 The following definition generalises the notion of acceptability with respect to a set [12] in two ways: 1) it generalises it to general quasi orderings, 2) it generalises it to mutual recursion, using the standard notion of ....

.... Then, Call(P; S) S [ fdelete(t 1 ; t 2 ; t 3 )j t 1 ; t 3 are free variables and t 2 is a nil terminated listg: Such information about S could for instance be expressed in terms of the rigid types of Janssens and Bruynooghe [21] and Call(P; S) could be computed using the type inference of [21]. 2 6 The following definition generalises the notion of acceptability with respect to a set [12] in two ways: 1) it generalises it to general quasi orderings, 2) it generalises it to mutual recursion, using the standard notion of mutual recursion [2] Definition 6. Let S be a set of atomic ....

[Article contains additional citation context not shown here]

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. J. Logic Programming, 13(2&3):205--258, July 1992.

....could be represented more accurately, by requiring the domain to keep track of the di#erent chains contained in the structures to which the program variables are bound, their individual trailing state and how these are a#ected by the di#erent program constructs. Known techniques (see for instance [7, 6, 9]) based on type information could be used to keep track of the constructor that a variable is bound to and the trailing state of the di#erent arguments, thereby making this approach possible. This applies equally to the analysis of the classical scheme. Additionally it would be interesting to see ....

G. Janssens and M. Bruynooghe. Deriving descriptions of possible value of program variables by means of abstract interpretation. JLP, 13:205--258, 1993.

....could be represented more accurately, by requiring the domain to keep track of the di erent chains contained in the structures to which the program variables are bound, their individual trailing state and how these are a ected by the di erent program constructs. Known techniques (see for instance [7, 6, 9]) based on type information could be used to keep track of the constructor that a variable is bound to and the trailing state of the di erent arguments, thereby making this approach possible. This applies equally to the analysis of the classical scheme. Additionally it would be interesting to see ....

G. Janssens and M. Bruynooghe. Deriving descriptions of possible value of program variables by means of abstract interpretation. JLP, 13:205-258, 1993.

....bound variables more accurately, by requiring the domain to keep track of the di#erent chains contained in the structures to which the program variables are bound, their individual trailing state and how these are a#ected by the di#erent program constructs. Known techniques (see for instance [JB93,HCC95,MWB94]) based on type information could be used to keep track of the constructor that a variable is bound to and of the trailing state of the di#erent arguments, thereby making this approach possible. 5 Analysing HAL Body Constructs This section defines the notrail operations required by HAL s ....

G. Janssens and M. Bruynooghe. Deriving descriptions of possible value of program variables by means of abstract interpretation. JLP, 13:205-- 258, 1993.

....Almost all work on mode analysis in logic programming has focused on untyped languages, mainly Prolog. As a consequence, most papers use very simple analysis domains, such as ground, free, unknown . One can use patterns from the code to derive more detailed program specific domains, as in e.g. [3, 10, 12], but such analyses must sacrifice too much precision to achieve acceptable analysis times. In [18] we proposed fixing this problem by requiring type information and using the types of variables as the domains of mode analysis. Several papers since then (e.g. 14, 17] have been based on similar ....

G. Janssens and M. Bruynooghe. Deriving descriptions of possible value of program variables by means of abstract interpretation. JLP, 13:205--258, 1993.

....; T 1) Let S be fperm(t 1 ; t 2 ) j t 1 is a nil terminated list and t 2 is a free variableg. Then, Call(P; S) S [ f del(t 1 ; t 2 ; t 3 ) j t 1 and t 3 are free variables and t 2 is a nil terminated listg. Such information about S could for instance be expressed in terms of the rigid types of [16] and Call(P; S) could be computed using the type inference of [16] 2 The following definition generalises the notion of acceptability w.r.t. a set [9] in two ways: 1) it generalises it to general term orders, 2) it generalises it to mutual recursion, using the standard notation of mutual ....

....and t 2 is a free variableg. Then, Call(P; S) S [ f del(t 1 ; t 2 ; t 3 ) j t 1 and t 3 are free variables and t 2 is a nil terminated listg. Such information about S could for instance be expressed in terms of the rigid types of [16] and Call(P; S) could be computed using the type inference of [16]. 2 The following definition generalises the notion of acceptability w.r.t. a set [9] in two ways: 1) it generalises it to general term orders, 2) it generalises it to mutual recursion, using the standard notation of mutual recursion [1] the original definition of acceptability required decrease ....

[Article contains additional citation context not shown here]

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. J. Logic Programming, 13(2&3):205--258, July 1992.

....or variable is allowed to take, but in this paper we are concerned with deriving such descriptions statically, rather than prescribing them. Derivation of set expressions such as these has many applications including type inference [16, 8] debugging [24] assisting compiler optimisations [25, 34], optimising a theorem prover [14] program specialisation [20] planning [4] and veri cation [8] The rst work in this area was by Reynolds [33] other early research was done by Jones and Muchnick [27, 26] In the past decade two di erent approaches to deriving set expressions have been ....

....[20] planning [4] and veri cation [8] The rst work in this area was by Reynolds [33] other early research was done by Jones and Muchnick [27, 26] In the past decade two di erent approaches to deriving set expressions have been followed. One approach is based on abstract interpretation [25, 34, 19, 13, 30], and the other on solving set constraints derived from the program text [22, 16, 21, 2, 1, 28, 9, 32] In abstract interpretation the program is executed over an abstract type domain, program variables taking on abstract values represented by types rather than standard values. In set constraint ....

[Article contains additional citation context not shown here]

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. Journal of Logic Programming, 13(2-3):205-258, July 1992.

.... for all atomic goals in the set S = fpermute(t 1 ; t 2 ) j t 1 is a nil terminated list and t 2 is a free variableg: Initially, a separate analysis is needed to determine the set Call(P; S) In this particular example, type inference (for instance through the abstract interpretation of [Janssens and Bruynooghe 1992]) allows to determine that Call(P; S) is the set S [ fdelete(t 1 ; t 2 ; t 3 ) j t 1 and t 3 are free variables and t 2 is a nil terminated list g: 12 Stefaan Decorte, Danny De Schreye, Henk Vandecasteele The analysis starts by setting up symbolic versions of all concepts needed in the ....

....They allow e.g. to distinguish between lists and other terms, which is impossible by modes. In the literature, several type formalisms have been proposed (see e.g. Pfenning 1992] In this article, we pick out one particular instance, called rigid types, to illustrate the main ideas. We refer to [Janssens and Bruynooghe 1992] for a deeper study on rigid types and their properties. Other formalisms can be used with minor changes only. In the following, we recall the basic ideas and we give an example. There exist a number of primitive types (e.g. INT, REAL) which represent subsets of the set of constants in the ....

[Article contains additional citation context not shown here]

Janssens, G. and Bruynooghe, M. 1992. Deriving descriptions of possible values of program variables by means of abstract interpretation. Journal of Logic Programming 13, 2 & 3, 205-258.

.... L(cons(a, nil) # cons(E(a) L(nil) # cons(a, L(nil) # cons(a, nil) We also write L(cons(a, nil) # # E(a) and L(cons(a, nil) # # L(nil) The notation can also be applied to non ground terms, e.g. L(cons(X, Y) # # L(Y) It is also convenient to depict a grammar as a type graph [10]. We define a type graph for G = #S, W,#,## as a directed graph whose nodes are labelled by nonterminals, and there is an edge from N to N # i# there is a production N # f( N # , in #. We call the node L . ....

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. Journal of Logic Programming, 13(2 & 3):205--258, 1992. First author name erroneously spelt "Janssen".

....or variable is allowed to take, but in this paper we are concerned with deriving such descriptions statically, rather than prescribing them. Derivation of set expressions such as these has many applications including type inference [13, 6] debugging [21] assisting compiler optimisations [22, 32], optimising a theorem prover [11] program specialisation [17] planning [3] and veri cation [6] The rst work in this area was by Reynolds [30] other early research was done by Jones and Muchnick [24, 23] In the past decade two di erent approaches to deriving set expressions have been ....

....[17] planning [3] and veri cation [6] The rst work in this area was by Reynolds [30] other early research was done by Jones and Muchnick [24, 23] In the past decade two di erent approaches to deriving set expressions have been followed. One approach is based on abstract interpretation [22, 32, 16, 10, 27], and the other on solving set constraints derived from the program text [19, 13, 18, 2, 1, 25, 7, 29] In abstract interpretation the program is executed over an abstract type domain, program variables taking on abstract values represented by types rather than standard values. In set based ....

[Article contains additional citation context not shown here]

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. Journal of Logic Programming, 13(2-3):205{ 258, July 1992.

....: Rn and j j 1 ; j j n . Let i 2 f1; ng. If Q is de ned in R 1 [ R i then Q is strongly bounded wrt. R 1 [ R i and j j 1 ; j j i . In order to verify whether a query Q is strongly bounded wrt. a given program P one can perform a call pattern analysis [JB92, GG94, CD95] which allows us to infer information about the form of the call patterns, i.e. the atoms that will be possibly called during the execution of P [ fQg. However this is not the only way for guaranteeing strong boundedness. There are classes of programs and queries for which strong boundedness can ....

G. Janssen and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. Journal of Logic Programming, 13(2-3):205-258, 1992.

....On the other hand, it is possible to use abstract interpretation techniques to infer directional types of a program. Soundness of an abstract interpretation method can be justified by deriving it systematically from the verification conditions. An example of an abstract interpretation approach is (Janssens Bruynooghe, 1992; Van Hentenryck et al. 1995) Another example is (Gallagher de Waal, 1994) it derives types in form of discriminative term grammars. In (Drabent et al. 2000a) we modified the latter technique to infer directional types for CLP programs. In this paper we present its further extension for ....

....to the extension. Therefore we leave the issue of implementation of the extension as a topic of future work and in our work we focus on another approach discussed below. The second way of finding a model of the constraint system C(P ) stems from abstract interpretation approaches (among others (Janssens Bruynooghe, 1992; Van Hentenryck et al. 1995) Gallagher de Waal, 1994) we generalize the latter work in (Drabent Pietrzak, 1999; Drabent et al. 2000b; Drabent et al. 2000a) and here) C(P ) is seen as a valuation transformer, its fixed points are models 3 This approach can also be used when P is a ....

[Article contains additional citation context not shown here]

Janssens, G., & Bruynooghe, M. (1992). Deriving descriptions of possible values of program variables by means of abstract interpretation. Journal of Logic Programming, 13(2 & 3), 205--258.

....open ended definitions of our derived norms should facilitate such a study. 9 5 Related work One weakness of [6] is that its norms are derived from type graphs. Type graph analyses, however, have not always been renowned for their tractability. Even for small programs, the prototype analyser of [12], used in [6] is typically 15 times slower than the optimising PLM compiler [15] Recently, type graph analysis has been shown to be practical for medium sized Prolog programs [14] when augmented with an improved widening and compacting procedure. In addition, Gallagher and de Waal have shown how ....

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. J. Logic Programming, 13:205--258, 1992.

....traditional logic programming languages where the analysis assumes the given literal ordering is correct, only simple instantiations are used and higher order predicates are largely ignored. Regular trees have been used before in logic programming to de ne types, e.g. 6] and instantiations, e.g. [8], usually in the context of inference of information. Here, although we use regular trees to formalize types, our type analysis [5] is based on a HindleyMilner approach. A key di erence with previous work (in particular [8] is that we describe instantiations for polymorphic types, including ....

....in logic programming to de ne types, e.g. 6] and instantiations, e.g. 8] usually in the context of inference of information. Here, although we use regular trees to formalize types, our type analysis [5] is based on a HindleyMilner approach. A key di erence with previous work (in particular [8]) is that we describe instantiations for polymorphic types, including higher order objects. The only other work on mode checking in strongly typed logic languages with reorderable clause bodies is that of [12] 2 The HAL Language In this section we provide an overview of the HAL language. The ....

[Article contains additional citation context not shown here]

G. Janssens and M. Bruynooghe. Deriving descriptions of possible value of program variables by means of abstract interpretation. JLP, 13:205-258, 1993.

....this approach is that missing type information can be inferred, and in the extreme, when no information is provided by the user all types are inferred by the system. A starting point for development of a tool based on this approach may be the previous work done for logic programs, e.g. SG95] or [JB92] The type system proposed therein should then be extended to the constraint domain in question. ffl The use of dedicated proof techniques for directional types. The directional types combine a kind of mode information, where every argument of a predicate is a priori determined as input or as ....

G. Janssens and M. Bruynooghe. Deriving Descriptions of Possible Values of Program Variables by means of Abstract Interpretation. Journal of Logic Programming, 13(2 and 3):205--258, July 1992.

....necessary, with the understanding that the algorithms are defined with respect to normalized clauses. 3 Types, Tests, and Coverings A type refers to a set of terms, and can be denoted by using several type representations (e.g. type terms and regular term grammars as in [3] or type graphs as in [13]) Let type[q] denote the type of each predicate q in a given program. In this paper, we are concerned exclusively with calling types for predicates in other words, when we say a predicate p in a program P has type type[p] we mean that in any execution of the program P starting from some ....

....of the set denoted by type[p] The non failure analysis we describe is based on regular types [3] which are specified by regular term grammars in which each type symbol has exactly one defining type rule. A more detailed treatment of these issues may be found in papers on type analysis, e.g. [3, 13]. Due to space limitations we do not pursue them further here. We denote the Herbrand Universe (i.e. the set of all ground terms) as H, and the set of n tuples of elements of H as H n . Given a (finite) set of variables V , a type assignment over V is a mapping from V to a set of types. A ....

G. Janssens and M. Bruynooghe. Deriving Descriptions of Possible Values of Program Variables by means of Abstract Interpretation. Journal of Logic Programming, 13(2 and 3):205--258, July 1992.

....an output demand to an input demand. Input and output demands are measures of data, which in our context means how constrained the shared data structures must be. The current approach quantifies such a demand by specifying a non ground type, rather than for instance a term size. A non ground type [23, 19] is a regular set of terms that possibly contain unbound variables. The safety requirement of the analysis is that, if the input provided to the process is less determined than required by the input demand, the output provided by the process will be less determined than required by the output ....

....the empty set. We assume that union of types implicitly forms the Cartesian closure: Restricting attention briefly to a single binary function symbol, f , a set T is Cartesian closed if f(a; b) f(c; d) 2 T implies f(a; d) f(c; b) 2 T . This corresponds to the principal function restriction of [23]. The domain of abstract constraints consists of systems of equations over PVtypes, which are given by the syntactic category D V . Program variables are per 9 mitted in PV types (whence the PV ) but only outside of unions and fixpoints 1 . This enables our abstract domain to express ....

[Article contains additional citation context not shown here]

G. Janssens and M. Bruynooghe. Deriving Descriptions of Possible Values of Program Variables by means of Abstract Interpretation. Journal of Logic Programming, 13(1, 2, 3 and 4):205--258, 1992.

....idea here is to overapproximate the least model of a given program by a regular set. This approach can be found in particular in [45, 57, 37, 29, 5, 26, 38, 31, 41, 27] or, using a typegraph representation of regular sets (a type graph may be seen as a deterministic top down tree automaton) in [43, 41]. An advantage of the descriptive approach is that there is no need for type declarations; a disadvantage is that the inferred types may not correspond to the intent of the programmer. The present paper falls into both the prescriptive and the descriptive streams. In Section 6 we discuss the ....

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. Journal of Logic Programming, 13(2-3):205-258, July 1992. 30

....traditional logic programming languages where the analysis assumes the given literal ordering is correct, only simple instantiations are used and higher order predicates are largely ignored. Regular trees have been used before in logic programming to de ne types, e.g. 7] and instantiations, e.g. [9], usually in the context of inference of information. Here, although we use regular trees to formalize types, our type analysis [6] is based on a Hindley Milner approach. A key di erence with previous work (in particular [9] is that we describe instantiations for polymorphic types, including ....

....in logic programming to de ne types, e.g. 7] and instantiations, e.g. 9] usually in the context of inference of information. Here, although we use regular trees to formalize types, our type analysis [6] is based on a Hindley Milner approach. A key di erence with previous work (in particular [9]) is that we describe instantiations for polymorphic types, including higher order objects. The only work on mode checking in strongly typed logic languages with reorderable clause bodies is that of [13] Other related work has been on mode checking for concurrent logic programming languages [2] ....

[Article contains additional citation context not shown here]

G. Janssens and M. Bruynooghe. Deriving descriptions of possible value of program variables by means of abstract interpretation. JLP, 13:205-258, 1993.

....Pattern is not able to keep track of a finite number of possible functors for a given index. Hence, we have to keep all incompatible abstract sequences separately until the procedure has been fully executed. No such treatment would be necessary if a more expressive type domain (e.g. type graphs [9]) would be used. 6 Implementation of the Abstract Operations We now turn to the definition of the abstract operations on abstract sequences. For space reasons, we only consider a subset of the operations, in particular, unification, upper bound, widening, cut, and the concatenation operation. ....

....improved by introducing a priori knowledge about termination [1] or by introducing symbolic values in the abstract domain to replace the postfixpoint computation by a mathematical induction argument. Second, sure success information can be improved by using a more sophisticated type domain (e.g. [9]) Finally, the mode analysis can be improved by generalizing the domain to preserve all abstract substitutions which surely succeed and an additional one to represent all remaining cases as suggested in [12] The tradeoff accuracy efficiency of these extensions need to be studied carefully. 13 ....

G. Janssens and M. Bruynooghe. Deriving Description of Possible Values of Program Variables by Means of Abstract Interpretation. Journal of Logic Programming, 13(2-3):205--258, 1992.

....of the implemented systems infer predicate types nor deal with higher order predicates in a complete way. Type inference is performed by several abstract interpretation frameworks: without an attempt to cover literature completely, we mention [Hentenryck et al. 1995; Gallagher and de Waal, 1994; Janssens and Bruynooghe, 1992]. However, in these frameworks the type definitions themselves are derived from the program clauses. We assume given type definitions and we check and or infer predicate typings using only these type declarations: in this respect, our work is closer to [Codish and Demoen, 1994] which also assumes ....

Janssens, G. and Bruynooghe, M. (1992). Deriving descriptions of possible values of program variables by means of abstract interpretation. Journal of Logic Programming, 13:205--258.

....such as modes and sharing. A type inference system based on this approach was developed by Heintze [8] and the experimental results (on programs up to 32 clauses) indicate that there is hope to make this approach practical. Another line of research is the approach of Bruynooghe and Janssens (e.g. [2, 10]) which is based on a traditional abstract interpretation approach [4] The key idea is to approximate a collecting semantics of the language by an abstract semantics where sets of substitutions are described by type graphs, i.e. disjunctive rational trees. A fixpoint algorithm is then used to ....

....analyses as required by applications such as compile time garbage collection [17] The drawback is that the result of the analysis is more difficult to characterize formally as the design of the abstract domain is an experimental endeavour. This approach has been implemented in a prototype system [10] but experimental results have only been reported on very small programs and were not very encouraging. Hence the practicability of this approach remains open. Note also that the two approaches, which use fundamentally different algorithms, are not directly comparable in accuracy, since the ....

[Article contains additional citation context not shown here]

G. Janssens and M. Bruynooghe. Deriving Description of Possible Values of Program Variables by Means of Abstract Interpretation. Journal of Logic Programming, 13(2-3):205--258, 1992.

.... to the type checking procedure for arbitrary types) and path closure abstraction (related to the type checking procedure for discriminative types) These properties, that we collect in Section 2, are of general interest; in particular, the abstraction by path closure keeps reappearing (see, e.g. [27, 26, 31, 19, 20]) Furthermore, we establish that the directional types of a program P are exactly the models of an associated logic program P I nOut . In fact, P I nOut is a kind of magic set transformation (see, e.g. 20] of P . We obtain our results (and the soundness and completeness results in [1] by ....

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables. Journal of Logic Programming, 13(2-3):205--258, 1992.

.... for logic programs, such as the original one in Bruynooghe s seminal work [3] are based on explicitly building an abstract version of the and or tree which contains a di erent or node for each di erent call substitution c i to a predicate p j which has been detected during analysis [43, 30]. This has the advantage that, while not directly represented in AO(P; p; D ) it is quite straightforward to derive a fully multiply specialized program (i.e. with all possible versions) from such graph and the original program. The arcs in AO(P; p; D ) allow determining at compiletime ....

G. Janssens and M. Bruynooghe. Deriving Descriptions of Possible Values of Program Variables by means of Abstract Interpretation. Journal of Logic Programming, 13(2 and 3):205-258, July 1992.

....of regular sets of words, which are nitely representable by nite word automata. The basic idea of the approach is to over approximate the least model of a given program by a regular set. This approach can be found in particular in [29, 35, 25, 19, 16, 26, 21, 17] Also a type graph approach of [28, 27] is closely related to regular types, since a type graph may be seen as a deterministic top down tree automaton. The approximation of the least model of the program by a regular set is often not as precise as one would expect. A typical example here is a clause append( L; L) Most of the ....

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. Journal of Logic Programming, 13(2-3):205-258, July 1992.

....types to terms. A ground type language does not allow one to handle type dependencies [4] This is the case of [14,18] Some type dependencies among di erent arguments of a procedure can be expressed using type variables in the type language. This is a standard solution, used for instance in [3,13,19,6]. The same solution is used in the framework of regular approximations of the success set in [11] However, the use of type variables does not allow one to express all type dependencies between argument positions. 5] is the only example of an analysis which explicitly expresses type ....

G. Janssens and M. Bruynooghe. Deriving Descriptions of Possible Values of Program Variables by means of Abstract Interpretation. Journal of Logic Programming, 13(2 & 3):205-258, 1992.

No context found.

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. Journal of Logic Programming, 13(2-3):205--258, 1992.

....that overcomes these problems has been presented in [11] considering so called typed norms. The general idea is to derive for every argument position of each atom in the program an approximation of the set of terms that can occur in that position (expressed through the formalism of rigid types [15]) and to construct a particular norm for each such set. For the above example, 11] would derive that the second argument of flat 2 contains a list of any values, whereas the rst argument may contain a list of which the elements are again lists of any values. Accordingly, it would derive exactly ....

Gerda Janssens and Maurice Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. J. Logic programming, 13(2&3):205-258, 1992.

....A feature distinguishing our work from the other type based approaches is that we have an analysis for polymorphic types which eliminates the need to analyze a polymorphic predicate for each distinct type instance under which it is called. Type information can be derived by analysis, as e.g. in [18, 15]; specified by the user and verified by analysis as possible in Prolog systems such as Ciao [16] or declared and considered part of the semantics of the program as with strongly typed languages such as Godel [17] Mercury [28] and HAL [13] The analysis as worked out in this paper is for strongly ....

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. J. Logic programming, 13(2&3):205--258, 1992.

....A feature distinguishing our work from the other type based approaches is that we have an analysis for polymorphic types which eliminates the need to analyze a polymorphic predicate for each distinct type instance under which it is called. Type information can be derived by analysis, as e.g. in [18, 15]; specified by the user and verified by analysis as possible in Prolog systems such as Ciao [16] or declared and considered part of the semantics of the program as with strongly typed languages such as Godel [17] Mercury [28] and HAL [13] The analysis as worked out in this paper is for strongly ....

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. J. Logic programming, 13(2&3):205--258, 1992.

....Le Charlier and Van Hentenryck 1994; Muthukumar and Hermenegildo 1992; Van Roy and Despain 1992; Warren et al. 1988] Thus, it is natural to expect that this technique should also be useful in the context of CLP. A few general frameworks have already been defined for this purpose [Bruynooghe and Janssens 1992; Codognet and Fil e 1992; Giacobazzi et al. 1993; Marriott and Sndergaard 1990] However, one common characteristic of these frameworks is that they are either not implementation oriented or depart from the approaches that have been so far quite successful in the analysis of traditional logic ....

....and show that abstract interpretation is simply another instance of the general framework which safely approximates the instance given by the concrete constraint system. Also, their work is in fairly general terms and does not offer much to the application developer. Finally, Bruynooghe and Janssens [1992] present a specialized framework (which was developed in parallel with the proposal presented in this article) which is based on the idea of adding complexity to the framework with the potential benefit of decreased complexity in the abstract domain. This is done by incorporating a local form of ....

[Article contains additional citation context not shown here]

Janssens, G. and Bruynooghe, M. 1992. Deriving descriptions of possible values of program variables by means of abstract interpretation. J. Logic Program. 13, 2 -- 3 (July), 205--258.

No context found.

Janssens, G. and M. Bruynooghe: 1992, `Deriving Descriptions of Possible Values of Program Variables by Means of Abstract Interpretation'. Journal of Logic Programming 13#2-3#, 205#258.

No context found.

G. Janssen and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. J. Log. Program., 13(2&3):205--258, 1992.

No context found.

Janssens, G. and Bruynooghe, M. 1993. Deriving Descriptions of Possible Value of Program Variables by means of Abstract Interpretation. Journal of Logic Programming 13, 205--258.

No context found.

G. Janssen and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. J. Log. Program., 13(2&3):205--258, 1992.

No context found.

G. Janssens and M. Bruynooghe. Deriving Descriptions of Possible Values of Program Variables by means of Abstract Interpretation. Journal of Logic Programming, 13(2 & 3):205-258, 1992.

No context found.

G. Janssens and M. Bruynooghe. Deriving Descriptions of Possible Values of Program Variables by means of Abstract Interpretation. Journal of Logic Programming, 13(2 and 3):205--258, July 1992.

No context found.

G. Janssens and M. Bruynooghe. Deriving Descriptions of Possible Values of Program Variables by means of Abstract Interpretation. Journal of Logic Programming, 13(2 and 3):205-258, July 1992.

No context found.

Gerda Janssens and Maurice Bruynooghe. Deriving descriptions of possible value of program variables by means of abstract interpretation. Journal of Logic Programming, 13(2 & 3): 205--258, 1992.

No context found.

G. Janssens, M. Bruynooghe, Deriving descriptions of possible values of program variables by means of abstract interpretation, Journal of Logic Programming 13 (2&3) (1992) 205--258.

No context found.

G. Janssens, M. Bruynooghe, Deriving descriptions of possible values of program variables by means of abstract interpretation, Journal of Logic Programming 13 (2&3) (1992) 205--258.

No context found.

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. The Journal of Logic Programming, 13(2 & 3):205-258, 1992.

No context found.

G. Janssens, M. Bruynooghe, Deriving descriptions of possible values of program variables by means of abstract interpretation, Journal of Logic Programming 13 (2&3) (1992) 205--258.

No context found.

G. Janssens, M. Bruynooghe, Deriving descriptions of possible values of program variables by means of abstract interpretation, Journal of Logic Programming 13 (2&3) (1992) 205--258.

No context found.

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. J. Logic Programming, 13(2&3):205--258, July 1992.

No context found.

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. Journal of Logic Programming, 13(2&3):205--258, July 1992.

No context found.

G. Janssens and Maurice Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. Journal of Logic Programming, 13(2, 3):205--258, July 1992.

No context found.

Gerda Janssens and Maurice Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. Journal of logic programming, 13(2&3):205-258, July 1992.

No context found.

G. Janssens and M. Bruynooghe. Deriving descriptions of possible values of program variables by means of abstract interpretation. Journal of Logic Programming, 13(2-3):205--258, July 1992.

First 50 documents  Next 50

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC