IO.hs

-- GENERATED by C->Haskell Compiler, version 0.15.1 Rainy Days, 31 Aug 2007 (Haskell)
-- Edit the ORIGNAL .chs file instead!


{-# LINE 1 "IO.chs" #-}-- hexpat, a Haskell wrapper for expat
-- Copyright (C) 2008 Evan Martin <martine@danga.com>

-- |This module wraps the Expat API directly, with IO.

module Text.XML.Expat.IO (
  -- ** Parser Setup
  Parser, newParser,

  -- ** Parsing
  parse,

  -- ** Parser Callbacks
  StartElementHandler, EndElementHandler, CharacterDataHandler,
  setStartElementHandler, setEndElementHandler, setCharacterDataHandler
) where

import C2HS


-- Expat functions start with "XML", but C2HS appears to ignore our "as"
-- definitions if they only differ from the symbol in case.  So we write out
-- XML_* in most cases anyway...  :(

{-# LINE 25 "IO.chs" #-}

-- |Opaque parser type.
type ParserPtr = Ptr ()
newtype Parser = Parser (ForeignPtr ())

withParser :: Parser -> (ParserPtr -> IO a) -> IO a
withParser (Parser fp) = withForeignPtr fp

withOptCString :: Maybe String -> (CString -> IO a) -> IO a
withOptCString Nothing    f = f nullPtr
withOptCString (Just str) f = withCString str f

parserCreate :: Maybe String -> IO (ParserPtr)
parserCreate a1 =
  withOptCString a1 $ \a1' -> 
  parserCreate'_ a1' >>= \res ->
  let {res' = id res} in
  return (res')
{-# LINE 39 "IO.chs" #-}
foreign import ccall "&XML_ParserFree" parserFree :: FunPtr (ParserPtr -> IO ())

-- |Create a 'Parser'.  The optional parameter is the default character
-- encoding, and can be one of
--
-- - \"US-ASCII\"
--
-- - \"UTF-8\"
--
-- - \"UTF-16\"
--
-- - \"ISO-8859-1\"
newParser :: Maybe String -> IO Parser
newParser enc = do
  ptr <- parserCreate enc
  fptr <- newForeignPtr parserFree ptr
  return $ Parser fptr

unStatus :: CInt -> Bool
unStatus 0 = False
unStatus 1 = True
-- |@parse data False@ feeds mode data into a 'Parser'.  The end of the data
-- is indicated by passing True for the final parameter.  @parse@ returns
-- False on a parse error.
parse :: Parser -> String -> Bool -> IO (Bool)
parse a1 a2 a3 =
  withParser a1 $ \a1' -> 
  withCStringLenIntConv a2 $ \(a2'1, a2'2) -> 
  let {a3' = cFromBool a3} in 
  parse'_ a1' a2'1  a2'2 a3' >>= \res ->
  let {res' = unStatus res} in
  return (res')
{-# LINE 65 "IO.chs" #-}

-- |The type of the \"element started\" callback.  The first parameter is
-- the element name; the second are the (attribute, value) pairs.
type StartElementHandler  = String -> [(String,String)] -> IO ()
-- |The type of the \"element ended\" callback.  The parameter is
-- the element name.
type EndElementHandler    = String -> IO ()
-- |The type of the \"character data\" callback.  The parameter is
-- the character data processed.  This callback may be called more than once
-- while processing a single conceptual block of text.
type CharacterDataHandler = String -> IO ()

type CStartElementHandler = Ptr () -> CString -> Ptr CString -> IO ()
foreign import ccall "wrapper"
  mkCStartElementHandler :: CStartElementHandler
                         -> IO (FunPtr CStartElementHandler)
wrapStartElementHandler :: StartElementHandler
                        -> IO (FunPtr CStartElementHandler)
wrapStartElementHandler handler = mkCStartElementHandler h where
  h ptr cname cattrs = do
    name <- peekCString cname
    cattrlist <- peekArray0 nullPtr cattrs
    attrlist <- mapM peekCString cattrlist
    handler name (pairwise attrlist)
-- |Attach a StartElementHandler to a Parser.
setStartElementHandler :: Parser -> StartElementHandler -> IO ()
setStartElementHandler parser handler = do
  withParser parser $ \p -> do
  handler' <- wrapStartElementHandler handler
  xmlSetstartelementhandler p handler'


type CEndElementHandler = Ptr () -> CString -> IO ()
foreign import ccall "wrapper"
  mkCEndElementHandler :: CEndElementHandler
                       -> IO (FunPtr CEndElementHandler)
wrapEndElementHandler :: EndElementHandler
                      -> IO (FunPtr CEndElementHandler)
wrapEndElementHandler handler = mkCEndElementHandler h where
  h ptr cname = do
    name <- peekCString cname
    handler name
-- |Attach an EndElementHandler to a Parser.
setEndElementHandler :: Parser -> EndElementHandler -> IO ()
setEndElementHandler parser handler = do
  withParser parser $ \p -> do
  handler' <- wrapEndElementHandler handler
  xmlSetendelementhandler p handler'

type CCharacterDataHandler = Ptr () -> CString -> CInt -> IO ()
foreign import ccall "wrapper"
  mkCCharacterDataHandler :: CCharacterDataHandler
                          -> IO (FunPtr CCharacterDataHandler)
wrapCharacterDataHandler :: CharacterDataHandler
                      -> IO (FunPtr CCharacterDataHandler)
wrapCharacterDataHandler handler = mkCCharacterDataHandler h where
  h ptr cdata len = do
    data_ <- peekCStringLen (cdata, fromIntegral len)
    handler data_
-- |Attach an CharacterDataHandler to a Parser.
setCharacterDataHandler :: Parser -> CharacterDataHandler -> IO ()
setCharacterDataHandler parser handler = do
  withParser parser $ \p -> do
  handler' <- wrapCharacterDataHandler handler
  xmlSetcharacterdatahandler p handler'

pairwise (x1:x2:xs) = (x1,x2) : pairwise xs
pairwise []         = []

foreign import ccall unsafe "IO.chs.h XML_ParserCreate"
  parserCreate'_ :: ((Ptr CChar) -> (IO (Ptr ())))

foreign import ccall safe "IO.chs.h XML_Parse"
  parse'_ :: ((Ptr ()) -> ((Ptr CChar) -> (CInt -> (CInt -> (IO CInt)))))

foreign import ccall unsafe "IO.chs.h XML_SetStartElementHandler"
  xmlSetstartelementhandler :: ((Ptr ()) -> ((FunPtr ((Ptr ()) -> ((Ptr CChar) -> ((Ptr (Ptr CChar)) -> (IO ()))))) -> (IO ())))

foreign import ccall unsafe "IO.chs.h XML_SetEndElementHandler"
  xmlSetendelementhandler :: ((Ptr ()) -> ((FunPtr ((Ptr ()) -> ((Ptr CChar) -> (IO ())))) -> (IO ())))

foreign import ccall unsafe "IO.chs.h XML_SetCharacterDataHandler"
  xmlSetcharacterdatahandler :: ((Ptr ()) -> ((FunPtr ((Ptr ()) -> ((Ptr CChar) -> (CInt -> (IO ()))))) -> (IO ())))