gi-glib-0.2.44.12: GI/GLib/Structs/ScannerConfig.hs

{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

Specifies the #GScanner parser configuration. Most settings can
be changed during the parsing phase and will affect the lexical
parsing of the next unpeeked token.
-}

module GI.GLib.Structs.ScannerConfig
    ( 

-- * Exported types
    ScannerConfig(..)                       ,
    noScannerConfig                         ,


 -- * Properties
-- ** CaseSensitive
    scannerConfigReadCaseSensitive          ,


-- ** Char2Token
    scannerConfigReadChar2Token             ,


-- ** CpairCommentSingle
    scannerConfigReadCpairCommentSingle     ,


-- ** CsetIdentifierFirst
    scannerConfigReadCsetIdentifierFirst    ,


-- ** CsetIdentifierNth
    scannerConfigReadCsetIdentifierNth      ,


-- ** CsetSkipCharacters
    scannerConfigReadCsetSkipCharacters     ,


-- ** Identifier2String
    scannerConfigReadIdentifier2String      ,


-- ** Int2Float
    scannerConfigReadInt2Float              ,


-- ** Numbers2Int
    scannerConfigReadNumbers2Int            ,


-- ** ScanBinary
    scannerConfigReadScanBinary             ,


-- ** ScanCommentMulti
    scannerConfigReadScanCommentMulti       ,


-- ** ScanFloat
    scannerConfigReadScanFloat              ,


-- ** ScanHex
    scannerConfigReadScanHex                ,


-- ** ScanHexDollar
    scannerConfigReadScanHexDollar          ,


-- ** ScanIdentifier
    scannerConfigReadScanIdentifier         ,


-- ** ScanIdentifier1char
    scannerConfigReadScanIdentifier1char    ,


-- ** ScanIdentifierNULL
    scannerConfigReadScanIdentifierNULL     ,


-- ** ScanOctal
    scannerConfigReadScanOctal              ,


-- ** ScanStringDq
    scannerConfigReadScanStringDq           ,


-- ** ScanStringSq
    scannerConfigReadScanStringSq           ,


-- ** ScanSymbols
    scannerConfigReadScanSymbols            ,


-- ** Scope0Fallback
    scannerConfigReadScope0Fallback         ,


-- ** SkipCommentMulti
    scannerConfigReadSkipCommentMulti       ,


-- ** SkipCommentSingle
    scannerConfigReadSkipCommentSingle      ,


-- ** StoreInt64
    scannerConfigReadStoreInt64             ,


-- ** Symbol2Token
    scannerConfigReadSymbol2Token           ,




    ) where

import Prelude ()
import Data.GI.Base.ShortPrelude

import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map

import GI.GLib.Types
import GI.GLib.Callbacks

newtype ScannerConfig = ScannerConfig (ForeignPtr ScannerConfig)
noScannerConfig :: Maybe ScannerConfig
noScannerConfig = Nothing

scannerConfigReadCsetSkipCharacters :: ScannerConfig -> IO T.Text
scannerConfigReadCsetSkipCharacters s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CString
    val' <- cstringToText val
    return val'

scannerConfigReadCsetIdentifierFirst :: ScannerConfig -> IO T.Text
scannerConfigReadCsetIdentifierFirst s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO CString
    val' <- cstringToText val
    return val'

scannerConfigReadCsetIdentifierNth :: ScannerConfig -> IO T.Text
scannerConfigReadCsetIdentifierNth s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO CString
    val' <- cstringToText val
    return val'

scannerConfigReadCpairCommentSingle :: ScannerConfig -> IO T.Text
scannerConfigReadCpairCommentSingle s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO CString
    val' <- cstringToText val
    return val'

scannerConfigReadCaseSensitive :: ScannerConfig -> IO Word32
scannerConfigReadCaseSensitive s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO Word32
    return val

scannerConfigReadSkipCommentMulti :: ScannerConfig -> IO Word32
scannerConfigReadSkipCommentMulti s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 36) :: IO Word32
    return val

scannerConfigReadSkipCommentSingle :: ScannerConfig -> IO Word32
scannerConfigReadSkipCommentSingle s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO Word32
    return val

scannerConfigReadScanCommentMulti :: ScannerConfig -> IO Word32
scannerConfigReadScanCommentMulti s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 44) :: IO Word32
    return val

scannerConfigReadScanIdentifier :: ScannerConfig -> IO Word32
scannerConfigReadScanIdentifier s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 48) :: IO Word32
    return val

scannerConfigReadScanIdentifier1char :: ScannerConfig -> IO Word32
scannerConfigReadScanIdentifier1char s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 52) :: IO Word32
    return val

scannerConfigReadScanIdentifierNULL :: ScannerConfig -> IO Word32
scannerConfigReadScanIdentifierNULL s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 56) :: IO Word32
    return val

scannerConfigReadScanSymbols :: ScannerConfig -> IO Word32
scannerConfigReadScanSymbols s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 60) :: IO Word32
    return val

scannerConfigReadScanBinary :: ScannerConfig -> IO Word32
scannerConfigReadScanBinary s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 64) :: IO Word32
    return val

scannerConfigReadScanOctal :: ScannerConfig -> IO Word32
scannerConfigReadScanOctal s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 68) :: IO Word32
    return val

scannerConfigReadScanFloat :: ScannerConfig -> IO Word32
scannerConfigReadScanFloat s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 72) :: IO Word32
    return val

scannerConfigReadScanHex :: ScannerConfig -> IO Word32
scannerConfigReadScanHex s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 76) :: IO Word32
    return val

scannerConfigReadScanHexDollar :: ScannerConfig -> IO Word32
scannerConfigReadScanHexDollar s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 80) :: IO Word32
    return val

scannerConfigReadScanStringSq :: ScannerConfig -> IO Word32
scannerConfigReadScanStringSq s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 84) :: IO Word32
    return val

scannerConfigReadScanStringDq :: ScannerConfig -> IO Word32
scannerConfigReadScanStringDq s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 88) :: IO Word32
    return val

scannerConfigReadNumbers2Int :: ScannerConfig -> IO Word32
scannerConfigReadNumbers2Int s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 92) :: IO Word32
    return val

scannerConfigReadInt2Float :: ScannerConfig -> IO Word32
scannerConfigReadInt2Float s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 96) :: IO Word32
    return val

scannerConfigReadIdentifier2String :: ScannerConfig -> IO Word32
scannerConfigReadIdentifier2String s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 100) :: IO Word32
    return val

scannerConfigReadChar2Token :: ScannerConfig -> IO Word32
scannerConfigReadChar2Token s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 104) :: IO Word32
    return val

scannerConfigReadSymbol2Token :: ScannerConfig -> IO Word32
scannerConfigReadSymbol2Token s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 108) :: IO Word32
    return val

scannerConfigReadScope0Fallback :: ScannerConfig -> IO Word32
scannerConfigReadScope0Fallback s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 112) :: IO Word32
    return val

scannerConfigReadStoreInt64 :: ScannerConfig -> IO Word32
scannerConfigReadStoreInt64 s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 116) :: IO Word32
    return val