+-- Stability : experimental
+-- Portability : portable
+--
+-- CVS : $Id: XMLScanner.hs,v 1.9 2002/10/12 01:58:59 joe Exp $
+--
+----------------------------------------------------------------------------
+--
+-- 9 Jan 2000
+--
+
+-- doesn't check as many errors as it ought to...
+
+module XMLScanner
+ ( Delimiter(..)
+ , pcdataMode, markupMode
+ , isNMCHAR, isSEPCHAR
+ , expandReferences
+ ) where
+
+import XML -- for "Name"
+import Char
+
+import qualified DTD
+
+isSEPCHAR, isNMCHAR, isNMSTART :: Char -> Bool
+
+isSEPCHAR = isSpace
+isNMCHAR c = isAlphaNum c || c `elem` ".-_:" -- 2.3 prodn 4
+--isNMSTART c = isAlpha c || c `elem` "_:" -- 2.3 prodn 5
+isNMSTART c = isAlphaNum c || c `elem` "_:" -- for NUTOKEN, NMTOKEN attvals
+
+-- Utility:
+--
+-- doSpan pred k f g s = k (f x) (g y) where (x,y) = span pred s
+--
+doSpan :: (a -> Bool) -> (b -> c -> d) -> ([a] -> b) -> ([a] -> c) -> [a] -> d
+doSpan pred k f g = sp f where
+ sp f' [] = k (f' []) (g [])
+ sp f' s@(c:cs)
+ | pred c = sp (f' . (c:)) cs
+ | otherwise = k (f' []) (g s)
+
+drop1 :: [a] -> [a] -- drop1 == drop 1; safe version of tail
+drop1 [] = []
+drop1 (_:xs) = xs
+
+data Delimiter =
+ -- character data mode:
+ WS String -- whitespace
+ | CDATA String -- character data
+ | GEREF Name -- general entity reference
+ | STAGO -- start tag open, "<"
+ | ETAGO -- end tag open, "" (">" in SGML)
+
+ -- Errors:
+ | LEXERR String -- lexical error
+ | REST String -- rest of input
+
+ -- Markup mode:
+ | NAME Name -- name
+ | RNINAME Name -- name prefixed with RNI (#)
+ | PEREF Name -- parameter entity reference
+ | LITERAL String -- attribute value literal or parameter literal
+
+ | TAGC -- tag close, ">"
+ | VI -- value indicator, "="
+ | EETAGC -- empty element tag close (XML), "/>"
+
+ | MDC -- markup declaration close, ">"
+ | DSO -- declaration subset open, "["
+ | DSC -- declaration subset close, "]"
+ | MSC -- DSC+MDC, delimiter-in-context, "]]>"
+ | COM -- comment, "--"
+ | GRPO -- group open, "("
+ | GRPC -- group close, ")"
+ | AND -- and connector, "&"
+ | OR -- or connector, "|"
+ | SEQ -- seq connector, ","
+ | OPT -- opt occurrence indicator, "?"
+ | REP -- rep occurrence indicator, "*"
+ | PLUS -- plus occurrence indicator, inclusion, "+"
+ | MINUS -- exclusion, omission flag, "-"
+ | PERO -- parameter entity reference open, "%"
+ -- ALSO:
+ -- Shortref -- short reference string (SGML only)
+ -- NET -- null end-tag (SGML only)
+ -- RNI -- reserved name indicator, "#"
+ -- LIT -- literal, """
+ -- LITA -- alternative literal, "'"
+ -- CRO -- character reference open, "&#"
+ -- HCRO -- hex character reference open, "&#X" (new in XML)
+ -- ERO -- entity reference open, "&"
+ -- REFC -- reference close, ";"
+ deriving (Eq, Show)
+
+pcdataMode, tagMode, markupMode :: String -> [Delimiter]
+
+-- [STAGO, ETAGO, NET, CRO, ERO, MDO, MDOCOM, MDODSO, PIO, MSC]
+pcdataMode [] = []
+pcdataMode ('<':s) = case s of
+ '!':'-':'-':r -> MDOCOM : comMode pcdataMode r
+ '!':'[':r -> {- MDODSO : -} msMode r
+ '!':r -> MDO : markupMode r
+ '/':r -> ETAGO : tagMode r
+ '?':r -> PIO : piMode pcdataMode r
+ ']':']':'>':r -> MSC : pcdataMode r
+ r -> STAGO : tagMode r
+pcdataMode ('&':'#':s) = doSpan (';'/=) (:) mkCREF (pcdataMode . drop1) s
+ where mkCREF = CDATA . return . chr . stringToInt 10
+pcdataMode ('&':s) =
+ case span isNMCHAR s of
+ (ename,';':r) -> GEREF ename : pcdataMode r
+ (junk,r) -> LEXERR ("Bad entity reference " ++ junk)
+ : pcdataMode r
+pcdataMode ('>':r) = LEXERR "Warning: %%% SKIPPING UNESCAPED '>'":pcdataMode r
+pcdataMode (c:s)
+ | isSEPCHAR c = doSpan isSEPCHAR (:) (WS . (c:)) pcdataMode s
+ | otherwise = doSpan isDATACHAR (:) (CDATA . (c:)) pcdataMode s
+ where isDATACHAR ch =
+ case ch of '<' -> False; '&' ->False; _ -> True
+
+tagMode [] = []
+tagMode ('/':'>':r) = EETAGC : pcdataMode r
+tagMode ('>':r) = TAGC : pcdataMode r
+tagMode ('=':r) = VI : tagMode r
+tagMode ('"':r) = doSpan ('"'/=) (:) LITERAL (tagMode . drop1) r
+tagMode ('\'':r) = doSpan ('\''/=) (:) LITERAL (tagMode . drop1) r
+tagMode ('<':'/':r) = ETAGO : tagMode r -- not allowed in XML
+tagMode ('<':r) = STAGO : tagMode r -- not allowed in XML
+tagMode cs@(c:s)
+ | isSEPCHAR c = tagMode (dropWhile isSEPCHAR s)
+ | isNMSTART c = doSpan isNMCHAR (:) NAME tagMode cs
+ | otherwise = LEXERR [c] : tagMode s
+
+
+-- [ERO, CRO, HCRO]
+expandReferences :: DTD.EntityMap -> String -> String
+expandReferences entities = expand where
+ expand s = case s of
+ [] -> []
+ '&':'#':'X':r -> doCharRef 16 expand r
+ '&':'#':r -> doCharRef 10 expand r
+ '&':r -> doEntityRef entities expand r
+ x:r -> x : expand r
+
+doCharRef :: Int -> (String -> String) -> [Char] -> [Char]
+doCharRef base k = doSpan (';'/=) (:) (chr . stringToInt base) (k . drop1)
+stringToInt :: Int -> String -> Int
+stringToInt base = foldl digit 0 . map digitToInt
+ where digit num next = base*num + next
+
+-- @@@ This is not quite right: should rescan the replacement text.
+doEntityRef :: DTD.EntityMap -> (String -> String) -> String -> String
+doEntityRef entities k r = doSpan (';'/=) (++) replacement (k . drop1) r where
+ replacement ename = case DTD.expandInternalEntity entities ename of
+ Just s -> s
+ _ -> error ("entity " ++ ename ++ " not defined")
+
+-- [...]
+markupMode [] = []
+markupMode ('%':s) = case span isNMCHAR s of
+ ([], ' ':r) -> PERO : markupMode r -- %%% Not Quite Right
+ (ename,';':r) -> PEREF ename : markupMode r
+ (ename,r) -> LEXERR ("Bad parameter entity reference %" ++ ename)
+ : markupMode r
+markupMode ('-':'-':r) = eatComment r
+markupMode ('>':r) = MDC : markupMode r -- %%% or pcdataMode?
+markupMode ('"':r) = doSpan ('"'/=) (:) LITERAL (markupMode . drop1) r
+markupMode ('\'':r) = doSpan ('\''/=) (:) LITERAL (markupMode . drop1) r
+markupMode ('#':r) = doSpan isNMCHAR (:) (RNINAME . ('#':)) markupMode r
+markupMode ('<':'!':'-':'-':r)
+ = MDOCOM : comMode markupMode r
+markupMode ('<':'!':r) = MDO : markupMode r
+markupMode ('<':'?':r) = PIO : piMode markupMode r
+markupMode s@('<':_) = pcdataMode s -- %%% Not strictly correct, but
+ -- %%% needed to parse the prolog.
+markupMode cs@(c:s)
+ | isSEPCHAR c = markupMode (dropWhile isSEPCHAR s)
+ | isNMSTART c = doSpan isNMCHAR (:) NAME markupMode cs
+ | otherwise = (case c of
+ '&' -> AND
+ '|' -> OR
+ ',' -> SEQ
+ '?' -> OPT
+ '*' -> REP
+ '+' -> PLUS
+ '-' -> MINUS
+ '[' -> DSO
+ ']' -> DSC
+ '(' -> GRPO
+ ')' -> GRPC
+ _ -> LEXERR [c]) : markupMode s
+
+--
+-- Internal recognition modes:
+--
+
+msMode, cdataMode, eatComment :: String -> [Delimiter]
+
+piMode, comMode, cdMode :: (String -> [Delimiter]) -> String -> [Delimiter]
+
+--
+-- msMode: marked section in instance.
+-- @@@ Only supports XML instance syntax ();
+-- In SGML (and XML DTDs), parameter entity references and whitespace
+-- are also allowed, in addition to INCLUDE and IGNORE keywords.
+-- 'cdataMode' checks for nested occurrences of ':rest) = pcdataMode rest
+cdataMode ('<':'!':'[':rest) = error "Nested []
+ '-':'-':r -> COM : cdMode prevMode r
+ (c:s) -> doSpan brk (:) (CDATA . (c:)) (comMode prevMode) s where
+ brk '-' = False
+ brk '\n' = False -- split long comments at line breaks
+ brk _ = True
+
+-- cdMode (inside comment declarations): [COM,MDC, ignore whitespace]
+cdMode prevMode cs = case cs of
+ [] -> []
+ '>':r -> MDC : prevMode r
+ '-':'-':r -> COM : comMode prevMode r
+ c:s -> if isSEPCHAR c
+ then cdMode prevMode (dropWhile isSEPCHAR s)
+ else LEXERR [c] : cdMode prevMode s
+
+eatComment cs = case cs of
+ [] -> []
+ '-':'-':r -> markupMode r
+ (_:r) -> eatComment r
+
+piMode prevMode cs = case cs of
+ [] -> []
+ '?':'>':r -> PIC : prevMode r
+ (c:s) -> doSpan ('?'/=) (:) (CDATA . (c:)) (piMode prevMode) s
+
+-- EOF --
diff --git a/index.html b/index.html
new file mode 100644
--- /dev/null
+++ b/index.html
@@ -0,0 +1,105 @@
+
+HXQ: A Compiler from XQuery to Haskell
+
+
+HXQ: A Compiler from XQuery to Haskell
+
+
+
Description
+
+HXQ is a fast and space-efficient translator from XQuery to
+embedded Haskell code (the translation is based on GHC templates).
+It takes full advantage
+of Haskell's lazy evaluation to keep in memory only those parts of XML data
+needed at each point of evaluation, thus performing stream-based evaluation.
+This results to an implementation that is as fast and space-efficient as
+any stream-based
+implementation based on SAX filters or finite state machines. Furthermore,
+the coding is far simpler and extensible since its based on XML trees, rather
+than SAX events (both the code generator and the the XQuery parser are about 400 lines each).
+For example, the XQuery below against the DBLP XML database
+(420MB) runs in 1.5 minutes on my laptop.
+My high-performance Java implementation of XQuery, called XQPull,
+which is stream-based (based on a StAX events), took about the same time.
+
+
Installation Instructions
+
+If you haven't done so, install the Glasgow Haskell Compiler,
+ghc,
+and the parser generator for Haskell,
+happy.
+For example, in Fedora Linux, you install both using:
+
+yum install ghc happy
+
+Then download HXQ and untar it.
+You can either use cabal or make to build it. Then run xquery to test drive it.
+
+
Current Status
+
+HXQ supports most essential XQuery features, although some system functions are missing (but are easy to add).
+It does not have static typechecking; it leaves all checking to Haskell. This means that it distinguishes regular predicates
+from indexing at run time: if an XPath predicate returns an integer at run time, it is indexing and this index is
+checked against the current node position. The most important omission is backward step axes, such as /.. (parent).
+Some, but not all, parent axis steps are removed using optimization rules, all others cause a compilation error.
+
+
Use
+
+HXQ represents XML data as rose trees:
+
+type Tag = String
+
+type AttList = [(String,String)]
+
+data XTree = XElem Tag AttList [XTree]
+ | XText String
+ | XInt Int
+ | XFloat Float
+
+type XSeq = [XTree]
+
+which basically means that one cannot implement backward navigation steps directly.
+The main functions for embedding XQueries in Haskell are:
+
+- $(xe query)
+
- $(xq query)
+
+where query is a string value (a Haskell expression that evaluates
+to a string at compile-time), They both translate the query into Haskell
+code, which is compiled and optimized into machine code directly. The code that xe generates has type XSeq (a sequence of XML trees)
+while the code that xq generates has type (IO XSeq). If the query reads
+at least one document (using doc(...)), then you should use xq since it requires
+IO. To define constant XML data or a function body, it is better to use xe.
+You can use the value of a Haskell variable v inside a query using
+$v as long as v has type XSeq.
+To use a function in a query, it should be defined in Haskell
+with type (XSeq,...,XSeq) -> XSeq.
+
+Here is an example of a main program:
+
+f(x,y) = $(xe "<article><first>{$x}</first><second>{$y}</second></article>")
+
+main = do a <- $(xq ("<result>{ "
+ ++" for $x in doc('data/dblp.xml')//inproceedings at $i "
+ ++" where $x/author = 'Leonidas Fegaras' "
+ ++" orderby $x/year descending "
+ ++" return <paper>{ $i, ') ', $x/booktitle/text(), "
+ ++" ': ', $x/title/text() "
+ ++" }</paper> "
+ ++" }</result> "))
+ putStrLn (show a)
+ b <- $(xq " f( $a/paper[10], $a/paper[8] ) ")
+ putStrLn (show b)
+
+Another example, can be found in Main.hs.
+
+If you want to extend HXQ, you need to read about Template Haskell.
+Use make test to do various translation tests in ghci. You can look at the
+Abstract Syntax Trees and the generated code from a query by evaluating
+cq query. Basically, the way you generate Haskell code is
+similar to operational semantics (where [| ... |] are syntactic brackets).
+
+
+
+
+
Last modified: 03/18/08 by Leonidas Fegaras