Results 1 - 10
of
10
The Design Space of Type Checkers for XML Transformation Languages
, 2004
"... We survey work on statically type checking XML transformations, covering a wide range of notations and ambitions. The concept of type may vary from idealizations of DTD to full-blown XML Schema or even more expressive formalisms. The notion of transformation may vary from clean and simple transd ..."
Abstract
-
Cited by 32 (5 self)
- Add to MetaCart
We survey work on statically type checking XML transformations, covering a wide range of notations and ambitions. The concept of type may vary from idealizations of DTD to full-blown XML Schema or even more expressive formalisms. The notion of transformation may vary from clean and simple transductions to domain-specific languages or integration of XML in general-purpose programming languages. Type annotations can be either explicit or implicit, and type checking ranges from exact decidability to pragmatic approximations. We characterize
The Xtatic experience
- University of Pennsylvania
, 2005
"... Xtatic is a lightweight extension of C ♯ with native support for statically typed XML processing. It features XML trees as built-in values, a refined type system based on regular types in the style of XDuce, and “tree grep”-style regular patterns for traversing and manipulating XML. Previous papers ..."
Abstract
-
Cited by 22 (6 self)
- Add to MetaCart
Xtatic is a lightweight extension of C ♯ with native support for statically typed XML processing. It features XML trees as built-in values, a refined type system based on regular types in the style of XDuce, and “tree grep”-style regular patterns for traversing and manipulating XML. Previous papers on Xtatic have reported results on a number of specific technical issues: basic theoretical properties of an idealized core language, novel compilation algorithms for regular pattern matching, and efficient runtime support for XML processing in the style encouraged by Xtatic. The aim of the present paper is to discuss Xtatic—less formally and more holistically—from the perspective of language design. We survey the most significant issues we faced in the design process and evaluate the choices we have made in addressing them. <person> <name>Haruo Hosoya</name>
Regular Tree Language Recognition with Static Information
, 2004
"... This paper presents our compilation strategy to produce efficient code for pattern matching in the CDuce compiler, taking into account static information provided by the type system. Indeed, this information allows in many cases to compute the result (that is, to decide which branch to consider) by ..."
Abstract
-
Cited by 19 (1 self)
- Add to MetaCart
This paper presents our compilation strategy to produce efficient code for pattern matching in the CDuce compiler, taking into account static information provided by the type system. Indeed, this information allows in many cases to compute the result (that is, to decide which branch to consider) by looking only at a small fragment of the tree. Formally, we introduce a new kind of deterministic tree automata that can efficiently recognize regular tree languages with static information about the trees and we propose a compilation algorithm to produce these automata.
Type-based optimization for regular patterns
- In First International Workshop on High Performance XML Processing
, 2005
"... Pattern matching mechanisms based on regular tree expressions feature in a number of recent languages for processing XML. The flexibility of these mechanisms demands novel approaches to the familiar problems of pattern-match compilation—how to minimize the number of tests performed during matching w ..."
Abstract
-
Cited by 19 (4 self)
- Add to MetaCart
Pattern matching mechanisms based on regular tree expressions feature in a number of recent languages for processing XML. The flexibility of these mechanisms demands novel approaches to the familiar problems of pattern-match compilation—how to minimize the number of tests performed during matching while keeping the size of the output code small. We describe semantic compilation methods in which we use the schema of the value flowing into a pattern matching expression to generate efficient target code. We start by discussing a pragmatic algorithm used currently in the compiler of Xtatic and report some preliminary performance results. For a more fundamental analysis, we define an optimality criterion of “no useless tests ” and show that it is not satisfied by Xtatic’s algorithm. We constructively demonstrate that the problem of generating optimal pattern matching code is decidable for finite (non-recursive) patterns. 1
XML goes native: Run-time representations for Xtatic
- In 14th International Conference on Compiler Construction
, 2004
"... Abstract. Xtatic is a lightweight extension of C ♯ offering native support for statically typed XML processing. XML trees are built-in values in Xtatic, and static analysis of the trees manipulated by programs is part of the ordinary job of the typechecker. “Tree grep ” pattern matching is used to i ..."
Abstract
-
Cited by 15 (6 self)
- Add to MetaCart
Abstract. Xtatic is a lightweight extension of C ♯ offering native support for statically typed XML processing. XML trees are built-in values in Xtatic, and static analysis of the trees manipulated by programs is part of the ordinary job of the typechecker. “Tree grep ” pattern matching is used to investigate and transform XML trees. Xtatic’s surface syntax and type system are tightly integrated with those of C ♯. Beneath the hood, however, an implementation of Xtatic must address a number of issues common to any language supporting a declarative style of XML processing (e.g., XQuery, XSLT, XDuce, CDuce, Xact, Xen, etc.). In particular, it must provide representations for XML tags, trees, and textual data that use memory efficiently, support efficient pattern matching, allow maximal sharing of common substructures, and permit separate compilation. We analyze these representation choices in detail and describe the solutions used by the Xtatic compiler. 1
Polymorphic Regular Tree Types and Patterns
, 2006
"... We propose a type system based on regular tree grammars, where algebraic datatypes are interpreted in a structural way. Thus, the same constructors can be reused for different types and a flexible subtyping relation can be defined between types, corresponding to the inclusion of their semantics. For ..."
Abstract
-
Cited by 14 (1 self)
- Add to MetaCart
We propose a type system based on regular tree grammars, where algebraic datatypes are interpreted in a structural way. Thus, the same constructors can be reused for different types and a flexible subtyping relation can be defined between types, corresponding to the inclusion of their semantics. For instance, one can define a type for lists and a subtype of this type corresponding to lists of even length. Patterns are simply types annotated with binders. This provides a generalization of algebraic patterns with the ability of matching arbitrarily deep in a value. Our main contribution, compared to languages such as XDuce and CDuce, is that we are able to deal with both polymorphism and function types.
Greedy regular expression matching
- Proc. of ICALP’04
, 2004
"... This paper studies the problem of matching sequences against regular expressions in order to produce structured values. ..."
Abstract
-
Cited by 10 (0 self)
- Add to MetaCart
This paper studies the problem of matching sequences against regular expressions in order to produce structured values.
Statically typed document transformation: An Xtatic experience
- BRICS, Department of Computer Science, University of Aarhus
, 2006
"... XTATIC is a lightweight extension of C ♯ with native support for statically typed XML processing. It features XML trees as built-in values, a refined type system based on regular types à la XDUCE, and regular patterns for investigating and manipulating XML. We describe our experiences using XTATIC i ..."
Abstract
-
Cited by 6 (0 self)
- Add to MetaCart
XTATIC is a lightweight extension of C ♯ with native support for statically typed XML processing. It features XML trees as built-in values, a refined type system based on regular types à la XDUCE, and regular patterns for investigating and manipulating XML. We describe our experiences using XTATIC in a real-world application: a program for transforming XMLSPEC, a format used for authoring W3C technical reports, into HTML. Our implementation closely follows an existing one written in XSLT, facilitating comparison of the two languages and analysis of the costs and benefits—both significant—of rich static typing for XML-intensive code.
Compiling Regular Patterns to Sequential Machines
, 2004
"... this paper, we will give a formal model of the shortest match and derive our algorithms from it. This model is based on the metaphor that binding to a variable can be seen as tagging parts of the input with the variable to which they are bound. Let us agree on writing xa for appending input element ..."
Abstract
- Add to MetaCart
this paper, we will give a formal model of the shortest match and derive our algorithms from it. This model is based on the metaphor that binding to a variable can be seen as tagging parts of the input with the variable to which they are bound. Let us agree on writing xa for appending input element a to variable x.Thenmatching "From : jj@foo.net\n ..." against the email pattern above to yield the substitution {x ## "jj@foo.net"} is conceptually the same as transforming the input string to " From : x j x j x @ x f x o x o x . x n x e x t\n ..."
XPath Whole Query Optimization
"... Previous work reports about SXSI, a fast XPath engine which executes tree automata over compressed XML indexes. Here, reasons are investigated why SXSI is so fast. It is shown that tree automata can be used as a general framework for fine grained XML query optimization. We define the “relevant nodes ..."
Abstract
- Add to MetaCart
Previous work reports about SXSI, a fast XPath engine which executes tree automata over compressed XML indexes. Here, reasons are investigated why SXSI is so fast. It is shown that tree automata can be used as a general framework for fine grained XML query optimization. We define the “relevant nodes ” of a query as those nodes that a minimal automaton must touch in order to answer the query. This notion allows to skip many subtrees during execution, and, with the help of particular tree indexes, even allows to skip internal nodes of the tree. We efficiently approximate runs over relevant nodes by means of on-the-fly removal of alternation and non-determinism of (alternating) tree automata. We also introduce many implementation techniques which allows us to efficiently evaluate tree automata, even in the absence of special indexes. Through extensive experiments, we demonstrate the impact of the different optimization techniques. 1.

