    -- |
    -- Module      :  Language.C.Quote
    -- Copyright   :  (c) 2006-2011 Harvard University
    --                (c) 2011-2013 Geoffrey Mainland
    --             :  (c) 2013-2017 Drexel University
    -- License     :  BSD-style
    -- Maintainer  :  mainland@drexel.edu

    {-# LANGUAGE CPP #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE TemplateHaskell #-}
    {-# OPTIONS_GHC -w #-}

    module Language.C.Quote.Base (
        ToIdent(..),
        ToConst(..),
        ToExp(..),
        qqExp,
        qqPat,
        quasiquote
      ) where

    import Control.Monad ((>=>))
    import qualified Data.ByteString.Char8 as B
    import Data.Char (isAscii, isPrint, ord)
    import Data.Data (Data(..))
    import Data.Generics (extQ)
    import Data.Int
    import Data.Loc
    import Data.Typeable (Typeable(..))
    import Data.Word
    #ifdef FULL_HASKELL_ANTIQUOTES
    import Language.Haskell.Meta (parseExp,parsePat)
    #else
    import Language.Haskell.ParseExp (parseExp,parsePat)
    #endif
    import Language.Haskell.TH as TH
    #if MIN_VERSION_template_haskell(2,7,0)
    import Language.Haskell.TH.Quote (QuasiQuoter(..),
                                      dataToQa,
                                      dataToExpQ,
                                      dataToPatQ)
    #else /* !MIN_VERSION_template_haskell(2,7,0) */
    import Language.Haskell.TH.Quote (QuasiQuoter(..))
    #endif /* !MIN_VERSION_template_haskell(2,7,0) */
    import Language.Haskell.TH.Syntax
    import Numeric (showOct, showHex)

    import qualified Language.C.Parser as P
    import qualified Language.C.Syntax as C

    newtype LongDouble = LongDouble Double

    -- | An instance of 'ToIndent' can be converted to a 'C.Id'.
    class ToIdent a where
        toIdent :: a -> SrcLoc -> C.Id

    instance ToIdent C.Id where
        toIdent :: Id -> SrcLoc -> Id
    toIdent Id
    ident SrcLoc
    _ = Id
    ident

    instance ToIdent (SrcLoc -> C.Id) where
        toIdent :: (SrcLoc -> Id) -> SrcLoc -> Id
    toIdent SrcLoc -> Id
    ident = SrcLoc -> Id
    ident

    instance ToIdent String where
        toIdent :: String -> SrcLoc -> Id
    toIdent String
    s SrcLoc
    loc = String -> SrcLoc -> Id
    C.Id String
    s SrcLoc
    loc

    -- | An instance of 'ToConst' can be converted to a 'C.Const'.
    class ToConst a where
        toConst :: a -> SrcLoc -> C.Const

    instance ToConst C.Const where
        toConst :: Const -> SrcLoc -> Const
    toConst Const
    k SrcLoc
    _ = Const
    k

    instance ToConst Int where
        toConst :: Int -> SrcLoc -> Const
    toConst = Integer -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst (Integer -> SrcLoc -> Const)
    -> (Int -> Integer) -> Int -> SrcLoc -> Const
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Integer
    forall a. Integral a => a -> Integer
    toInteger

    instance ToConst Int8 where
        toConst :: Int8 -> SrcLoc -> Const
    toConst = Integer -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst (Integer -> SrcLoc -> Const)
    -> (Int8 -> Integer) -> Int8 -> SrcLoc -> Const
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Integer
    forall a. Integral a => a -> Integer
    toInteger

    instance ToConst Int16 where
        toConst :: Int16 -> SrcLoc -> Const
    toConst = Integer -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst (Integer -> SrcLoc -> Const)
    -> (Int16 -> Integer) -> Int16 -> SrcLoc -> Const
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Integer
    forall a. Integral a => a -> Integer
    toInteger

    instance ToConst Int32 where
        toConst :: Int32 -> SrcLoc -> Const
    toConst = Integer -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst (Integer -> SrcLoc -> Const)
    -> (Int32 -> Integer) -> Int32 -> SrcLoc -> Const
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Integer
    forall a. Integral a => a -> Integer
    toInteger

    instance ToConst Int64 where
        toConst :: Int64 -> SrcLoc -> Const
    toConst = Integer -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst (Integer -> SrcLoc -> Const)
    -> (Int64 -> Integer) -> Int64 -> SrcLoc -> Const
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Integer
    forall a. Integral a => a -> Integer
    toInteger

    instance ToConst Word where
        toConst :: Word -> SrcLoc -> Const
    toConst Word
    n SrcLoc
    loc = String -> Signed -> Integer -> SrcLoc -> Const
    C.IntConst (Word -> String
    forall a. Show a => a -> String
    show Word
    n) Signed
    C.Unsigned (Word -> Integer
    forall a. Integral a => a -> Integer
    toInteger Word
    n) SrcLoc
    loc

    instance ToConst Word8 where
        toConst :: Word8 -> SrcLoc -> Const
    toConst Word8
    n SrcLoc
    loc = String -> Signed -> Integer -> SrcLoc -> Const
    C.IntConst (Word8 -> String
    forall a. Show a => a -> String
    show Word8
    n) Signed
    C.Unsigned (Word8 -> Integer
    forall a. Integral a => a -> Integer
    toInteger Word8
    n) SrcLoc
    loc

    instance ToConst Word16 where
        toConst :: Word16 -> SrcLoc -> Const
    toConst Word16
    n SrcLoc
    loc = String -> Signed -> Integer -> SrcLoc -> Const
    C.IntConst (Word16 -> String
    forall a. Show a => a -> String
    show Word16
    n) Signed
    C.Unsigned (Word16 -> Integer
    forall a. Integral a => a -> Integer
    toInteger Word16
    n) SrcLoc
    loc

    instance ToConst Word32 where
        toConst :: Word32 -> SrcLoc -> Const
    toConst Word32
    n SrcLoc
    loc = String -> Signed -> Integer -> SrcLoc -> Const
    C.IntConst (Word32 -> String
    forall a. Show a => a -> String
    show Word32
    n) Signed
    C.Unsigned (Word32 -> Integer
    forall a. Integral a => a -> Integer
    toInteger Word32
    n) SrcLoc
    loc

    instance ToConst Word64 where
        toConst :: Word64 -> SrcLoc -> Const
    toConst Word64
    n SrcLoc
    loc = String -> Signed -> Integer -> SrcLoc -> Const
    C.IntConst (Word64 -> String
    forall a. Show a => a -> String
    show Word64
    n) Signed
    C.Unsigned (Word64 -> Integer
    forall a. Integral a => a -> Integer
    toInteger Word64
    n) SrcLoc
    loc

    instance ToConst Integer where
        toConst :: Integer -> SrcLoc -> Const
    toConst Integer
    n SrcLoc
    loc = String -> Signed -> Integer -> SrcLoc -> Const
    C.IntConst (Integer -> String
    forall a. Show a => a -> String
    show Integer
    n) Signed
    C.Signed Integer
    n SrcLoc
    loc

    instance ToConst Rational where
        toConst :: Rational -> SrcLoc -> Const
    toConst Rational
    n SrcLoc
    loc = Double -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst (Rational -> Double
    forall a. Fractional a => Rational -> a
    fromRational Rational
    n :: Double) SrcLoc
    loc

    instance ToConst Float where
        toConst :: Float -> SrcLoc -> Const
    toConst Float
    n SrcLoc
    loc = String -> Float -> SrcLoc -> Const
    C.FloatConst (Float -> String
    forall a. (RealFloat a, Show a) => a -> String
    realFloatToString Float
    n String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "F") Float
    n SrcLoc
    loc

    instance ToConst Double where
        toConst :: Double -> SrcLoc -> Const
    toConst Double
    n SrcLoc
    loc = String -> Double -> SrcLoc -> Const
    C.DoubleConst (Double -> String
    forall a. (RealFloat a, Show a) => a -> String
    realFloatToString Double
    n) Double
    n SrcLoc
    loc

    instance ToConst LongDouble where
        toConst :: LongDouble -> SrcLoc -> Const
    toConst (LongDouble Double
    n) SrcLoc
    loc = String -> Double -> SrcLoc -> Const
    C.LongDoubleConst (Double -> String
    forall a. (RealFloat a, Show a) => a -> String
    realFloatToString Double
    n String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "L") Double
    n SrcLoc
    loc

    realFloatToString :: (RealFloat a, Show a) => a -> String
    realFloatToString :: forall a. (RealFloat a, Show a) => a -> String
    realFloatToString a
    n
      | a -> Bool
    forall a. RealFloat a => a -> Bool
    isNaN a
    n      = String
    "NAN"
      | a -> Bool
    forall a. RealFloat a => a -> Bool
    isInfinite a
    n = if a
    n a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    < a
    0 then String
    "-INFINITY" else String
    "INFINITY"
      | Bool
    otherwise    = a -> String
    forall a. Show a => a -> String
    show a
    n

    instance ToConst Char where
        toConst :: Char -> SrcLoc -> Const
    toConst Char
    c SrcLoc
    loc = String -> Char -> SrcLoc -> Const
    C.CharConst (String
    "'" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Char -> String
    charToString Char
    c String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "'") Char
    c SrcLoc
    loc
          where
            charToString :: Char -> String
            charToString :: Char -> String
    charToString Char
    '\0' = String
    "\\0"
            charToString Char
    '\a' = String
    "\\a"
            charToString Char
    '\b' = String
    "\\b"
            charToString Char
    '\f' = String
    "\\f"
            charToString Char
    '\n' = String
    "\\n"
            charToString Char
    '\r' = String
    "\\r"
            charToString Char
    '\t' = String
    "\\t"
            charToString Char
    '\v' = String
    "\\v"
            charToString Char
    '\\' = String
    "\\\\"
            charToString Char
    '\"' = String
    "\\\""
            charToString Char
    c
              | Char -> Bool
    isAscii Char
    c Bool -> Bool -> Bool
    && Char -> Bool
    isPrint Char
    c = [Char
    c]
              | Char -> Bool
    isAscii Char
    c              = String
    "\\x" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Maybe Int -> Char -> String
    hexOf Maybe Int
    forall a. Maybe a
    Nothing Char
    c
              | Char -> Int
    ord Char
    c Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    0x10000        = String
    "\\u" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Maybe Int -> Char -> String
    hexOf (Int -> Maybe Int
    forall a. a -> Maybe a
    Just Int
    4) Char
    c
              | Bool
    otherwise              = String
    "\\U" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Maybe Int -> Char -> String
    hexOf (Int -> Maybe Int
    forall a. a -> Maybe a
    Just Int
    8) Char
    c
              where
                hexOf :: Maybe Int -> Char -> String
                hexOf :: Maybe Int -> Char -> String
    hexOf Maybe Int
    len Char
    c = case Maybe Int
    len of
                                Maybe Int
    Nothing -> String
    hex
                                Just Int
    i  -> Int -> Char -> String
    forall a. Int -> a -> [a]
    replicate (Int
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - String -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length String
    hex) Char
    '0' String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    hex
                  where
                    hex :: String
                    hex :: String
    hex = Int -> String -> String
    forall a. Integral a => a -> String -> String
    showHex (Char -> Int
    ord Char
    c) String
    ""

    instance ToConst String where
        toConst :: String -> SrcLoc -> Const
    toConst String
    s SrcLoc
    loc = [String] -> String -> SrcLoc -> Const
    C.StringConst [String -> String
    forall a. Show a => a -> String
    show String
    s] String
    s SrcLoc
    loc

    -- | An instance of 'ToExp' can be converted to a 'C.Exp'.
    class ToExp a where
        toExp :: a -> SrcLoc -> C.Exp

    instance ToExp C.Exp where
        toExp :: Exp -> SrcLoc -> Exp
    toExp Exp
    e SrcLoc
    _ = Exp
    e

    instance ToExp Int where
        toExp :: Int -> SrcLoc -> Exp
    toExp Int
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Int -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Int
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp Int8 where
        toExp :: Int8 -> SrcLoc -> Exp
    toExp Int8
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Int8 -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Int8
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp Int16 where
        toExp :: Int16 -> SrcLoc -> Exp
    toExp Int16
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Int16 -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Int16
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp Int32 where
        toExp :: Int32 -> SrcLoc -> Exp
    toExp Int32
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Int32 -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Int32
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp Int64 where
        toExp :: Int64 -> SrcLoc -> Exp
    toExp Int64
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Int64 -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Int64
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp Word where
        toExp :: Word -> SrcLoc -> Exp
    toExp Word
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Word -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Word
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp Word8 where
        toExp :: Word8 -> SrcLoc -> Exp
    toExp Word8
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Word8 -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Word8
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp Word16 where
        toExp :: Word16 -> SrcLoc -> Exp
    toExp Word16
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Word16 -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Word16
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp Word32 where
        toExp :: Word32 -> SrcLoc -> Exp
    toExp Word32
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Word32 -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Word32
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp Word64 where
        toExp :: Word64 -> SrcLoc -> Exp
    toExp Word64
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Word64 -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Word64
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp Integer where
        toExp :: Integer -> SrcLoc -> Exp
    toExp Integer
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Integer -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Integer
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp Rational where
        toExp :: Rational -> SrcLoc -> Exp
    toExp Rational
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Rational -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Rational
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp Float where
        toExp :: Float -> SrcLoc -> Exp
    toExp Float
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Float -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Float
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp Double where
        toExp :: Double -> SrcLoc -> Exp
    toExp Double
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Double -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Double
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp Char where
        toExp :: Char -> SrcLoc -> Exp
    toExp Char
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (Char -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst Char
    n SrcLoc
    loc) SrcLoc
    loc

    instance ToExp String where
        toExp :: String -> SrcLoc -> Exp
    toExp String
    n SrcLoc
    loc = Const -> SrcLoc -> Exp
    C.Const (String -> SrcLoc -> Const
    forall a. ToConst a => a -> SrcLoc -> Const
    toConst String
    n SrcLoc
    loc) SrcLoc
    loc

    antiVarE :: String -> ExpQ
    antiVarE :: String -> ExpQ
    antiVarE = (String -> ExpQ) -> (Exp -> ExpQ) -> Either String Exp -> ExpQ
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    either String -> ExpQ
    forall a. String -> Q a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail Exp -> ExpQ
    forall a. a -> Q a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Either String Exp -> ExpQ)
    -> (String -> Either String Exp) -> String -> ExpQ
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> Either String Exp
    parseExp

    qqLocE :: SrcLoc -> ExpQ
    qqLocE :: SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc = (forall b. Data b => b -> Maybe ExpQ) -> SrcLoc -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp SrcLoc
    loc

    qqStringE :: String -> Maybe (Q Exp)
    qqStringE :: String -> Maybe ExpQ
    qqStringE String
    s = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ Lit -> ExpQ
    forall (m :: * -> *). Quote m => Lit -> m Exp
    litE (Lit -> ExpQ) -> Lit -> ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> Lit
    stringL String
    s

    qqIdE :: C.Id -> Maybe (Q Exp)
    qqIdE :: Id -> Maybe ExpQ
    qqIdE (C.AntiId String
    v SrcLoc
    loc)  = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|toIdent $(String -> ExpQ
    antiVarE String
    v) $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]
    qqIdE Id
    _                 = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqDeclSpecE :: C.DeclSpec -> Maybe (Q Exp)
    qqDeclSpecE :: DeclSpec -> Maybe ExpQ
    qqDeclSpecE (C.AntiDeclSpec String
    v SrcLoc
    _) = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    v
    qqDeclSpecE (C.AntiTypeDeclSpec [Storage]
    extraStorage [TypeQual]
    extraTypeQuals String
    v SrcLoc
    _) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|
            case $(String -> ExpQ
    antiVarE String
    v) of
                C.Type (C.DeclSpec storage typeQuals typeSpec loc) _ _ ->
                     C.DeclSpec
                         (storage ++ $((forall b. Data b => b -> Maybe ExpQ) -> [Storage] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [Storage]
    extraStorage))
                         (typeQuals ++ $((forall b. Data b => b -> Maybe ExpQ) -> [TypeQual] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [TypeQual]
    extraTypeQuals))
                         typeSpec
                         loc

                x -> error
                       $ "Impossible happened, expected C.Type (C.DeclSpec {}) but got "
                       ++ show x
             |]
    qqDeclSpecE DeclSpec
    _ = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqDeclE :: C.Decl -> Maybe (Q Exp)
    qqDeclE :: Decl -> Maybe ExpQ
    qqDeclE (C.AntiTypeDecl String
    v SrcLoc
    _) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|
            case $(String -> ExpQ
    antiVarE String
    v) of
                C.Type _ decl _ -> decl
                x -> error
                       $ "Impossible happened, expected C.Type but got "
                       ++ show x
        |]
    qqDeclE Decl
    _ = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqTypeQualE :: C.TypeQual -> Maybe (Q Exp)
    qqTypeQualE :: TypeQual -> Maybe ExpQ
    qqTypeQualE (C.AntiTypeQual String
    v SrcLoc
    _)  = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    v
    qqTypeQualE TypeQual
    _                     = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqTypeQualListE :: [C.TypeQual] -> Maybe (Q Exp)
    qqTypeQualListE :: [TypeQual] -> Maybe ExpQ
    qqTypeQualListE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqTypeQualListE (C.AntiTypeQuals String
    v SrcLoc
    _ : [TypeQual]
    stms) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    v) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [TypeQual] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [TypeQual]
    stms)|]
    qqTypeQualListE (TypeQual
    stm : [TypeQual]
    stms) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> TypeQual -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp TypeQual
    stm) : $((forall b. Data b => b -> Maybe ExpQ) -> [TypeQual] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [TypeQual]
    stms)|]

    qqTypeE :: C.Type -> Maybe (Q Exp)
    qqTypeE :: Type -> Maybe ExpQ
    qqTypeE (C.AntiType String
    v SrcLoc
    _)  = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    v
    qqTypeE Type
    _                 = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqInitializerE :: C.Initializer -> Maybe (Q Exp)
    qqInitializerE :: Initializer -> Maybe ExpQ
    qqInitializerE (C.AntiInit String
    v SrcLoc
    _)  = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    v
    qqInitializerE Initializer
    _                 = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqInitializerListE :: [(Maybe C.Designation, C.Initializer)] -> Maybe (Q Exp)
    qqInitializerListE :: [(Maybe Designation, Initializer)] -> Maybe ExpQ
    qqInitializerListE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqInitializerListE ((Maybe Designation
    Nothing, C.AntiInits String
    v SrcLoc
    _) : [(Maybe Designation, Initializer)]
    fields) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[(Nothing, init) | init <- $(String -> ExpQ
    antiVarE String
    v)] ++ $((forall b. Data b => b -> Maybe ExpQ)
    -> [(Maybe Designation, Initializer)] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [(Maybe Designation, Initializer)]
    fields)|]
    qqInitializerListE ((Maybe Designation, Initializer)
    field : [(Maybe Designation, Initializer)]
    fields) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ)
    -> (Maybe Designation, Initializer) -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp (Maybe Designation, Initializer)
    field) : $((forall b. Data b => b -> Maybe ExpQ)
    -> [(Maybe Designation, Initializer)] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [(Maybe Designation, Initializer)]
    fields)|]

    qqInitGroupE :: C.InitGroup -> Maybe (Q Exp)
    qqInitGroupE :: InitGroup -> Maybe ExpQ
    qqInitGroupE (C.AntiDecl String
    v SrcLoc
    _)  = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    v
    qqInitGroupE InitGroup
    _                 = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqInitGroupListE :: [C.InitGroup] -> Maybe (Q Exp)
    qqInitGroupListE :: [InitGroup] -> Maybe ExpQ
    qqInitGroupListE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqInitGroupListE (C.AntiDecls String
    v SrcLoc
    _ : [InitGroup]
    inits) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    v) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [InitGroup] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [InitGroup]
    inits)|]
    qqInitGroupListE (InitGroup
    ini : [InitGroup]
    inis) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> InitGroup -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp InitGroup
    ini) : $((forall b. Data b => b -> Maybe ExpQ) -> [InitGroup] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [InitGroup]
    inis)|]

    qqAttrE :: C.Attr -> Maybe (Q Exp)
    qqAttrE :: Attr -> Maybe ExpQ
    qqAttrE (C.AntiAttr String
    v SrcLoc
    _)  = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    v
    qqAttrE Attr
    _                 = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqAttrListE :: [C.Attr] -> Maybe (Q Exp)
    qqAttrListE :: [Attr] -> Maybe ExpQ
    qqAttrListE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqAttrListE (C.AntiAttrs String
    v SrcLoc
    _ : [Attr]
    attrs) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    v) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [Attr] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [Attr]
    attrs)|]
    qqAttrListE (Attr
    field : [Attr]
    fields) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> Attr -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp Attr
    field) : $((forall b. Data b => b -> Maybe ExpQ) -> [Attr] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [Attr]
    fields)|]

    qqFieldGroupE :: C.FieldGroup -> Maybe (Q Exp)
    qqFieldGroupE :: FieldGroup -> Maybe ExpQ
    qqFieldGroupE (C.AntiSdecl String
    v SrcLoc
    _)  = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    v
    qqFieldGroupE FieldGroup
    _                  = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqFieldGroupListE :: [C.FieldGroup] -> Maybe (Q Exp)
    qqFieldGroupListE :: [FieldGroup] -> Maybe ExpQ
    qqFieldGroupListE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqFieldGroupListE (C.AntiSdecls String
    v SrcLoc
    _ : [FieldGroup]
    fields) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    v) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [FieldGroup] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [FieldGroup]
    fields)|]
    qqFieldGroupListE (FieldGroup
    field : [FieldGroup]
    fields) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> FieldGroup -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp FieldGroup
    field) : $((forall b. Data b => b -> Maybe ExpQ) -> [FieldGroup] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [FieldGroup]
    fields)|]

    qqCEnumE :: C.CEnum -> Maybe (Q Exp)
    qqCEnumE :: CEnum -> Maybe ExpQ
    qqCEnumE (C.AntiEnum String
    v SrcLoc
    _)  = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    v
    qqCEnumE CEnum
    _                 = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqCEnumListE :: [C.CEnum] -> Maybe (Q Exp)
    qqCEnumListE :: [CEnum] -> Maybe ExpQ
    qqCEnumListE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqCEnumListE (C.AntiEnums String
    v SrcLoc
    _ : [CEnum]
    fields) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    v) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [CEnum] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [CEnum]
    fields)|]
    qqCEnumListE (CEnum
    field : [CEnum]
    fields) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> CEnum -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp CEnum
    field) : $((forall b. Data b => b -> Maybe ExpQ) -> [CEnum] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [CEnum]
    fields)|]

    qqParamE :: C.Param -> Maybe (Q Exp)
    qqParamE :: Param -> Maybe ExpQ
    qqParamE (C.AntiParam String
    v SrcLoc
    _)  = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    v
    qqParamE Param
    _                  = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqParamListE :: [C.Param] -> Maybe (Q Exp)
    qqParamListE :: [Param] -> Maybe ExpQ
    qqParamListE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqParamListE (C.AntiParams String
    v SrcLoc
    _ : [Param]
    args) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    v) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [Param] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [Param]
    args)|]
    qqParamListE (Param
    arg : [Param]
    args) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> Param -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp Param
    arg) : $((forall b. Data b => b -> Maybe ExpQ) -> [Param] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [Param]
    args)|]

    qqDefinitionE :: C.Definition -> Maybe (Q Exp)
    qqDefinitionE :: Definition -> Maybe ExpQ
    qqDefinitionE (C.AntiFunc String
    v SrcLoc
    loc) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|C.FuncDef $(String -> ExpQ
    antiVarE String
    v) $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]
    qqDefinitionE (C.AntiEsc String
    v SrcLoc
    loc) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|C.EscDef $(String -> ExpQ
    antiVarE String
    v) $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]
    qqDefinitionE (C.AntiEdecl String
    v SrcLoc
    _) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    v
    qqDefinitionE (C.AntiObjCMeth String
    m SrcLoc
    _) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    m
    qqDefinitionE Definition
    _ = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqDefinitionListE :: [C.Definition] -> Maybe (Q Exp)
    qqDefinitionListE :: [Definition] -> Maybe ExpQ
    qqDefinitionListE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqDefinitionListE (C.AntiEdecls String
    v SrcLoc
    _ : [Definition]
    defs) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    v) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [Definition] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [Definition]
    defs)|]
    qqDefinitionListE (C.AntiObjCMeths String
    m SrcLoc
    _ : [Definition]
    meths) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    m) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [Definition] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [Definition]
    meths)|]
    qqDefinitionListE (Definition
    def : [Definition]
    defs) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> Definition -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp Definition
    def) : $((forall b. Data b => b -> Maybe ExpQ) -> [Definition] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [Definition]
    defs)|]

    qqConstE :: C.Const -> Maybe (Q Exp)
    qqConstE :: Const -> Maybe ExpQ
    qqConstE = Const -> Maybe ExpQ
    go
      where
        go :: Const -> Maybe ExpQ
    go (C.AntiConst String
    v SrcLoc
    loc) =
            ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|toConst $(String -> ExpQ
    antiVarE String
    v) $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc) :: C.Const|]

        go (C.AntiInt String
    v SrcLoc
    loc) =
            ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|C.IntConst  $(ExpQ -> ExpQ
    intConst (String -> ExpQ
    antiVarE String
    v)) C.Signed
                               (fromIntegral $(String -> ExpQ
    antiVarE String
    v))
                               $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]

        go (C.AntiUInt String
    v SrcLoc
    loc) =
            ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|C.IntConst  ($(ExpQ -> ExpQ
    intConst (String -> ExpQ
    antiVarE String
    v)) ++ "U") C.Unsigned
                               (fromIntegral $(String -> ExpQ
    antiVarE String
    v))
                               $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]

        go (C.AntiLInt String
    v SrcLoc
    loc) =
            ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|C.LongIntConst  ($(ExpQ -> ExpQ
    intConst (String -> ExpQ
    antiVarE String
    v)) ++ "L") C.Signed
                                   (fromIntegral $(String -> ExpQ
    antiVarE String
    v))
                                   $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]

        go (C.AntiULInt String
    v SrcLoc
    loc) =
            ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|C.LongIntConst  ($(ExpQ -> ExpQ
    intConst (String -> ExpQ
    antiVarE String
    v)) ++ "UL") C.Unsigned
                                   (fromIntegral $(String -> ExpQ
    antiVarE String
    v))
                                   $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]

        go (C.AntiLLInt String
    v SrcLoc
    loc) =
            ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|C.LongLongIntConst  ($(ExpQ -> ExpQ
    intConst (String -> ExpQ
    antiVarE String
    v)) ++ "LL") C.Signed
                                   (fromIntegral $(String -> ExpQ
    antiVarE String
    v))
                                   $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]

        go (C.AntiULLInt String
    v SrcLoc
    loc) =
            ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|C.LongLongIntConst  ($(ExpQ -> ExpQ
    intConst (String -> ExpQ
    antiVarE String
    v)) ++ "ULL") C.Unsigned
                                   (fromIntegral $(String -> ExpQ
    antiVarE String
    v))
                                   $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]

        go (C.AntiFloat String
    v SrcLoc
    loc) =
            ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|toConst ($(String -> ExpQ
    antiVarE String
    v) :: Float) $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]

        go (C.AntiDouble String
    v SrcLoc
    loc) =
            ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|toConst ($(String -> ExpQ
    antiVarE String
    v) :: Double) $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]

        go (C.AntiLongDouble String
    v SrcLoc
    loc) =
            ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|toConst (LongDouble $(String -> ExpQ
    antiVarE String
    v)) $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]

        go (C.AntiChar String
    v SrcLoc
    loc) =
            ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|toConst $(String -> ExpQ
    antiVarE String
    v) $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]

        go (C.AntiString String
    v SrcLoc
    loc) =
            ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|C.StringConst [show $(String -> ExpQ
    antiVarE String
    v)] $(String -> ExpQ
    antiVarE String
    v) $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]

        go Const
    _ = Maybe ExpQ
    forall a. Maybe a
    Nothing

        intConst :: ExpQ -> ExpQ
        intConst :: ExpQ -> ExpQ
    intConst ExpQ
    e = [|show $(ExpQ
    e)|]

    qqExpE :: C.Exp -> Maybe (Q Exp)
    qqExpE :: Exp -> Maybe ExpQ
    qqExpE (C.AntiExp String
    v SrcLoc
    loc)    = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|toExp $(String -> ExpQ
    antiVarE String
    v) $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc) :: C.Exp|]
    qqExpE (C.AntiEscExp String
    v SrcLoc
    loc) = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|C.EscExp $(String -> ExpQ
    antiVarE String
    v) $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc) :: C.Exp|]
    qqExpE Exp
    _                    = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqExpListE :: [C.Exp] -> Maybe (Q Exp)
    qqExpListE :: [Exp] -> Maybe ExpQ
    qqExpListE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqExpListE (C.AntiArgs String
    v SrcLoc
    loc : [Exp]
    exps) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[toExp v $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc) | v <- $(String -> ExpQ
    antiVarE String
    v)] ++
               $((forall b. Data b => b -> Maybe ExpQ) -> [Exp] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [Exp]
    exps)|]
    qqExpListE (Exp
    exp : [Exp]
    exps) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> Exp -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp Exp
    exp) : $((forall b. Data b => b -> Maybe ExpQ) -> [Exp] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [Exp]
    exps)|]

    qqStmE :: C.Stm -> Maybe (Q Exp)
    qqStmE :: Stm -> Maybe ExpQ
    qqStmE (C.AntiEscStm String
    v SrcLoc
    loc)      = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|C.EscStm $(String -> ExpQ
    antiVarE String
    v) $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]
    qqStmE (C.AntiPragma String
    v SrcLoc
    loc)      = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|C.Pragma $(String -> ExpQ
    antiVarE String
    v) $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]
    qqStmE (C.AntiComment String
    v Stm
    stm SrcLoc
    loc) = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|C.Comment $(String -> ExpQ
    antiVarE String
    v) $((forall b. Data b => b -> Maybe ExpQ) -> Stm -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp Stm
    stm) $(SrcLoc -> ExpQ
    qqLocE SrcLoc
    loc)|]
    qqStmE (C.AntiStm String
    v SrcLoc
    _)           = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    v
    qqStmE Stm
    _                         = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqStmListE :: [C.Stm] -> Maybe (Q Exp)
    qqStmListE :: [Stm] -> Maybe ExpQ
    qqStmListE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqStmListE (C.AntiStms String
    v SrcLoc
    _ : [Stm]
    stms) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    v) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [Stm] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [Stm]
    stms)|]
    qqStmListE (Stm
    stm : [Stm]
    stms) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> Stm -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp Stm
    stm) : $((forall b. Data b => b -> Maybe ExpQ) -> [Stm] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [Stm]
    stms)|]

    qqBlockItemE :: C.BlockItem -> Maybe (Q Exp)
    qqBlockItemE :: BlockItem -> Maybe ExpQ
    qqBlockItemE (C.AntiBlockItem String
    v SrcLoc
    _) = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    v
    qqBlockItemE BlockItem
    _                     = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqBlockItemListE :: [C.BlockItem] -> Maybe (Q Exp)
    qqBlockItemListE :: [BlockItem] -> Maybe ExpQ
    qqBlockItemListE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqBlockItemListE (C.BlockDecl (C.AntiDecls String
    v SrcLoc
    _) : [BlockItem]
    items) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|map C.BlockDecl $(String -> ExpQ
    antiVarE String
    v) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [BlockItem] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [BlockItem]
    items)|]
    qqBlockItemListE (C.BlockStm (C.AntiStms String
    v SrcLoc
    _) : [BlockItem]
    items) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|map C.BlockStm $(String -> ExpQ
    antiVarE String
    v) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [BlockItem] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [BlockItem]
    items)|]
    qqBlockItemListE (C.AntiBlockItems String
    v SrcLoc
    _ : [BlockItem]
    items) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    v) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [BlockItem] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [BlockItem]
    items)|]
    qqBlockItemListE (BlockItem
    stm : [BlockItem]
    stms) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> BlockItem -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp BlockItem
    stm) : $((forall b. Data b => b -> Maybe ExpQ) -> [BlockItem] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [BlockItem]
    stms)|]

    qqObjcIfaceDeclE :: C.ObjCIfaceDecl -> Maybe (Q Exp)
    qqObjcIfaceDeclE :: ObjCIfaceDecl -> Maybe ExpQ
    qqObjcIfaceDeclE (C.AntiObjCProp String
    p SrcLoc
    _) = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    p
    qqObjcIfaceDeclE ObjCIfaceDecl
    _                    = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqObjcIfaceDeclListE :: [C.ObjCIfaceDecl] -> Maybe (Q Exp)
    qqObjcIfaceDeclListE :: [ObjCIfaceDecl] -> Maybe ExpQ
    qqObjcIfaceDeclListE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqObjcIfaceDeclListE (C.AntiObjCProps String
    p SrcLoc
    _ : [ObjCIfaceDecl]
    decls) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    p) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [ObjCIfaceDecl] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [ObjCIfaceDecl]
    decls)|]
    qqObjcIfaceDeclListE (C.AntiObjCIfaceDecls String
    v SrcLoc
    _ : [ObjCIfaceDecl]
    decls) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    v) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [ObjCIfaceDecl] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [ObjCIfaceDecl]
    decls)|]
    qqObjcIfaceDeclListE (C.AntiObjCIfaceDecl String
    v SrcLoc
    _  : [ObjCIfaceDecl]
    decls) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    v) : $((forall b. Data b => b -> Maybe ExpQ) -> [ObjCIfaceDecl] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [ObjCIfaceDecl]
    decls)|]
    qqObjcIfaceDeclListE (ObjCIfaceDecl
    decl : [ObjCIfaceDecl]
    decls) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> ObjCIfaceDecl -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp ObjCIfaceDecl
    decl) : $((forall b. Data b => b -> Maybe ExpQ) -> [ObjCIfaceDecl] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [ObjCIfaceDecl]
    decls)|]

    qqObjCPropAttrE :: C.ObjCPropAttr -> Maybe (Q Exp)
    qqObjCPropAttrE :: ObjCPropAttr -> Maybe ExpQ
    qqObjCPropAttrE (C.AntiObjCAttr String
    pa SrcLoc
    _) = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    pa
    qqObjCPropAttrE ObjCPropAttr
    _                     = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqObjCPropAttrListE :: [C.ObjCPropAttr] -> Maybe (Q Exp)
    qqObjCPropAttrListE :: [ObjCPropAttr] -> Maybe ExpQ
    qqObjCPropAttrListE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqObjCPropAttrListE (C.AntiObjCAttrs String
    pa SrcLoc
    _:[ObjCPropAttr]
    attrelems) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    pa) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [ObjCPropAttr] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [ObjCPropAttr]
    attrelems)|]
    qqObjCPropAttrListE (ObjCPropAttr
    pattr : [ObjCPropAttr]
    pattrs) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> ObjCPropAttr -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp ObjCPropAttr
    pattr) : $((forall b. Data b => b -> Maybe ExpQ) -> [ObjCPropAttr] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [ObjCPropAttr]
    pattrs)|]

    qqObjCDictsE :: [C.ObjCDictElem] -> Maybe (Q Exp)
    qqObjCDictsE :: [ObjCDictElem] -> Maybe ExpQ
    qqObjCDictsE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqObjCDictsE (C.AntiObjCDictElems String
    e SrcLoc
    _:[ObjCDictElem]
    elems) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    e) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [ObjCDictElem] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [ObjCDictElem]
    elems)|]
    qqObjCDictsE (ObjCDictElem
    elem : [ObjCDictElem]
    elems) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> ObjCDictElem -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp ObjCDictElem
    elem) : $((forall b. Data b => b -> Maybe ExpQ) -> [ObjCDictElem] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [ObjCDictElem]
    elems)|]

    qqObjCParamE :: C.ObjCParam -> Maybe (Q Exp)
    qqObjCParamE :: ObjCParam -> Maybe ExpQ
    qqObjCParamE (C.AntiObjCParam String
    p SrcLoc
    _) = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    p
    qqObjCParamE ObjCParam
    _                     = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqObjCParamsE :: [C.ObjCParam] -> Maybe (Q Exp)
    qqObjCParamsE :: [ObjCParam] -> Maybe ExpQ
    qqObjCParamsE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqObjCParamsE (C.AntiObjCParams String
    p SrcLoc
    _: [ObjCParam]
    props) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    p) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [ObjCParam] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [ObjCParam]
    props)|]
    qqObjCParamsE (ObjCParam
    param : [ObjCParam]
    params) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> ObjCParam -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp ObjCParam
    param) : $((forall b. Data b => b -> Maybe ExpQ) -> [ObjCParam] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [ObjCParam]
    params)|]

    qqObjCMethodProtoE :: C.ObjCMethodProto -> Maybe (Q Exp)
    qqObjCMethodProtoE :: ObjCMethodProto -> Maybe ExpQ
    qqObjCMethodProtoE (C.AntiObjCMethodProto String
    p SrcLoc
    _) = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    p
    qqObjCMethodProtoE ObjCMethodProto
    _                           = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqObjCRecvE :: C.ObjCRecv -> Maybe (Q Exp)
    qqObjCRecvE :: ObjCRecv -> Maybe ExpQ
    qqObjCRecvE (C.AntiObjCRecv String
    p SrcLoc
    _) = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    p
    qqObjCRecvE ObjCRecv
    _                  = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqObjCArgE :: C.ObjCArg -> Maybe (Q Exp)
    qqObjCArgE :: ObjCArg -> Maybe ExpQ
    qqObjCArgE (C.AntiObjCArg String
    p SrcLoc
    _) = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just (ExpQ -> Maybe ExpQ) -> ExpQ -> Maybe ExpQ
    forall a b. (a -> b) -> a -> b
    $ String -> ExpQ
    antiVarE String
    p
    qqObjCArgE ObjCArg
    _                  = Maybe ExpQ
    forall a. Maybe a
    Nothing

    qqObjCArgsE :: [C.ObjCArg] -> Maybe (Q Exp)
    qqObjCArgsE :: [ObjCArg] -> Maybe ExpQ
    qqObjCArgsE [] = ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|[]|]
    qqObjCArgsE (C.AntiObjCArgs String
    a SrcLoc
    _: [ObjCArg]
    args) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$(String -> ExpQ
    antiVarE String
    a) ++ $((forall b. Data b => b -> Maybe ExpQ) -> [ObjCArg] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [ObjCArg]
    args)|]
    qqObjCArgsE (ObjCArg
    arg : [ObjCArg]
    args) =
        ExpQ -> Maybe ExpQ
    forall a. a -> Maybe a
    Just [|$((forall b. Data b => b -> Maybe ExpQ) -> ObjCArg -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp ObjCArg
    arg) : $((forall b. Data b => b -> Maybe ExpQ) -> [ObjCArg] -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp [ObjCArg]
    args)|]

    qqExp :: Typeable a => a -> Maybe (Q Exp)
    qqExp :: forall a. Typeable a => a -> Maybe ExpQ
    qqExp = Maybe ExpQ -> a -> Maybe ExpQ
    forall a b. a -> b -> a
    const Maybe ExpQ
    forall a. Maybe a
    Nothing  (a -> Maybe ExpQ) -> (String -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` String -> Maybe ExpQ
    qqStringE
                           (a -> Maybe ExpQ) -> (Id -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Id -> Maybe ExpQ
    qqIdE
                           (a -> Maybe ExpQ) -> (DeclSpec -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` DeclSpec -> Maybe ExpQ
    qqDeclSpecE
                           (a -> Maybe ExpQ) -> (Decl -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Decl -> Maybe ExpQ
    qqDeclE
                           (a -> Maybe ExpQ) -> (TypeQual -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` TypeQual -> Maybe ExpQ
    qqTypeQualE
                           (a -> Maybe ExpQ) -> ([TypeQual] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [TypeQual] -> Maybe ExpQ
    qqTypeQualListE
                           (a -> Maybe ExpQ) -> (Type -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Type -> Maybe ExpQ
    qqTypeE
                           (a -> Maybe ExpQ) -> (Initializer -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Initializer -> Maybe ExpQ
    qqInitializerE
                           (a -> Maybe ExpQ)
    -> ([(Maybe Designation, Initializer)] -> Maybe ExpQ)
    -> a
    -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [(Maybe Designation, Initializer)] -> Maybe ExpQ
    qqInitializerListE
                           (a -> Maybe ExpQ) -> (InitGroup -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` InitGroup -> Maybe ExpQ
    qqInitGroupE
                           (a -> Maybe ExpQ) -> ([InitGroup] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [InitGroup] -> Maybe ExpQ
    qqInitGroupListE
                           (a -> Maybe ExpQ) -> (Attr -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Attr -> Maybe ExpQ
    qqAttrE
                           (a -> Maybe ExpQ) -> ([Attr] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [Attr] -> Maybe ExpQ
    qqAttrListE
                           (a -> Maybe ExpQ) -> (FieldGroup -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` FieldGroup -> Maybe ExpQ
    qqFieldGroupE
                           (a -> Maybe ExpQ)
    -> ([FieldGroup] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [FieldGroup] -> Maybe ExpQ
    qqFieldGroupListE
                           (a -> Maybe ExpQ) -> (CEnum -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` CEnum -> Maybe ExpQ
    qqCEnumE
                           (a -> Maybe ExpQ) -> ([CEnum] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [CEnum] -> Maybe ExpQ
    qqCEnumListE
                           (a -> Maybe ExpQ) -> (Param -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Param -> Maybe ExpQ
    qqParamE
                           (a -> Maybe ExpQ) -> ([Param] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [Param] -> Maybe ExpQ
    qqParamListE
                           (a -> Maybe ExpQ) -> (Definition -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Definition -> Maybe ExpQ
    qqDefinitionE
                           (a -> Maybe ExpQ)
    -> ([Definition] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [Definition] -> Maybe ExpQ
    qqDefinitionListE
                           (a -> Maybe ExpQ) -> (Const -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Const -> Maybe ExpQ
    qqConstE
                           (a -> Maybe ExpQ) -> (Exp -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Exp -> Maybe ExpQ
    qqExpE
                           (a -> Maybe ExpQ) -> ([Exp] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [Exp] -> Maybe ExpQ
    qqExpListE
                           (a -> Maybe ExpQ) -> (Stm -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Stm -> Maybe ExpQ
    qqStmE
                           (a -> Maybe ExpQ) -> ([Stm] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [Stm] -> Maybe ExpQ
    qqStmListE
                           (a -> Maybe ExpQ) -> (BlockItem -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` BlockItem -> Maybe ExpQ
    qqBlockItemE
                           (a -> Maybe ExpQ) -> ([BlockItem] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [BlockItem] -> Maybe ExpQ
    qqBlockItemListE
                           (a -> Maybe ExpQ)
    -> (ObjCIfaceDecl -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` ObjCIfaceDecl -> Maybe ExpQ
    qqObjcIfaceDeclE
                           (a -> Maybe ExpQ)
    -> ([ObjCIfaceDecl] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [ObjCIfaceDecl] -> Maybe ExpQ
    qqObjcIfaceDeclListE
                           (a -> Maybe ExpQ)
    -> (ObjCPropAttr -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` ObjCPropAttr -> Maybe ExpQ
    qqObjCPropAttrE
                           (a -> Maybe ExpQ)
    -> ([ObjCPropAttr] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [ObjCPropAttr] -> Maybe ExpQ
    qqObjCPropAttrListE
                           (a -> Maybe ExpQ)
    -> ([ObjCDictElem] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [ObjCDictElem] -> Maybe ExpQ
    qqObjCDictsE
                           (a -> Maybe ExpQ) -> (ObjCParam -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` ObjCParam -> Maybe ExpQ
    qqObjCParamE
                           (a -> Maybe ExpQ) -> ([ObjCParam] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [ObjCParam] -> Maybe ExpQ
    qqObjCParamsE
                           (a -> Maybe ExpQ)
    -> (ObjCMethodProto -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` ObjCMethodProto -> Maybe ExpQ
    qqObjCMethodProtoE
                           (a -> Maybe ExpQ) -> (ObjCRecv -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` ObjCRecv -> Maybe ExpQ
    qqObjCRecvE
                           (a -> Maybe ExpQ) -> (ObjCArg -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` ObjCArg -> Maybe ExpQ
    qqObjCArgE
                           (a -> Maybe ExpQ) -> ([ObjCArg] -> Maybe ExpQ) -> a -> Maybe ExpQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [ObjCArg] -> Maybe ExpQ
    qqObjCArgsE

    antiVarP :: String -> PatQ
    antiVarP :: String -> PatQ
    antiVarP = (String -> PatQ) -> (Pat -> PatQ) -> Either String Pat -> PatQ
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    either String -> PatQ
    forall a. String -> Q a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail Pat -> PatQ
    forall a. a -> Q a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Either String Pat -> PatQ)
    -> (String -> Either String Pat) -> String -> PatQ
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> Either String Pat
    parsePat

    qqStringP :: String -> Maybe (Q Pat)
    qqStringP :: String -> Maybe PatQ
    qqStringP String
    s = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Lit -> PatQ
    forall (m :: * -> *). Quote m => Lit -> m Pat
    litP (Lit -> PatQ) -> Lit -> PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> Lit
    stringL String
    s

    qqLocP :: Data.Loc.Loc -> Maybe (Q Pat)
    qqLocP :: Loc -> Maybe PatQ
    qqLocP Loc
    _ = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP

    qqIdP :: C.Id -> Maybe (Q Pat)
    qqIdP :: Id -> Maybe PatQ
    qqIdP (C.AntiId String
    v SrcLoc
    _) = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    "C.Id") [String -> PatQ
    antiVarP String
    v, PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP]
    qqIdP Id
    _              = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqDeclSpecP :: C.DeclSpec -> Maybe (Q Pat)
    qqDeclSpecP :: DeclSpec -> Maybe PatQ
    qqDeclSpecP (C.AntiDeclSpec String
    v SrcLoc
    _) = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqDeclSpecP C.AntiTypeDeclSpec{} =
        String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Illegal antiquoted type in pattern"
    qqDeclSpecP DeclSpec
    _ = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqDeclP :: C.Decl -> Maybe (Q Pat)
    qqDeclP :: Decl -> Maybe PatQ
    qqDeclP C.AntiTypeDecl{} =
        String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Illegal antiquoted type in pattern"
    qqDeclP Decl
    _ = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqTypeQualP :: C.TypeQual -> Maybe (Q Pat)
    qqTypeQualP :: TypeQual -> Maybe PatQ
    qqTypeQualP (C.AntiTypeQual String
    v SrcLoc
    _) = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqTypeQualP TypeQual
    _                    = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqTypeQualListP :: [C.TypeQual] -> Maybe (Q Pat)
    qqTypeQualListP :: [TypeQual] -> Maybe PatQ
    qqTypeQualListP [] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => [m Pat] -> m Pat
    listP []
    qqTypeQualListP [C.AntiTypeQuals String
    v SrcLoc
    _] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqTypeQualListP (C.AntiTypeQuals{} : TypeQual
    _ : [TypeQual]
    _) =
        String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Antiquoted list of type qualifiers must be last item in quoted list"
    qqTypeQualListP (TypeQual
    arg : [TypeQual]
    args) =
        PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    ":") [(forall b. Data b => b -> Maybe PatQ) -> TypeQual -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat TypeQual
    arg, (forall b. Data b => b -> Maybe PatQ) -> [TypeQual] -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat [TypeQual]
    args]

    qqTypeP :: C.Type -> Maybe (Q Pat)
    qqTypeP :: Type -> Maybe PatQ
    qqTypeP (C.AntiType String
    v SrcLoc
    _)  = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqTypeP Type
    _                 = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqInitializerP :: C.Initializer -> Maybe (Q Pat)
    qqInitializerP :: Initializer -> Maybe PatQ
    qqInitializerP (C.AntiInit String
    v SrcLoc
    _)  = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqInitializerP Initializer
    _                 = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqInitializerListP :: [C.Initializer] -> Maybe (Q Pat)
    qqInitializerListP :: [Initializer] -> Maybe PatQ
    qqInitializerListP [] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => [m Pat] -> m Pat
    listP []
    qqInitializerListP [C.AntiInits String
    v SrcLoc
    _] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqInitializerListP (C.AntiInits{} : Initializer
    _ : [Initializer]
    _) =
        String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Antiquoted list of initializers must be last item in quoted list"
    qqInitializerListP (Initializer
    ini : [Initializer]
    inis) =
        PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    ":") [(forall b. Data b => b -> Maybe PatQ) -> Initializer -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat Initializer
    ini,  (forall b. Data b => b -> Maybe PatQ) -> [Initializer] -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat [Initializer]
    inis]

    qqInitGroupP :: C.InitGroup -> Maybe (Q Pat)
    qqInitGroupP :: InitGroup -> Maybe PatQ
    qqInitGroupP (C.AntiDecl String
    v SrcLoc
    _) = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqInitGroupP InitGroup
    _                = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqInitGroupListP :: [C.InitGroup] -> Maybe (Q Pat)
    qqInitGroupListP :: [InitGroup] -> Maybe PatQ
    qqInitGroupListP [] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => [m Pat] -> m Pat
    listP []
    qqInitGroupListP [C.AntiDecls String
    v SrcLoc
    _] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqInitGroupListP (C.AntiDecls{} : InitGroup
    _ : [InitGroup]
    _) =
        String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Antiquoted list of initialization groups must be last item in quoted list"
    qqInitGroupListP (InitGroup
    ini : [InitGroup]
    inis) =
        PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    ":") [(forall b. Data b => b -> Maybe PatQ) -> InitGroup -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat InitGroup
    ini,  (forall b. Data b => b -> Maybe PatQ) -> [InitGroup] -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat [InitGroup]
    inis]

    qqAttrP :: C.Attr -> Maybe (Q Pat)
    qqAttrP :: Attr -> Maybe PatQ
    qqAttrP (C.AntiAttr String
    v SrcLoc
    _)  = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqAttrP Attr
    _                 = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqAttrListP :: [C.Attr] -> Maybe (Q Pat)
    qqAttrListP :: [Attr] -> Maybe PatQ
    qqAttrListP [] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => [m Pat] -> m Pat
    listP []
    qqAttrListP [C.AntiAttrs String
    v SrcLoc
    _] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqAttrListP (C.AntiAttrs{} : Attr
    _ : [Attr]
    _) =
       String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Antiquoted list of attrs must be last item in quoted list"
    qqAttrListP (Attr
    ini : [Attr]
    inis) =
        PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    ":") [(forall b. Data b => b -> Maybe PatQ) -> Attr -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat Attr
    ini,  (forall b. Data b => b -> Maybe PatQ) -> [Attr] -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat [Attr]
    inis]

    qqFieldGroupP :: C.FieldGroup -> Maybe (Q Pat)
    qqFieldGroupP :: FieldGroup -> Maybe PatQ
    qqFieldGroupP (C.AntiSdecl String
    v SrcLoc
    _) = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqFieldGroupP FieldGroup
    _                 = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqFieldGroupListP :: [C.FieldGroup] -> Maybe (Q Pat)
    qqFieldGroupListP :: [FieldGroup] -> Maybe PatQ
    qqFieldGroupListP [] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => [m Pat] -> m Pat
    listP []
    qqFieldGroupListP [C.AntiSdecls String
    v SrcLoc
    _] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqFieldGroupListP (C.AntiSdecls{} : FieldGroup
    _ : [FieldGroup]
    _) =
        String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Antiquoted list of struct/union fields must be last item in quoted list"
    qqFieldGroupListP (FieldGroup
    ini : [FieldGroup]
    inis) =
        PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    ":") [(forall b. Data b => b -> Maybe PatQ) -> FieldGroup -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat FieldGroup
    ini,  (forall b. Data b => b -> Maybe PatQ) -> [FieldGroup] -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat [FieldGroup]
    inis]

    qqCEnumP :: C.CEnum -> Maybe (Q Pat)
    qqCEnumP :: CEnum -> Maybe PatQ
    qqCEnumP (C.AntiEnum String
    v SrcLoc
    _) = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqCEnumP CEnum
    _                = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqCEnumListP :: [C.CEnum] -> Maybe (Q Pat)
    qqCEnumListP :: [CEnum] -> Maybe PatQ
    qqCEnumListP [] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => [m Pat] -> m Pat
    listP []
    qqCEnumListP [C.AntiEnums String
    v SrcLoc
    _] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqCEnumListP (C.AntiEnums{} : CEnum
    _ : [CEnum]
    _) =
        String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Antiquoted list of enumerations must be last item in quoted list"
    qqCEnumListP (CEnum
    ini : [CEnum]
    inis) =
        PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    ":") [(forall b. Data b => b -> Maybe PatQ) -> CEnum -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat CEnum
    ini,  (forall b. Data b => b -> Maybe PatQ) -> [CEnum] -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat [CEnum]
    inis]

    qqParamP :: C.Param -> Maybe (Q Pat)
    qqParamP :: Param -> Maybe PatQ
    qqParamP (C.AntiParam String
    v SrcLoc
    _) = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqParamP Param
    _                 = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqParamListP :: [C.Param] -> Maybe (Q Pat)
    qqParamListP :: [Param] -> Maybe PatQ
    qqParamListP [] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => [m Pat] -> m Pat
    listP []
    qqParamListP [C.AntiParams String
    v SrcLoc
    _] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqParamListP (C.AntiParams{} : Param
    _ : [Param]
    _) =
        String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Antiquoted list of parameters must be last item in quoted list"
    qqParamListP (Param
    arg : [Param]
    args) =
        PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    ":") [(forall b. Data b => b -> Maybe PatQ) -> Param -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat Param
    arg,  (forall b. Data b => b -> Maybe PatQ) -> [Param] -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat [Param]
    args]

    qqDefinitionP :: C.Definition -> Maybe (Q Pat)
    qqDefinitionP :: Definition -> Maybe PatQ
    qqDefinitionP (C.AntiFunc String
    v SrcLoc
    _)  = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    "C.FuncDef") [String -> PatQ
    antiVarP String
    v, PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP]
    qqDefinitionP (C.AntiEsc String
    v SrcLoc
    _)   = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    "C.EscDef") [String -> PatQ
    antiVarP String
    v, PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP]
    qqDefinitionP (C.AntiEdecl String
    v SrcLoc
    _) = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqDefinitionP Definition
    _                 = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqDefinitionListP :: [C.Definition] -> Maybe (Q Pat)
    qqDefinitionListP :: [Definition] -> Maybe PatQ
    qqDefinitionListP [] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => [m Pat] -> m Pat
    listP []
    qqDefinitionListP [C.AntiEdecls String
    v SrcLoc
    _] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqDefinitionListP (C.AntiEdecls{} : Definition
    _ : [Definition]
    _) =
        String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Antiquoted list of definitions must be last item in quoted list"
    qqDefinitionListP (Definition
    arg : [Definition]
    args) =
        PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    ":") [(forall b. Data b => b -> Maybe PatQ) -> Definition -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat Definition
    arg,  (forall b. Data b => b -> Maybe PatQ) -> [Definition] -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat [Definition]
    args]

    qqConstP :: C.Const -> Maybe (Q Pat)
    qqConstP :: Const -> Maybe PatQ
    qqConstP = Const -> Maybe PatQ
    go
      where
        go :: Const -> Maybe PatQ
    go (C.AntiInt String
    v SrcLoc
    _) =
            PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> [PatQ] -> PatQ
    forall {m :: * -> *}. Quote m => String -> [m Pat] -> m Pat
    con String
    "C.IntConst" [PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP, PatQ
    signed, String -> PatQ
    antiVarP String
    v, PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP]
        go (C.AntiUInt String
    v SrcLoc
    _) =
            PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> [PatQ] -> PatQ
    forall {m :: * -> *}. Quote m => String -> [m Pat] -> m Pat
    con String
    "C.IntConst" [PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP, PatQ
    unsigned, String -> PatQ
    antiVarP String
    v, PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP]
        go (C.AntiLInt String
    v SrcLoc
    _) =
            PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> [PatQ] -> PatQ
    forall {m :: * -> *}. Quote m => String -> [m Pat] -> m Pat
    con String
    "C.LongIntConst" [PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP, PatQ
    signed, String -> PatQ
    antiVarP String
    v, PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP]
        go (C.AntiULInt String
    v SrcLoc
    _) =
            PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> [PatQ] -> PatQ
    forall {m :: * -> *}. Quote m => String -> [m Pat] -> m Pat
    con String
    "C.LongIntConst" [PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP, PatQ
    unsigned, String -> PatQ
    antiVarP String
    v, PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP]
        go (C.AntiFloat String
    v SrcLoc
    _) =
            PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> [PatQ] -> PatQ
    forall {m :: * -> *}. Quote m => String -> [m Pat] -> m Pat
    con String
    "C.FloatConst" [PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP, String -> PatQ
    antiVarP String
    v, PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP]
        go (C.AntiDouble String
    v SrcLoc
    _) =
            PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> [PatQ] -> PatQ
    forall {m :: * -> *}. Quote m => String -> [m Pat] -> m Pat
    con String
    "C.DoubleConst" [PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP, String -> PatQ
    antiVarP String
    v, PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP]
        go (C.AntiLongDouble String
    v SrcLoc
    _) =
            PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> [PatQ] -> PatQ
    forall {m :: * -> *}. Quote m => String -> [m Pat] -> m Pat
    con String
    "C.LongDoubleConst" [PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP, String -> PatQ
    antiVarP String
    v, PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP]
        go (C.AntiChar String
    v SrcLoc
    _) =
            PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> [PatQ] -> PatQ
    forall {m :: * -> *}. Quote m => String -> [m Pat] -> m Pat
    con String
    "C.CharConst" [PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP, String -> PatQ
    antiVarP String
    v, PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP]
        go (C.AntiString String
    v SrcLoc
    _) =
            PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> [PatQ] -> PatQ
    forall {m :: * -> *}. Quote m => String -> [m Pat] -> m Pat
    con String
    "C.StringConst" [PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP, String -> PatQ
    antiVarP String
    v, PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP]
        go Const
    _ =
            Maybe PatQ
    forall a. Maybe a
    Nothing

        con :: String -> [m Pat] -> m Pat
    con String
    n = Name -> [m Pat] -> m Pat
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    n)

        signed :: PatQ
    signed   = Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    "C.Signed") []
        unsigned :: PatQ
    unsigned = Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    "C.Unsigned") []

    qqExpP :: C.Exp -> Maybe (Q Pat)
    qqExpP :: Exp -> Maybe PatQ
    qqExpP (C.AntiExp String
    v SrcLoc
    _)    = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqExpP (C.AntiEscExp String
    v SrcLoc
    _) = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    "C.EscExp") [String -> PatQ
    antiVarP String
    v, PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP]
    qqExpP Exp
    _                  = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqExpListP :: [C.Exp] -> Maybe (Q Pat)
    qqExpListP :: [Exp] -> Maybe PatQ
    qqExpListP [] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => [m Pat] -> m Pat
    listP []
    qqExpListP [C.AntiArgs String
    v SrcLoc
    _] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqExpListP (C.AntiArgs{} : Exp
    _ : [Exp]
    _) =
        String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Antiquoted list of arguments must be last item in quoted list"
    qqExpListP (Exp
    arg : [Exp]
    args) =
        PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    ":") [(forall b. Data b => b -> Maybe PatQ) -> Exp -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat Exp
    arg,  (forall b. Data b => b -> Maybe PatQ) -> [Exp] -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat [Exp]
    args]

    qqStmP :: C.Stm -> Maybe (Q Pat)
    qqStmP :: Stm -> Maybe PatQ
    qqStmP (C.AntiStm String
    v SrcLoc
    _)    = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqStmP (C.AntiEscStm String
    v SrcLoc
    _) = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    "C.EscStm") [String -> PatQ
    antiVarP String
    v, PatQ
    forall (m :: * -> *). Quote m => m Pat
    wildP]
    qqStmP Stm
    _                  = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqStmListP :: [C.Stm] -> Maybe (Q Pat)
    qqStmListP :: [Stm] -> Maybe PatQ
    qqStmListP [] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => [m Pat] -> m Pat
    listP []
    qqStmListP [C.AntiStms String
    v SrcLoc
    _] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqStmListP (C.AntiStms{} : Stm
    _ : [Stm]
    _) =
        String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Antiquoted list of statements must be last item in quoted list"
    qqStmListP (Stm
    arg : [Stm]
    args) =
        PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    ":") [(forall b. Data b => b -> Maybe PatQ) -> Stm -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat Stm
    arg,  (forall b. Data b => b -> Maybe PatQ) -> [Stm] -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat [Stm]
    args]

    qqBlockItemP :: C.BlockItem -> Maybe (Q Pat)
    qqBlockItemP :: BlockItem -> Maybe PatQ
    qqBlockItemP (C.AntiBlockItem String
    v SrcLoc
    _) = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqBlockItemP BlockItem
    _                     = Maybe PatQ
    forall a. Maybe a
    Nothing

    qqBlockItemListP :: [C.BlockItem] -> Maybe (Q Pat)
    qqBlockItemListP :: [BlockItem] -> Maybe PatQ
    qqBlockItemListP [] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => [m Pat] -> m Pat
    listP []
    qqBlockItemListP (C.BlockDecl C.AntiDecls{} : [BlockItem]
    _) =
        String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Antiquoted list of declarations cannot appear in block"
    qqBlockItemListP (C.BlockStm C.AntiStms{} : [BlockItem]
    _) =
        String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Antiquoted list of statements cannot appear in block"
    qqBlockItemListP [C.AntiBlockItems String
    v SrcLoc
    _] = PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ String -> PatQ
    antiVarP String
    v
    qqBlockItemListP (C.AntiBlockItems{} : BlockItem
    _ : [BlockItem]
    _) =
        String -> Maybe PatQ
    forall a. HasCallStack => String -> a
    error String
    "Antiquoted list of block items must be last item in quoted list"
    qqBlockItemListP (BlockItem
    arg : [BlockItem]
    args) =
        PatQ -> Maybe PatQ
    forall a. a -> Maybe a
    Just (PatQ -> Maybe PatQ) -> PatQ -> Maybe PatQ
    forall a b. (a -> b) -> a -> b
    $ Name -> [PatQ] -> PatQ
    forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
    conP (String -> Name
    mkName String
    ":") [(forall b. Data b => b -> Maybe PatQ) -> BlockItem -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat BlockItem
    arg,  (forall b. Data b => b -> Maybe PatQ) -> [BlockItem] -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat [BlockItem]
    args]

    qqPat :: Typeable a => a -> Maybe (Q Pat)
    qqPat :: forall a. Typeable a => a -> Maybe PatQ
    qqPat = Maybe PatQ -> a -> Maybe PatQ
    forall a b. a -> b -> a
    const Maybe PatQ
    forall a. Maybe a
    Nothing (a -> Maybe PatQ) -> (String -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` String -> Maybe PatQ
    qqStringP
                          (a -> Maybe PatQ) -> (Loc -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Loc -> Maybe PatQ
    qqLocP
                          (a -> Maybe PatQ) -> (Id -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Id -> Maybe PatQ
    qqIdP
                          (a -> Maybe PatQ) -> (DeclSpec -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` DeclSpec -> Maybe PatQ
    qqDeclSpecP
                          (a -> Maybe PatQ) -> (Decl -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Decl -> Maybe PatQ
    qqDeclP
                          (a -> Maybe PatQ) -> (TypeQual -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` TypeQual -> Maybe PatQ
    qqTypeQualP
                          (a -> Maybe PatQ) -> ([TypeQual] -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [TypeQual] -> Maybe PatQ
    qqTypeQualListP
                          (a -> Maybe PatQ) -> (Type -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Type -> Maybe PatQ
    qqTypeP
                          (a -> Maybe PatQ) -> (Initializer -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Initializer -> Maybe PatQ
    qqInitializerP
                          (a -> Maybe PatQ)
    -> ([Initializer] -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [Initializer] -> Maybe PatQ
    qqInitializerListP
                          (a -> Maybe PatQ) -> (InitGroup -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` InitGroup -> Maybe PatQ
    qqInitGroupP
                          (a -> Maybe PatQ) -> ([InitGroup] -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [InitGroup] -> Maybe PatQ
    qqInitGroupListP
                          (a -> Maybe PatQ) -> (Attr -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Attr -> Maybe PatQ
    qqAttrP
                          (a -> Maybe PatQ) -> ([Attr] -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [Attr] -> Maybe PatQ
    qqAttrListP
                          (a -> Maybe PatQ) -> (FieldGroup -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` FieldGroup -> Maybe PatQ
    qqFieldGroupP
                          (a -> Maybe PatQ) -> (CEnum -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` CEnum -> Maybe PatQ
    qqCEnumP
                          (a -> Maybe PatQ) -> ([CEnum] -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [CEnum] -> Maybe PatQ
    qqCEnumListP
                          (a -> Maybe PatQ) -> (Param -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Param -> Maybe PatQ
    qqParamP
                          (a -> Maybe PatQ) -> ([Param] -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [Param] -> Maybe PatQ
    qqParamListP
                          (a -> Maybe PatQ) -> (Definition -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Definition -> Maybe PatQ
    qqDefinitionP
                          (a -> Maybe PatQ)
    -> ([Definition] -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [Definition] -> Maybe PatQ
    qqDefinitionListP
                          (a -> Maybe PatQ) -> (Const -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Const -> Maybe PatQ
    qqConstP
                          (a -> Maybe PatQ) -> (Exp -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Exp -> Maybe PatQ
    qqExpP
                          (a -> Maybe PatQ) -> ([Exp] -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [Exp] -> Maybe PatQ
    qqExpListP
                          (a -> Maybe PatQ) -> (Stm -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` Stm -> Maybe PatQ
    qqStmP
                          (a -> Maybe PatQ) -> ([Stm] -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [Stm] -> Maybe PatQ
    qqStmListP
                          (a -> Maybe PatQ) -> (BlockItem -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` BlockItem -> Maybe PatQ
    qqBlockItemP
                          (a -> Maybe PatQ) -> ([BlockItem] -> Maybe PatQ) -> a -> Maybe PatQ
    forall a b r.
    (Typeable a, Typeable b) =>
    (a -> r) -> (b -> r) -> a -> r
    `extQ` [BlockItem] -> Maybe PatQ
    qqBlockItemListP

    parse :: [C.Extensions]
          -> [String]
          -> P.P a
          -> String
          -> Q a
    parse :: forall a. [Extensions] -> [String] -> P a -> String -> Q a
    parse [Extensions]
    exts [String]
    typenames P a
    p String
    s = do
        loc <- Q Loc
    location
        case P.parse (C.Antiquotation : exts) typenames p (B.pack s) (Just (locToPos loc)) of
          Left SomeException
    err -> String -> Q a
    forall a. String -> Q a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail (SomeException -> String
    forall a. Show a => a -> String
    show SomeException
    err)
          Right a
    x  -> a -> Q a
    forall a. a -> Q a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x
      where
        locToPos :: TH.Loc -> Pos
        locToPos :: Loc -> Pos
    locToPos TH.Loc {loc_filename :: Loc -> String
    loc_filename = String
    filename, loc_start :: Loc -> CharPos
    loc_start = (Int
    line, Int
    col)} =
            String -> Int -> Int -> Int -> Pos
    Pos String
    filename Int
    line Int
    col Int
    0

    quasiquote :: Data a
               => [C.Extensions]
               -> [String]
               -> P.P a
               -> QuasiQuoter
    quasiquote :: forall a. Data a => [Extensions] -> [String] -> P a -> QuasiQuoter
    quasiquote [Extensions]
    exts [String]
    typenames P a
    p =
        QuasiQuoter { quoteExp :: String -> ExpQ
    quoteExp  = [Extensions] -> [String] -> P a -> String -> Q a
    forall a. [Extensions] -> [String] -> P a -> String -> Q a
    parse [Extensions]
    exts [String]
    typenames P a
    p (String -> Q a) -> (a -> ExpQ) -> String -> ExpQ
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> (forall b. Data b => b -> Maybe ExpQ) -> a -> ExpQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
    dataToExpQ b -> Maybe ExpQ
    forall b. Data b => b -> Maybe ExpQ
    forall a. Typeable a => a -> Maybe ExpQ
    qqExp
                    , quotePat :: String -> PatQ
    quotePat  = [Extensions] -> [String] -> P a -> String -> Q a
    forall a. [Extensions] -> [String] -> P a -> String -> Q a
    parse [Extensions]
    exts [String]
    typenames P a
    p (String -> Q a) -> (a -> PatQ) -> String -> PatQ
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> (forall b. Data b => b -> Maybe PatQ) -> a -> PatQ
    forall (m :: * -> *) a.
    (Quote m, Data a) =>
    (forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
    dataToPatQ b -> Maybe PatQ
    forall b. Data b => b -> Maybe PatQ
    forall a. Typeable a => a -> Maybe PatQ
    qqPat
                    , quoteType :: String -> Q Type
    quoteType = String -> String -> Q Type
    forall a. HasCallStack => String -> a
    error String
    "C type quasiquoter undefined"
                    , quoteDec :: String -> Q [Dec]
    quoteDec  = String -> String -> Q [Dec]
    forall a. HasCallStack => String -> a
    error String
    "C declaration quasiquoter undefined"
                    }

    #if !MIN_VERSION_template_haskell(2,7,0)
    dataToQa  ::  forall a k q. Data a
              =>  (Name -> k)
              ->  (Lit -> Q q)
              ->  (k -> [Q q] -> Q q)
              ->  (forall b . Data b => b -> Maybe (Q q))
              ->  a
              ->  Q q
    dataToQa mkCon mkLit appCon antiQ t =
        case antiQ t of
          Nothing ->
              case constrRep constr of
                AlgConstr _  ->
                    appCon con conArgs
                IntConstr n ->
                    mkLit $ integerL n
                FloatConstr n ->
                    mkLit $ rationalL (toRational n)
                CharConstr c ->
                    mkLit $ charL c
            where
              constr :: Constr
              constr = toConstr t

              con :: k
              con = mkCon (mkConName mod occ)
                where
                  mod :: String
                  mod = (tyconModule . dataTypeName . dataTypeOf) t

                  occ :: String
                  occ = showConstr constr

                  mkConName :: String -> String -> Name
                  mkConName "Prelude" "(:)" = Name (mkOccName ":") NameS
                  mkConName "Prelude" "[]"  = Name (mkOccName "[]") NameS
                  mkConName "Prelude" "()"  = Name (mkOccName "()") NameS

                  mkConName "Prelude" s@('(' : ',' : rest) = go rest
                    where
                      go :: String -> Name
                      go (',' : rest) = go rest
                      go ")"          = Name (mkOccName s) NameS
                      go _            = Name (mkOccName occ) (NameQ (mkModName mod))

                  mkConName "GHC.Real" ":%" = mkNameG_d "base" "GHC.Real" ":%"

                  mkConName mod occ = Name (mkOccName occ) (NameQ (mkModName mod))

              conArgs :: [Q q]
              conArgs = gmapQ (dataToQa mkCon mkLit appCon antiQ) t

          Just y -> y

    -- | 'dataToExpQ' converts a value to a 'Q Exp' representation of the same
    -- value. It takes a function to handle type-specific cases.
    dataToExpQ  ::  Data a
                =>  (forall b . Data b => b -> Maybe (Q Exp))
                ->  a
                ->  Q Exp
    dataToExpQ = dataToQa conE litE (foldl appE)

    -- | 'dataToPatQ' converts a value to a 'Q Pat' representation of the same
    -- value. It takes a function to handle type-specific cases.
    dataToPatQ  ::  Data a
                =>  (forall b . Data b => b -> Maybe (Q Pat))
                ->  a
                ->  Q Pat
    dataToPatQ = dataToQa id litP conP
    #endif /* !MIN_VERSION_template_haskell(2,7,0) */