{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}

-- | The HTML Lexer.
module Zenacy.HTML.Internal.Lexer
  ( Lexer(..)
  , LexerOptions(..)
  , LexerSkip(..)
  , lexerNew
  , lexerSetRCDATA
  , lexerSetRAWTEXT
  , lexerSetPLAINTEXT
  , lexerSetScriptData
  , lexerSkipNextLF
  , lexerNext
  ) where

import Zenacy.HTML.Internal.BS
import Zenacy.HTML.Internal.Buffer
import Zenacy.HTML.Internal.Char
import Zenacy.HTML.Internal.Core
import Zenacy.HTML.Internal.Entity
import Zenacy.HTML.Internal.Token
import Control.Monad
  ( forM
  , forM_
  , mapM
  , when
  )
import Control.Monad.Extra
  ( whenM
  , whenJust
  )
import Control.Monad.ST
  ( ST
  )
import Data.STRef
  ( STRef
  , newSTRef
  )
import Data.DList
  ( DList
  )
import qualified Data.DList as D
  ( empty
  , snoc
  , toList
  )
import Data.Map
  ( Map
  )
import qualified Data.Map as Map
  ( fromList
  , lookup
  )
import Data.Maybe
  ( isJust
  )
import Data.Word
  ( Word8
  )
import Data.Default
  ( Default(..)
  )
import Data.Vector.Storable.Mutable
  ( MVector(..)
  )
import qualified Data.Vector.Storable.Mutable as U
  ( new
  , length
  , read
  , write
  , grow
  )

import Debug.Trace (trace)


-- | Lexer options type.
data LexerOptions = LexerOptions
  { LexerOptions -> BS
lexerOptionInput          :: BS
  -- ^ The input to the lexer.
  , LexerOptions -> Bool
lexerOptionLogErrors      :: Bool
  -- ^ Indicates whether errors are logged.
  , LexerOptions -> Bool
lexerOptionIgnoreEntities :: Bool
  -- ^ Indicates that entities should not be tokenized.
  } deriving (Int -> LexerOptions -> ShowS
[LexerOptions] -> ShowS
LexerOptions -> String
(Int -> LexerOptions -> ShowS)
-> (LexerOptions -> String)
-> ([LexerOptions] -> ShowS)
-> Show LexerOptions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LexerOptions] -> ShowS
$cshowList :: [LexerOptions] -> ShowS
show :: LexerOptions -> String
$cshow :: LexerOptions -> String
showsPrec :: Int -> LexerOptions -> ShowS
$cshowsPrec :: Int -> LexerOptions -> ShowS
Show)

-- | Defines the skip mode.
data LexerSkip
  = LexerSkipNone
  | LexerSkipLF
    deriving (LexerSkip -> LexerSkip -> Bool
(LexerSkip -> LexerSkip -> Bool)
-> (LexerSkip -> LexerSkip -> Bool) -> Eq LexerSkip
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LexerSkip -> LexerSkip -> Bool
$c/= :: LexerSkip -> LexerSkip -> Bool
== :: LexerSkip -> LexerSkip -> Bool
$c== :: LexerSkip -> LexerSkip -> Bool
Eq, Eq LexerSkip
Eq LexerSkip
-> (LexerSkip -> LexerSkip -> Ordering)
-> (LexerSkip -> LexerSkip -> Bool)
-> (LexerSkip -> LexerSkip -> Bool)
-> (LexerSkip -> LexerSkip -> Bool)
-> (LexerSkip -> LexerSkip -> Bool)
-> (LexerSkip -> LexerSkip -> LexerSkip)
-> (LexerSkip -> LexerSkip -> LexerSkip)
-> Ord LexerSkip
LexerSkip -> LexerSkip -> Bool
LexerSkip -> LexerSkip -> Ordering
LexerSkip -> LexerSkip -> LexerSkip
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: LexerSkip -> LexerSkip -> LexerSkip
$cmin :: LexerSkip -> LexerSkip -> LexerSkip
max :: LexerSkip -> LexerSkip -> LexerSkip
$cmax :: LexerSkip -> LexerSkip -> LexerSkip
>= :: LexerSkip -> LexerSkip -> Bool
$c>= :: LexerSkip -> LexerSkip -> Bool
> :: LexerSkip -> LexerSkip -> Bool
$c> :: LexerSkip -> LexerSkip -> Bool
<= :: LexerSkip -> LexerSkip -> Bool
$c<= :: LexerSkip -> LexerSkip -> Bool
< :: LexerSkip -> LexerSkip -> Bool
$c< :: LexerSkip -> LexerSkip -> Bool
compare :: LexerSkip -> LexerSkip -> Ordering
$ccompare :: LexerSkip -> LexerSkip -> Ordering
$cp1Ord :: Eq LexerSkip
Ord, Int -> LexerSkip -> ShowS
[LexerSkip] -> ShowS
LexerSkip -> String
(Int -> LexerSkip -> ShowS)
-> (LexerSkip -> String)
-> ([LexerSkip] -> ShowS)
-> Show LexerSkip
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LexerSkip] -> ShowS
$cshowList :: [LexerSkip] -> ShowS
show :: LexerSkip -> String
$cshow :: LexerSkip -> String
showsPrec :: Int -> LexerSkip -> ShowS
$cshowsPrec :: Int -> LexerSkip -> ShowS
Show)

-- | Defines the lexer state.
data Lexer s = Lexer
  { Lexer s -> BS
lexerData     :: BS
  -- ^ The lexer data.
  , Lexer s -> Bool
lexerIgnore   :: Bool
  -- ^ Flag to ignore entity processing.
  , Lexer s -> Bool
lexerLog      :: Bool
  -- ^ Flag to log errors.
  , Lexer s -> STRef s Int
lexerOffset   :: STRef s Int
  -- ^ The offset in the data for the next word to read.
  , Lexer s -> STRef s (TokenBuffer s)
lexerToken    :: STRef s (TokenBuffer s)
  -- ^ The token buffer.
  , Lexer s -> STRef s (Buffer s)
lexerBuffer   :: STRef s (Buffer s)
  -- ^ The buffer is used to accumulate characters during
  --   some types of character processing.
  , Lexer s -> STRef s [Word8]
lexerLast     :: STRef s [Word8]
  -- ^ The last start tag name to have been emitted.
  , Lexer s -> STRef s LexerState
lexerState    :: STRef s LexerState
  -- ^ The current lexer state in some cases.
  , Lexer s -> STRef s LexerState
lexerReturn   :: STRef s LexerState
  -- ^ The state to return to after character reference processing.
  , Lexer s -> STRef s LexerSkip
lexerSkip     :: STRef s LexerSkip
  -- ^ The skip next linefeed flag.
  , Lexer s -> STRef s (DList BS)
lexerErrors   :: STRef s (DList BS)
  -- ^ The lexer errors.
  , Lexer s -> STRef s Int
lexerCode     :: STRef s Int
  -- ^ The character reference code.
  }

-- | Default instance for lexer options.
instance Default LexerOptions where
  def :: LexerOptions
def = LexerOptions :: BS -> Bool -> Bool -> LexerOptions
LexerOptions
    { lexerOptionInput :: BS
lexerOptionInput          = BS
bsEmpty
    , lexerOptionLogErrors :: Bool
lexerOptionLogErrors      = Bool
False
    , lexerOptionIgnoreEntities :: Bool
lexerOptionIgnoreEntities = Bool
False
    }

-- | Defines the lexer state.
data LexerState
  = StateData
  | StateRCDATA
  | StateRAWTEXT
  | StateScriptData
  | StatePLAINTEXT
  | StateTagOpen
  | StateEndTagOpen
  | StateTagName
  | StateRCDATALessThan
  | StateRCDATAEndTagOpen
  | StateRCDATAEndTagName
  | StateRAWTEXTLessThan
  | StateRAWTEXTEndTagOpen
  | StateRAWTEXTEndTagName
  | StateScriptDataLessThan
  | StateScriptDataEndTagOpen
  | StateScriptDataEndTagName
  | StateScriptDataEscapeStart
  | StateScriptDataEscapeStartDash
  | StateScriptDataEscaped
  | StateScriptDataEscapedDash
  | StateScriptDataEscapedDashDash
  | StateScriptDataEscapedLessThan
  | StateScriptDataEscapedEndTagOpen
  | StateScriptDataEscapedEndTagName
  | StateScriptDataDoubleEscapedStart
  | StateScriptDataDoubleEscaped
  | StateScriptDataDoubleEscapedDash
  | StateScriptDataDoubleEscapedDashDash
  | StateScriptDataDoubleEscapedLessThan
  | StateScriptDataDoubleEscapeEnd
  | StateBeforeAttrName
  | StateAttrName
  | StateAfterAttrName
  | StateBeforeAttrValue
  | StateAttrValueDoubleQuoted
  | StateAttrValueSingleQuoted
  | StateAttrValueUnquoted
  | StateAfterAttrValue
  | StateSelfClosingStartTag
  | StateBogusComment
  | StateMarkupDeclarationOpen
  | StateCommentStart
  | StateCommentStartDash
  | StateComment
  | StateCommentLessThan
  | StateCommentLessThanBang
  | StateCommentLessThanBangDash
  | StateCommentLessThanBangDashDash
  | StateCommentEndDash
  | StateCommentEnd
  | StateCommentEndBang
  | StateDoctype
  | StateBeforeDoctypeName
  | StateDoctypeName
  | StateAfterDoctypeName
  | StateAfterDoctypePublicKeyword
  | StateBeforeDoctypePublicId
  | StateDoctypePublicIdDoubleQuoted
  | StateDoctypePublicIdSingleQuoted
  | StateAfterDoctypePublicId
  | StateBetweenDoctypePublicAndSystem
  | StateAfterDoctypeSystemKeyword
  | StateBeforeDoctypeSystemId
  | StateDoctypeSystemIdDoubleQuoted
  | StateDoctypeSystemIdSingleQuoted
  | StateAfterDoctypeSystemId
  | StateBogusDoctype
  | StateCDATASection
  | StateCDATASectionBracket
  | StateCDATASectionEnd
  | StateCharacterReference
  | StateNamedCharacterReference
  | StateAmbiguousAmpersand
  | StateNumericCharacterReference
  | StateHexCharacterReferenceStart
  | StateDecimalCharacterReferenceStart
  | StateHexCharacterReference
  | StateDecimalCharacterReference
  | StateNumericCharacterReferenceEnd
    deriving (Int -> LexerState -> ShowS
[LexerState] -> ShowS
LexerState -> String
(Int -> LexerState -> ShowS)
-> (LexerState -> String)
-> ([LexerState] -> ShowS)
-> Show LexerState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LexerState] -> ShowS
$cshowList :: [LexerState] -> ShowS
show :: LexerState -> String
$cshow :: LexerState -> String
showsPrec :: Int -> LexerState -> ShowS
$cshowsPrec :: Int -> LexerState -> ShowS
Show, LexerState -> LexerState -> Bool
(LexerState -> LexerState -> Bool)
-> (LexerState -> LexerState -> Bool) -> Eq LexerState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LexerState -> LexerState -> Bool
$c/= :: LexerState -> LexerState -> Bool
== :: LexerState -> LexerState -> Bool
$c== :: LexerState -> LexerState -> Bool
Eq, Eq LexerState
Eq LexerState
-> (LexerState -> LexerState -> Ordering)
-> (LexerState -> LexerState -> Bool)
-> (LexerState -> LexerState -> Bool)
-> (LexerState -> LexerState -> Bool)
-> (LexerState -> LexerState -> Bool)
-> (LexerState -> LexerState -> LexerState)
-> (LexerState -> LexerState -> LexerState)
-> Ord LexerState
LexerState -> LexerState -> Bool
LexerState -> LexerState -> Ordering
LexerState -> LexerState -> LexerState
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: LexerState -> LexerState -> LexerState
$cmin :: LexerState -> LexerState -> LexerState
max :: LexerState -> LexerState -> LexerState
$cmax :: LexerState -> LexerState -> LexerState
>= :: LexerState -> LexerState -> Bool
$c>= :: LexerState -> LexerState -> Bool
> :: LexerState -> LexerState -> Bool
$c> :: LexerState -> LexerState -> Bool
<= :: LexerState -> LexerState -> Bool
$c<= :: LexerState -> LexerState -> Bool
< :: LexerState -> LexerState -> Bool
$c< :: LexerState -> LexerState -> Bool
compare :: LexerState -> LexerState -> Ordering
$ccompare :: LexerState -> LexerState -> Ordering
$cp1Ord :: Eq LexerState
Ord)

lexerDispatch :: LexerState -> Lexer s -> ST s ()
lexerDispatch :: LexerState -> Lexer s -> ST s ()
lexerDispatch = \case
  LexerState
StateData ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doData
  LexerState
StateRCDATA ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRCDATA
  LexerState
StateRAWTEXT ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRAWTEXT
  LexerState
StateScriptData ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptData
  LexerState
StatePLAINTEXT ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doPLAINTEXT
  LexerState
StateTagOpen ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doTagOpen
  LexerState
StateEndTagOpen ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doEndTagOpen
  LexerState
StateTagName ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doTagName
  LexerState
StateRCDATALessThan ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRCDATALessThan
  LexerState
StateRCDATAEndTagOpen ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRCDATAEndTagOpen
  LexerState
StateRCDATAEndTagName ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRCDATAEndTagName
  LexerState
StateRAWTEXTLessThan ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRAWTEXTLessThan
  LexerState
StateRAWTEXTEndTagOpen ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRAWTEXTEndTagOpen
  LexerState
StateRAWTEXTEndTagName ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRAWTEXTEndTagName
  LexerState
StateScriptDataLessThan ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataLessThan
  LexerState
StateScriptDataEndTagOpen ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEndTagOpen
  LexerState
StateScriptDataEndTagName ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEndTagName
  LexerState
StateScriptDataEscapeStart ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapeStart
  LexerState
StateScriptDataEscapeStartDash ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapeStartDash
  LexerState
StateScriptDataEscaped ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscaped
  LexerState
StateScriptDataEscapedDash ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedDash
  LexerState
StateScriptDataEscapedDashDash ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedDashDash
  LexerState
StateScriptDataEscapedLessThan ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedLessThan
  LexerState
StateScriptDataEscapedEndTagOpen ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedEndTagOpen
  LexerState
StateScriptDataEscapedEndTagName ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedEndTagName
  LexerState
StateScriptDataDoubleEscapedStart ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataDoubleEscapedStart
  LexerState
StateScriptDataDoubleEscaped ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataDoubleEscaped
  LexerState
StateScriptDataDoubleEscapedDash ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataDoubleEscapedDash
  LexerState
StateScriptDataDoubleEscapedDashDash ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataDoubleEscapedDashDash
  LexerState
StateScriptDataDoubleEscapedLessThan ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataDoubleEscapedLessThan
  LexerState
StateScriptDataDoubleEscapeEnd ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataDoubleEscapeEnd
  LexerState
StateBeforeAttrName ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrName
  LexerState
StateAttrName ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrName
  LexerState
StateAfterAttrName ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterAttrName
  LexerState
StateBeforeAttrValue ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrValue
  LexerState
StateAttrValueDoubleQuoted ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrValueDoubleQuoted
  LexerState
StateAttrValueSingleQuoted ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrValueSingleQuoted
  LexerState
StateAttrValueUnquoted ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrValueUnquoted
  LexerState
StateAfterAttrValue ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterAttrValue
  LexerState
StateSelfClosingStartTag ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doSelfClosingStartTag
  LexerState
StateBogusComment ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusComment
  LexerState
StateMarkupDeclarationOpen ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doMarkupDeclarationOpen
  LexerState
StateCommentStart ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentStart
  LexerState
StateCommentStartDash ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentStartDash
  LexerState
StateComment ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doComment
  LexerState
StateCommentLessThan ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentLessThan
  LexerState
StateCommentLessThanBang ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentLessThanBang
  LexerState
StateCommentLessThanBangDash ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentLessThanBangDash
  LexerState
StateCommentLessThanBangDashDash ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentLessThanBangDashDash
  LexerState
StateCommentEndDash ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentEndDash
  LexerState
StateCommentEnd ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentEnd
  LexerState
StateCommentEndBang ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentEndBang
  LexerState
StateDoctype ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctype
  LexerState
StateBeforeDoctypeName ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeDoctypeName
  LexerState
StateDoctypeName ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeName
  LexerState
StateAfterDoctypeName ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterDoctypeName
  LexerState
StateAfterDoctypePublicKeyword ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterDoctypePublicKeyword
  LexerState
StateBeforeDoctypePublicId ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeDoctypePublicId
  LexerState
StateDoctypePublicIdDoubleQuoted ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypePublicIdDoubleQuoted
  LexerState
StateDoctypePublicIdSingleQuoted ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypePublicIdSingleQuoted
  LexerState
StateAfterDoctypePublicId ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterDoctypePublicId
  LexerState
StateBetweenDoctypePublicAndSystem ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBetweenDoctypePublicAndSystem
  LexerState
StateAfterDoctypeSystemKeyword ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterDoctypeSystemKeyword
  LexerState
StateBeforeDoctypeSystemId ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeDoctypeSystemId
  LexerState
StateDoctypeSystemIdDoubleQuoted ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeSystemIdDoubleQuoted
  LexerState
StateDoctypeSystemIdSingleQuoted ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeSystemIdSingleQuoted
  LexerState
StateAfterDoctypeSystemId ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterDoctypeSystemId
  LexerState
StateBogusDoctype ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusDoctype
  LexerState
StateCDATASection ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCDATASection
  LexerState
StateCDATASectionBracket ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCDATASectionBracket
  LexerState
StateCDATASectionEnd ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCDATASectionEnd
  LexerState
StateCharacterReference ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCharacterReference
  LexerState
StateNamedCharacterReference ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doNamedCharacterReference
  LexerState
StateAmbiguousAmpersand ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAmbiguousAmpersand
  LexerState
StateNumericCharacterReference ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doNumericCharacterReference
  LexerState
StateHexCharacterReferenceStart ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doHexCharacterReferenceStart
  LexerState
StateDecimalCharacterReferenceStart ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDecimalCharacterReferenceStart
  LexerState
StateHexCharacterReference ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doHexCharacterReference
  LexerState
StateDecimalCharacterReference ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDecimalCharacterReference
  LexerState
StateNumericCharacterReferenceEnd ->
    Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doNumericCharacterReferenceEnd

-- | Makes a new lexer.
lexerNew :: LexerOptions -> ST s (Either BS (Lexer s))
lexerNew :: LexerOptions -> ST s (Either BS (Lexer s))
lexerNew o :: LexerOptions
o@LexerOptions{Bool
BS
lexerOptionIgnoreEntities :: Bool
lexerOptionLogErrors :: Bool
lexerOptionInput :: BS
lexerOptionIgnoreEntities :: LexerOptions -> Bool
lexerOptionLogErrors :: LexerOptions -> Bool
lexerOptionInput :: LexerOptions -> BS
..}
  | Just Int
i <- Word8 -> BS -> Maybe Int
bsElemIndex Word8
0 BS
lexerOptionInput =
      Either BS (Lexer s) -> ST s (Either BS (Lexer s))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either BS (Lexer s) -> ST s (Either BS (Lexer s)))
-> Either BS (Lexer s) -> ST s (Either BS (Lexer s))
forall a b. (a -> b) -> a -> b
$ BS -> Either BS (Lexer s)
forall a b. a -> Either a b
Left (BS -> Either BS (Lexer s)) -> BS -> Either BS (Lexer s)
forall a b. (a -> b) -> a -> b
$ [BS] -> BS
bsConcat [ BS
"input contains null at ", String -> BS
bcPack (String -> BS) -> String -> BS
forall a b. (a -> b) -> a -> b
$ Int -> String
forall a. Show a => a -> String
show Int
i ]
  | Bool
otherwise =
      Lexer s -> Either BS (Lexer s)
forall a b. b -> Either a b
Right (Lexer s -> Either BS (Lexer s))
-> ST s (Lexer s) -> ST s (Either BS (Lexer s))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LexerOptions -> ST s (Lexer s)
forall s. LexerOptions -> ST s (Lexer s)
lexerMake LexerOptions
o

-- | Makes a new lexer.
lexerMake :: LexerOptions -> ST s (Lexer s)
lexerMake :: LexerOptions -> ST s (Lexer s)
lexerMake LexerOptions{Bool
BS
lexerOptionIgnoreEntities :: Bool
lexerOptionLogErrors :: Bool
lexerOptionInput :: BS
lexerOptionIgnoreEntities :: LexerOptions -> Bool
lexerOptionLogErrors :: LexerOptions -> Bool
lexerOptionInput :: LexerOptions -> BS
..} = do
  STRef s Int
offset <- Int -> ST s (STRef s Int)
forall a s. a -> ST s (STRef s a)
newSTRef Int
0
  STRef s LexerState
state  <- LexerState -> ST s (STRef s LexerState)
forall a s. a -> ST s (STRef s a)
newSTRef LexerState
StateData
  STRef s LexerState
ret    <- LexerState -> ST s (STRef s LexerState)
forall a s. a -> ST s (STRef s a)
newSTRef LexerState
StateData
  STRef s (TokenBuffer s)
token  <- ST s (STRef s (TokenBuffer s))
forall s. ST s (STRef s (TokenBuffer s))
tokenBuffer
  STRef s (Buffer s)
buffer <- ST s (STRef s (Buffer s))
forall s. ST s (STRef s (Buffer s))
bufferNew
  STRef s [Word8]
last   <- [Word8] -> ST s (STRef s [Word8])
forall a s. a -> ST s (STRef s a)
newSTRef []
  STRef s LexerSkip
skip   <- LexerSkip -> ST s (STRef s LexerSkip)
forall a s. a -> ST s (STRef s a)
newSTRef LexerSkip
LexerSkipNone
  STRef s (DList BS)
errors <- DList BS -> ST s (STRef s (DList BS))
forall a s. a -> ST s (STRef s a)
newSTRef DList BS
forall a. DList a
D.empty
  STRef s Int
code   <- Int -> ST s (STRef s Int)
forall a s. a -> ST s (STRef s a)
newSTRef Int
0
  Lexer s -> ST s (Lexer s)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Lexer s -> ST s (Lexer s)) -> Lexer s -> ST s (Lexer s)
forall a b. (a -> b) -> a -> b
$ Lexer :: forall s.
BS
-> Bool
-> Bool
-> STRef s Int
-> STRef s (TokenBuffer s)
-> STRef s (Buffer s)
-> STRef s [Word8]
-> STRef s LexerState
-> STRef s LexerState
-> STRef s LexerSkip
-> STRef s (DList BS)
-> STRef s Int
-> Lexer s
Lexer
    { lexerData :: BS
lexerData   = BS
lexerOptionInput
    , lexerIgnore :: Bool
lexerIgnore = Bool
lexerOptionIgnoreEntities
    , lexerLog :: Bool
lexerLog    = Bool
lexerOptionLogErrors
    , lexerOffset :: STRef s Int
lexerOffset = STRef s Int
offset
    , lexerToken :: STRef s (TokenBuffer s)
lexerToken  = STRef s (TokenBuffer s)
token
    , lexerBuffer :: STRef s (Buffer s)
lexerBuffer = STRef s (Buffer s)
buffer
    , lexerLast :: STRef s [Word8]
lexerLast   = STRef s [Word8]
last
    , lexerState :: STRef s LexerState
lexerState  = STRef s LexerState
state
    , lexerReturn :: STRef s LexerState
lexerReturn = STRef s LexerState
ret
    , lexerSkip :: STRef s LexerSkip
lexerSkip   = STRef s LexerSkip
skip
    , lexerErrors :: STRef s (DList BS)
lexerErrors = STRef s (DList BS)
errors
    , lexerCode :: STRef s Int
lexerCode   = STRef s Int
code
    }

-- | Sets the RCDATA mode.
lexerSetRCDATA :: Lexer s -> ST s ()
lexerSetRCDATA :: Lexer s -> ST s ()
lexerSetRCDATA Lexer{Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = STRef s LexerState -> LexerState -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s LexerState
lexerState LexerState
StateRCDATA

-- | Sets the raw text mode.
lexerSetRAWTEXT :: Lexer s -> ST s ()
lexerSetRAWTEXT :: Lexer s -> ST s ()
lexerSetRAWTEXT Lexer{Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = STRef s LexerState -> LexerState -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s LexerState
lexerState LexerState
StateRAWTEXT

-- | Sets the plain text mode.
lexerSetPLAINTEXT :: Lexer s -> ST s ()
lexerSetPLAINTEXT :: Lexer s -> ST s ()
lexerSetPLAINTEXT Lexer{Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = STRef s LexerState -> LexerState -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s LexerState
lexerState LexerState
StatePLAINTEXT

-- | Sets the script data mode.
lexerSetScriptData :: Lexer s -> ST s ()
lexerSetScriptData :: Lexer s -> ST s ()
lexerSetScriptData Lexer{Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = STRef s LexerState -> LexerState -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s LexerState
lexerState LexerState
StateScriptData

-- | Sets the skip next linefeed flag.
lexerSkipNextLF :: Lexer s -> ST s ()
lexerSkipNextLF :: Lexer s -> ST s ()
lexerSkipNextLF Lexer{Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = STRef s LexerSkip -> LexerSkip -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s LexerSkip
lexerSkip LexerSkip
LexerSkipLF

-- | Gets the next token from a lexer.
lexerNext :: Lexer s -> ST s Token
lexerNext :: Lexer s -> ST s Token
lexerNext x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} =
  ST s Token
skip
  where
    skip :: ST s Token
skip = do
      Token
t <- ST s Token
next
      case Token
t of
        TChar Word8
0x10 ->
          STRef s LexerSkip -> ST s LexerSkip
forall s a. STRef s a -> ST s a
rref STRef s LexerSkip
lexerSkip ST s LexerSkip -> (LexerSkip -> ST s Token) -> ST s Token
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
            LexerSkip
LexerSkipLF ->
              STRef s LexerSkip -> LexerSkip -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s LexerSkip
lexerSkip LexerSkip
LexerSkipNone ST s () -> ST s Token -> ST s Token
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ST s Token
skip
            LexerSkip
LexerSkipNone ->
              Token -> ST s Token
forall (f :: * -> *) a. Applicative f => a -> f a
pure Token
t
        Token
_otherwise ->
          Token -> ST s Token
forall (f :: * -> *) a. Applicative f => a -> f a
pure Token
t

    next :: ST s Token
next = do
      Int
i <- STRef s (TokenBuffer s) -> ST s Int
forall s. STRef s (TokenBuffer s) -> ST s Int
tokenNext STRef s (TokenBuffer s)
lexerToken
      if Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
         then do
           STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenReset STRef s (TokenBuffer s)
lexerToken
           LexerState
s <- STRef s LexerState -> ST s LexerState
forall s a. STRef s a -> ST s a
rref STRef s LexerState
lexerState
           LexerState -> Lexer s -> ST s ()
forall s. LexerState -> Lexer s -> ST s ()
lexerDispatch LexerState
s Lexer s
x
           Int
i <- STRef s (TokenBuffer s) -> ST s Int
forall s. STRef s (TokenBuffer s) -> ST s Int
tokenFirst STRef s (TokenBuffer s)
lexerToken
           if Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
              then Token -> ST s Token
forall (f :: * -> *) a. Applicative f => a -> f a
pure Token
TEOF
              else Int -> STRef s (TokenBuffer s) -> ST s Token
forall s. Int -> STRef s (TokenBuffer s) -> ST s Token
tokenPack Int
i STRef s (TokenBuffer s)
lexerToken
         else do
           Int -> STRef s (TokenBuffer s) -> ST s Token
forall s. Int -> STRef s (TokenBuffer s) -> ST s Token
tokenPack Int
i STRef s (TokenBuffer s)
lexerToken

-- | Gets the next word from a lexer.
nextWord :: Lexer s -> ST s Word8
nextWord :: Lexer s -> ST s Word8
nextWord Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Int
offset <- STRef s Int -> ST s Int
forall s a. STRef s a -> ST s a
rref STRef s Int
lexerOffset
  if | Int
offset Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< BS -> Int
bsLen BS
lexerData -> do
         STRef s Int -> Int -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s Int
lexerOffset (Int
offset Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
         Word8 -> ST s Word8
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word8 -> ST s Word8) -> Word8 -> ST s Word8
forall a b. (a -> b) -> a -> b
$ BS -> Int -> Word8
bsIndex BS
lexerData Int
offset
     | Bool
otherwise ->
         Word8 -> ST s Word8
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word8
chrEOF

-- | Gets the next word from a lexer without advancing.
peekWord :: Lexer s -> ST s Word8
peekWord :: Lexer s -> ST s Word8
peekWord Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Int
offset <- STRef s Int -> ST s Int
forall s a. STRef s a -> ST s a
rref STRef s Int
lexerOffset
  if | Int
offset Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< BS -> Int
bsLen BS
lexerData ->
         Word8 -> ST s Word8
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word8 -> ST s Word8) -> Word8 -> ST s Word8
forall a b. (a -> b) -> a -> b
$ BS -> Int -> Word8
bsIndex BS
lexerData Int
offset
     | Bool
otherwise ->
         Word8 -> ST s Word8
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word8
chrEOF

-- | Moves the lexer back one word.
backWord :: Lexer s -> ST s ()
backWord :: Lexer s -> ST s ()
backWord Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = STRef s Int -> (Int -> Int) -> ST s ()
forall s a. STRef s a -> (a -> a) -> ST s ()
uref STRef s Int
lexerOffset (Int -> Int -> Int
forall a. Num a => a -> a -> a
subtract Int
1)

-- | Skips the specified number of words.
skipWord :: Lexer s -> Int -> ST s ()
skipWord :: Lexer s -> Int -> ST s ()
skipWord Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} Int
n = STRef s Int -> (Int -> Int) -> ST s ()
forall s a. STRef s a -> (a -> a) -> ST s ()
uref STRef s Int
lexerOffset (Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
n)

-- | Gets an indexing function from the current lexer offset.
dataIndexer :: Lexer s -> ST s (Int -> Word8)
dataIndexer :: Lexer s -> ST s (Int -> Word8)
dataIndexer Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Int
offset <- STRef s Int -> ST s Int
forall s a. STRef s a -> ST s a
rref STRef s Int
lexerOffset
  (Int -> Word8) -> ST s (Int -> Word8)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Int -> Word8) -> ST s (Int -> Word8))
-> (Int -> Word8) -> ST s (Int -> Word8)
forall a b. (a -> b) -> a -> b
$ \Int
i -> BS -> Int -> Word8
bsIndex BS
lexerData (Int
offset Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i)

-- | Gets the remaining number of words.
dataRemain :: Lexer s -> ST s Int
dataRemain :: Lexer s -> ST s Int
dataRemain Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Int
offset <- STRef s Int -> ST s Int
forall s a. STRef s a -> ST s a
rref STRef s Int
lexerOffset
  Int -> ST s Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> ST s Int) -> Int -> ST s Int
forall a b. (a -> b) -> a -> b
$ BS -> Int
bsLen BS
lexerData Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
offset

-- | Emits the last token in the token buffer.
emit :: Lexer s -> ST s ()
emit :: Lexer s -> ST s ()
emit Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  STRef s (TokenBuffer s) -> ST s Int
forall s. STRef s (TokenBuffer s) -> ST s Int
tokenTail STRef s (TokenBuffer s)
lexerToken ST s Int -> (Int -> ST s (Maybe [Word8])) -> ST s (Maybe [Word8])
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8]))
-> STRef s (TokenBuffer s) -> Int -> ST s (Maybe [Word8])
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8])
forall s. Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8])
tokenTagStartName STRef s (TokenBuffer s)
lexerToken ST s (Maybe [Word8]) -> (Maybe [Word8] -> ST s ()) -> ST s ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Just [Word8]
a  -> STRef s [Word8] -> [Word8] -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s [Word8]
lexerLast [Word8]
a
    Maybe [Word8]
Nothing -> () -> ST s ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

-- | Emits a character token.
emitChar :: Lexer s -> Word8 -> ST s ()
emitChar :: Lexer s -> Word8 -> ST s ()
emitChar x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} Word8
w = do
  Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
w STRef s (TokenBuffer s)
lexerToken
  Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x

-- | Emits the characters in the buffer.
emitBuffer :: Lexer s -> ST s ()
emitBuffer :: Lexer s -> ST s ()
emitBuffer x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  (Word8 -> ST s ()) -> STRef s (Buffer s) -> ST s ()
forall s. (Word8 -> ST s ()) -> STRef s (Buffer s) -> ST s ()
bufferApply (Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x) STRef s (Buffer s)
lexerBuffer
  STRef s (Buffer s) -> ST s ()
forall s. STRef s (Buffer s) -> ST s ()
bufferReset STRef s (Buffer s)
lexerBuffer

-- | Sets the lexer state.
state :: Lexer s -> LexerState -> ST s ()
state :: Lexer s -> LexerState -> ST s ()
state Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = STRef s LexerState -> LexerState -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s LexerState
lexerState

-- | Sets the lexer return state.
returnSet :: Lexer s -> LexerState -> ST s ()
returnSet :: Lexer s -> LexerState -> ST s ()
returnSet x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = STRef s LexerState -> LexerState -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s LexerState
lexerReturn

-- | Gets the lexer return state.
returnGet :: Lexer s -> ST s LexerState
returnGet :: Lexer s -> ST s LexerState
returnGet x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = STRef s LexerState -> ST s LexerState
forall s a. STRef s a -> ST s a
rref STRef s LexerState
lexerReturn

-- | Switches to the return state.
returnState :: Lexer s -> ST s ()
returnState :: Lexer s -> ST s ()
returnState Lexer s
x = Lexer s -> ST s LexerState
forall s. Lexer s -> ST s LexerState
returnGet Lexer s
x ST s LexerState -> (LexerState -> ST s ()) -> ST s ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (LexerState -> Lexer s -> ST s ())
-> Lexer s -> LexerState -> ST s ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip LexerState -> Lexer s -> ST s ()
forall s. LexerState -> Lexer s -> ST s ()
lexerDispatch Lexer s
x

-- | Handles parse errors.
parseError :: Lexer s -> BS -> ST s ()
parseError :: Lexer s -> BS -> ST s ()
parseError x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} =
  Bool -> ST s () -> ST s ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
lexerLog (ST s () -> ST s ()) -> (BS -> ST s ()) -> BS -> ST s ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (STRef s (DList BS) -> (DList BS -> DList BS) -> ST s ()
forall s a. STRef s a -> (a -> a) -> ST s ()
uref STRef s (DList BS)
lexerErrors ((DList BS -> DList BS) -> ST s ())
-> (BS -> DList BS -> DList BS) -> BS -> ST s ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DList BS -> BS -> DList BS) -> BS -> DList BS -> DList BS
forall a b c. (a -> b -> c) -> b -> a -> c
flip DList BS -> BS -> DList BS
forall a. DList a -> a -> DList a
D.snoc)

-- | Determines if the current token is an appropriate end tag.
appropriateEndTag :: Lexer s -> ST s Bool
appropriateEndTag :: Lexer s -> ST s Bool
appropriateEndTag x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  STRef s (TokenBuffer s) -> ST s Int
forall s. STRef s (TokenBuffer s) -> ST s Int
tokenTail STRef s (TokenBuffer s)
lexerToken ST s Int -> (Int -> ST s (Maybe [Word8])) -> ST s (Maybe [Word8])
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8]))
-> STRef s (TokenBuffer s) -> Int -> ST s (Maybe [Word8])
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8])
forall s. Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8])
tokenTagEndName STRef s (TokenBuffer s)
lexerToken ST s (Maybe [Word8]) -> (Maybe [Word8] -> ST s Bool) -> ST s Bool
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Just [Word8]
a  -> ([Word8] -> [Word8] -> Bool
forall a. Eq a => a -> a -> Bool
==[Word8]
a) ([Word8] -> Bool) -> ST s [Word8] -> ST s Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> STRef s [Word8] -> ST s [Word8]
forall s a. STRef s a -> ST s a
rref STRef s [Word8]
lexerLast
    Maybe [Word8]
Nothing -> Bool -> ST s Bool
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False

-- | Determines if an attribute value is currently being consumed.
consumingAttibute :: Lexer s -> ST s Bool
consumingAttibute :: Lexer s -> ST s Bool
consumingAttibute x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  LexerState
a <- Lexer s -> ST s LexerState
forall s. Lexer s -> ST s LexerState
returnGet Lexer s
x
  Bool -> ST s Bool
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Bool -> ST s Bool) -> Bool -> ST s Bool
forall a b. (a -> b) -> a -> b
$ (LexerState -> Bool) -> [LexerState] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (LexerState -> LexerState -> Bool
forall a. Eq a => a -> a -> Bool
==LexerState
a)
    [ LexerState
StateAttrValueDoubleQuoted
    , LexerState
StateAttrValueSingleQuoted
    , LexerState
StateAttrValueUnquoted
    ]

-- | Flushes the code points stored in the buffer.
flushCodePoints :: Lexer s -> ST s ()
flushCodePoints :: Lexer s -> ST s ()
flushCodePoints x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Bool
a <- Lexer s -> ST s Bool
forall s. Lexer s -> ST s Bool
consumingAttibute Lexer s
x
  if | Bool
a -> do
         (Word8 -> ST s ()) -> STRef s (Buffer s) -> ST s ()
forall s. (Word8 -> ST s ()) -> STRef s (Buffer s) -> ST s ()
bufferApply ((Word8 -> STRef s (TokenBuffer s) -> ST s ())
-> STRef s (TokenBuffer s) -> Word8 -> ST s ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenAttrValAppend STRef s (TokenBuffer s)
lexerToken) STRef s (Buffer s)
lexerBuffer
         STRef s (Buffer s) -> ST s ()
forall s. STRef s (Buffer s) -> ST s ()
bufferReset STRef s (Buffer s)
lexerBuffer
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emitBuffer Lexer s
x

-- 12.2.5.1 Data state
doData :: Lexer s -> ST s ()
doData :: Lexer s -> ST s ()
doData x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrAmpersand -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
returnSet Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCharacterReference Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLess -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doTagOpen Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doData Lexer s
x

-- 12.2.5.2 RCDATA state
doRCDATA :: Lexer s -> ST s ()
doRCDATA :: Lexer s -> ST s ()
doRCDATA x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrAmpersand -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
returnSet Lexer s
x LexerState
StateRCDATA
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCharacterReference Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLess -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRCDATALessThan Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRCDATA Lexer s
x

-- 12.2.5.3 RAWTEXT state
doRAWTEXT :: Lexer s -> ST s ()
doRAWTEXT :: Lexer s -> ST s ()
doRAWTEXT x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLess -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRAWTEXTLessThan Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRAWTEXT Lexer s
x

-- 12.2.5.4 Script data state
doScriptData :: Lexer s -> ST s ()
doScriptData :: Lexer s -> ST s ()
doScriptData x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLess -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataLessThan Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptData Lexer s
x

-- 12.2.5.5 PLAINTEXT state
doPLAINTEXT :: Lexer s -> ST s ()
doPLAINTEXT :: Lexer s -> ST s ()
doPLAINTEXT x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doPLAINTEXT Lexer s
x

-- 12.2.5.6 Tag open state
doTagOpen :: Lexer s -> ST s ()
doTagOpen :: Lexer s -> ST s ()
doTagOpen x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrExclamation -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doMarkupDeclarationOpen Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doEndTagOpen Lexer s
x
     | Word8 -> Bool
chrASCIIAlpha Word8
c -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenTagStartInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doTagName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrQuestion -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"unexpected-question-mark-instead-of-tag-name"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenCommentInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusComment Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-before-tag-name"
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
chrLess STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"invalid-first-character-of-tag-name"
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doData Lexer s
x

-- 12.2.5.7 End tag open state
doEndTagOpen :: Lexer s -> ST s ()
doEndTagOpen :: Lexer s -> ST s ()
doEndTagOpen x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8 -> Bool
chrASCIIAlpha Word8
c -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenTagEndInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doTagName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-end-tag-name"
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doData Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-before-tag-name"
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
chrLess STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
chrSolidus STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"invalid-first-character-of-tag-name"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenCommentInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusComment Lexer s
x

-- 12.2.5.8 Tag name state
doTagName :: Lexer s -> ST s ()
doTagName :: Lexer s -> ST s ()
doTagName x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doSelfClosingStartTag Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8 -> Bool
chrASCIIUpperAlpha Word8
c -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenTagNameAppend (Word8 -> Word8
chrToLower Word8
c) STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doTagName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-tag"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenTagNameAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doTagName Lexer s
x

-- 12.2.5.9 RCDATA less-than sign state
doRCDATALessThan :: Lexer s -> ST s ()
doRCDATALessThan :: Lexer s -> ST s ()
doRCDATALessThan x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus -> do
         STRef s (Buffer s) -> ST s ()
forall s. STRef s (Buffer s) -> ST s ()
bufferReset STRef s (Buffer s)
lexerBuffer
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRCDATAEndTagOpen Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
chrLess STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRCDATA Lexer s
x

-- 12.2.5.10 RCDATA end tag open state
doRCDATAEndTagOpen :: Lexer s -> ST s ()
doRCDATAEndTagOpen :: Lexer s -> ST s ()
doRCDATAEndTagOpen x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8 -> Bool
chrASCIIAlpha Word8
c -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenTagEndInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRCDATAEndTagName Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
chrLess STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
chrSolidus STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRCDATA Lexer s
x

-- 12.2.5.11 RCDATA end tag name state
doRCDATAEndTagName :: Lexer s -> ST s ()
doRCDATAEndTagName :: Lexer s -> ST s ()
doRCDATAEndTagName x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  Bool
a <- Lexer s -> ST s Bool
forall s. Lexer s -> ST s Bool
appropriateEndTag Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         if Bool
a
         then do
           Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrName Lexer s
x
         else do
           ST s ()
anythingElse
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus -> do
         if Bool
a
         then do
           Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doSelfClosingStartTag Lexer s
x
         else do
           ST s ()
anythingElse
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         if Bool
a
         then do
           Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
           Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
         else do
           ST s ()
anythingElse
     | Word8 -> Bool
chrASCIIUpperAlpha Word8
c -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenTagNameAppend (Word8 -> Word8
chrToLower Word8
c) STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend Word8
c STRef s (Buffer s)
lexerBuffer
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRCDATAEndTagName Lexer s
x
     | Word8 -> Bool
chrASCIILowerAlpha Word8
c -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenTagNameAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend Word8
c STRef s (Buffer s)
lexerBuffer
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRCDATAEndTagName Lexer s
x
     | Bool
otherwise -> do
         ST s ()
anythingElse
  where
    anythingElse :: ST s ()
anythingElse = do
      STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDrop STRef s (TokenBuffer s)
lexerToken
      Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrLess
      Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrSolidus
      Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emitBuffer Lexer s
x
      Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
      Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRCDATA Lexer s
x

-- 12.2.5.12 RAWTEXT less-than sign state
doRAWTEXTLessThan :: Lexer s -> ST s ()
doRAWTEXTLessThan :: Lexer s -> ST s ()
doRAWTEXTLessThan x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus -> do
         STRef s (Buffer s) -> ST s ()
forall s. STRef s (Buffer s) -> ST s ()
bufferReset STRef s (Buffer s)
lexerBuffer
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRAWTEXTEndTagOpen Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
chrLess STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRAWTEXT Lexer s
x

-- 12.2.5.13 RAWTEXT end tag open state
doRAWTEXTEndTagOpen :: Lexer s -> ST s ()
doRAWTEXTEndTagOpen :: Lexer s -> ST s ()
doRAWTEXTEndTagOpen x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8 -> Bool
chrASCIIAlpha Word8
c -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenTagEndInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRAWTEXTEndTagName Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrLess
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrSolidus
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRAWTEXT Lexer s
x

-- 12.2.5.14 RAWTEXT end tag name state
doRAWTEXTEndTagName :: Lexer s -> ST s ()
doRAWTEXTEndTagName :: Lexer s -> ST s ()
doRAWTEXTEndTagName x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  Bool
a <- Lexer s -> ST s Bool
forall s. Lexer s -> ST s Bool
appropriateEndTag Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         if Bool
a
         then do
           Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrName Lexer s
x
         else do
           ST s ()
anythingElse
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus -> do
         if Bool
a
         then do
           Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doSelfClosingStartTag Lexer s
x
         else do
           ST s ()
anythingElse
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         if Bool
a
         then do
           Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
           Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
         else do
           ST s ()
anythingElse
     | Word8 -> Bool
chrASCIIUpperAlpha Word8
c -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenTagNameAppend (Word8 -> Word8
chrToLower Word8
c) STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend Word8
c STRef s (Buffer s)
lexerBuffer
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRAWTEXTEndTagName Lexer s
x
     | Word8 -> Bool
chrASCIILowerAlpha Word8
c -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenTagNameAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend Word8
c STRef s (Buffer s)
lexerBuffer
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRAWTEXTEndTagName Lexer s
x
     | Bool
otherwise -> do
         ST s ()
anythingElse
  where
    anythingElse :: ST s ()
anythingElse = do
      STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDrop STRef s (TokenBuffer s)
lexerToken
      Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrLess
      Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrSolidus
      Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emitBuffer Lexer s
x
      Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
      Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doRAWTEXT Lexer s
x

-- 12.2.5.15 Script data less-than sign state
doScriptDataLessThan :: Lexer s -> ST s ()
doScriptDataLessThan :: Lexer s -> ST s ()
doScriptDataLessThan x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus -> do
         STRef s (Buffer s) -> ST s ()
forall s. STRef s (Buffer s) -> ST s ()
bufferReset STRef s (Buffer s)
lexerBuffer
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEndTagOpen Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrExclamation -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
chrLess STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
chrExclamation STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapeStart Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
chrLess STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptData Lexer s
x

-- 12.2.5.16 Script data end tag open state
doScriptDataEndTagOpen :: Lexer s -> ST s ()
doScriptDataEndTagOpen :: Lexer s -> ST s ()
doScriptDataEndTagOpen x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8 -> Bool
chrASCIIAlpha Word8
c -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenTagEndInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEndTagName Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrLess
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrSolidus
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptData Lexer s
x

-- 12.2.5.17 Script data end tag name state
doScriptDataEndTagName :: Lexer s -> ST s ()
doScriptDataEndTagName :: Lexer s -> ST s ()
doScriptDataEndTagName x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  Bool
a <- Lexer s -> ST s Bool
forall s. Lexer s -> ST s Bool
appropriateEndTag Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         if Bool
a
         then do
           Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrName Lexer s
x
         else do
           ST s ()
anythingElse
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus -> do
         if Bool
a
         then do
           Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doSelfClosingStartTag Lexer s
x
         else do
           ST s ()
anythingElse
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         if Bool
a
         then do
           Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
           Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
         else do
           ST s ()
anythingElse
     | Word8 -> Bool
chrASCIIUpperAlpha Word8
c -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenTagNameAppend (Word8 -> Word8
chrToLower Word8
c) STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend Word8
c STRef s (Buffer s)
lexerBuffer
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEndTagName Lexer s
x
     | Word8 -> Bool
chrASCIILowerAlpha Word8
c -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenTagNameAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend Word8
c STRef s (Buffer s)
lexerBuffer
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEndTagName Lexer s
x
     | Bool
otherwise -> do
         ST s ()
anythingElse
  where
    anythingElse :: ST s ()
anythingElse = do
      STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDrop STRef s (TokenBuffer s)
lexerToken
      Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrLess
      Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrSolidus
      Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emitBuffer Lexer s
x
      Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
      Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptData Lexer s
x

-- 12.2.5.18 Script data escape start state
doScriptDataEscapeStart :: Lexer s -> ST s ()
doScriptDataEscapeStart :: Lexer s -> ST s ()
doScriptDataEscapeStart x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrHyphen
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapeStartDash Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptData Lexer s
x

-- 12.2.5.19 Script data escape start dash state
doScriptDataEscapeStartDash :: Lexer s -> ST s ()
doScriptDataEscapeStartDash :: Lexer s -> ST s ()
doScriptDataEscapeStartDash x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrHyphen
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedDashDash Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptData Lexer s
x

-- 12.2.5.20 Script data escaped state
doScriptDataEscaped :: Lexer s -> ST s ()
doScriptDataEscaped :: Lexer s -> ST s ()
doScriptDataEscaped x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrHyphen
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedDash Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLess -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedLessThan Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-script-html-comment-like-text"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscaped Lexer s
x

-- 12.2.5.21 Script data escaped dash state
doScriptDataEscapedDash :: Lexer s -> ST s ()
doScriptDataEscapedDash :: Lexer s -> ST s ()
doScriptDataEscapedDash x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrHyphen
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedDashDash Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLess -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedLessThan Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-script-html-comment-like-text"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscaped Lexer s
x

-- 12.2.5.22 Script data escaped dash dash state
doScriptDataEscapedDashDash :: Lexer s -> ST s ()
doScriptDataEscapedDashDash :: Lexer s -> ST s ()
doScriptDataEscapedDashDash x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedDashDash Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLess -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedLessThan Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptData Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-script-html-comment-like-text"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscaped Lexer s
x

-- 12.2.5.23 Script data escaped less-than sign state
doScriptDataEscapedLessThan :: Lexer s -> ST s ()
doScriptDataEscapedLessThan :: Lexer s -> ST s ()
doScriptDataEscapedLessThan x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus -> do
         STRef s (Buffer s) -> ST s ()
forall s. STRef s (Buffer s) -> ST s ()
bufferReset STRef s (Buffer s)
lexerBuffer
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedEndTagOpen Lexer s
x
     | Word8 -> Bool
chrASCIIAlpha Word8
c -> do
         STRef s (Buffer s) -> ST s ()
forall s. STRef s (Buffer s) -> ST s ()
bufferReset STRef s (Buffer s)
lexerBuffer
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrLess
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataDoubleEscapedStart Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrLess
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscaped Lexer s
x

-- 12.2.5.24 Script data escaped end tag open state
doScriptDataEscapedEndTagOpen :: Lexer s -> ST s ()
doScriptDataEscapedEndTagOpen :: Lexer s -> ST s ()
doScriptDataEscapedEndTagOpen x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8 -> Bool
chrASCIIAlpha Word8
c -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenTagEndInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedEndTagName Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrLess
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrSolidus
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscaped Lexer s
x

-- 12.2.5.25 Script data escaped end tag name state
doScriptDataEscapedEndTagName :: Lexer s -> ST s ()
doScriptDataEscapedEndTagName :: Lexer s -> ST s ()
doScriptDataEscapedEndTagName x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  Bool
a <- Lexer s -> ST s Bool
forall s. Lexer s -> ST s Bool
appropriateEndTag Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         if Bool
a
         then do
           Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrName Lexer s
x
         else do
           ST s ()
anythingElse
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus -> do
         if Bool
a
         then do
           Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doSelfClosingStartTag Lexer s
x
         else do
           ST s ()
anythingElse
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         if Bool
a
         then do
           Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
           Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
         else do
           ST s ()
anythingElse
     | Word8 -> Bool
chrASCIIUpperAlpha Word8
c -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenTagNameAppend (Word8 -> Word8
chrToLower Word8
c) STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend Word8
c STRef s (Buffer s)
lexerBuffer
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedEndTagName Lexer s
x
     | Word8 -> Bool
chrASCIILowerAlpha Word8
c -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenTagNameAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend Word8
c STRef s (Buffer s)
lexerBuffer
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscapedEndTagName Lexer s
x
     | Bool
otherwise -> do
         ST s ()
anythingElse
  where
    anythingElse :: ST s ()
anythingElse = do
      STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDrop STRef s (TokenBuffer s)
lexerToken
      Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrLess
      Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrSolidus
      Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emitBuffer Lexer s
x
      Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
      Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateScriptDataEscaped
      Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x

-- 12.2.5.26 Script data double escape start state
doScriptDataDoubleEscapedStart :: Lexer s -> ST s ()
doScriptDataDoubleEscapedStart :: Lexer s -> ST s ()
doScriptDataDoubleEscapedStart x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         [Word8] -> STRef s (Buffer s) -> ST s Bool
forall s. [Word8] -> STRef s (Buffer s) -> ST s Bool
bufferContains (BS -> [Word8]
bsUnpack BS
"script") STRef s (Buffer s)
lexerBuffer ST s Bool -> (Bool -> ST s ()) -> ST s ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
           Bool
True -> do
             Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataDoubleEscaped Lexer s
x
           Bool
False -> do
             Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
c STRef s (TokenBuffer s)
lexerToken
             Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateScriptDataEscaped
             Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8 -> Bool
chrASCIIUpperAlpha Word8
c -> do
         Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend (Word8 -> Word8
chrToLower Word8
c) STRef s (Buffer s)
lexerBuffer
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateScriptDataDoubleEscapedStart
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8 -> Bool
chrASCIILowerAlpha Word8
c -> do
         Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend Word8
c STRef s (Buffer s)
lexerBuffer
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateScriptDataDoubleEscapedStart
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscaped Lexer s
x

-- 12.2.5.27 Script data double escaped state
doScriptDataDoubleEscaped :: Lexer s -> ST s ()
doScriptDataDoubleEscaped :: Lexer s -> ST s ()
doScriptDataDoubleEscaped x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateScriptDataDoubleEscapedDash
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLess -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateScriptDataDoubleEscapedLessThan
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-script-html-comment-like-text"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x

-- 12.2.5.28 Script data double escaped dash state
doScriptDataDoubleEscapedDash :: Lexer s -> ST s ()
doScriptDataDoubleEscapedDash :: Lexer s -> ST s ()
doScriptDataDoubleEscapedDash x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateScriptDataDoubleEscapedDashDash
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLess -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateScriptDataDoubleEscapedLessThan
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-script-html-comment-like-text"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateScriptDataDoubleEscaped
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x

-- 12.2.5.29 Script data double escaped dash dash state
doScriptDataDoubleEscapedDashDash :: Lexer s -> ST s ()
doScriptDataDoubleEscapedDashDash :: Lexer s -> ST s ()
doScriptDataDoubleEscapedDashDash x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataDoubleEscapedDashDash Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLess -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateScriptDataDoubleEscapedLessThan
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateScriptData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-script-html-comment-like-text"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateScriptDataDoubleEscaped
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x

-- 12.2.5.30 Script data double escaped less-than sign state
doScriptDataDoubleEscapedLessThan :: Lexer s -> ST s ()
doScriptDataDoubleEscapedLessThan :: Lexer s -> ST s ()
doScriptDataDoubleEscapedLessThan x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus -> do
         STRef s (Buffer s) -> ST s ()
forall s. STRef s (Buffer s) -> ST s ()
bufferReset STRef s (Buffer s)
lexerBuffer
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateScriptDataDoubleEscapeEnd
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataDoubleEscaped Lexer s
x

-- 12.2.5.31 Script data double escape end state
doScriptDataDoubleEscapeEnd :: Lexer s -> ST s ()
doScriptDataDoubleEscapeEnd :: Lexer s -> ST s ()
doScriptDataDoubleEscapeEnd x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         [Word8] -> STRef s (Buffer s) -> ST s Bool
forall s. [Word8] -> STRef s (Buffer s) -> ST s Bool
bufferContains (BS -> [Word8]
bsUnpack BS
"script") STRef s (Buffer s)
lexerBuffer ST s Bool -> (Bool -> ST s ()) -> ST s ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
           Bool
True -> do
             Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataEscaped Lexer s
x
           Bool
False -> do
             Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
c STRef s (TokenBuffer s)
lexerToken
             Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateScriptDataDoubleEscaped
             Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8 -> Bool
chrASCIIUpperAlpha Word8
c -> do
         Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend (Word8 -> Word8
chrToLower Word8
c) STRef s (Buffer s)
lexerBuffer
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataDoubleEscapeEnd Lexer s
x
     | Word8 -> Bool
chrASCIILowerAlpha Word8
c -> do
         Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend Word8
c STRef s (Buffer s)
lexerBuffer
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataDoubleEscapeEnd Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doScriptDataDoubleEscaped Lexer s
x

-- 12.2.5.32 Before attribute name state
doBeforeAttrName :: Lexer s -> ST s ()
doBeforeAttrName :: Lexer s -> ST s ()
doBeforeAttrName x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterAttrName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEqual -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"unexpected-equals-sign-before-attribute-name"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenAttrInit STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenAttrNameAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrName Lexer s
x
     | Bool
otherwise -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenAttrInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrName Lexer s
x

-- 12.2.5.33 Attribute name state
doAttrName :: Lexer s -> ST s ()
doAttrName :: Lexer s -> ST s ()
doAttrName x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         ST s ()
checkAttr
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterAttrName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEqual -> do
         ST s ()
checkAttr
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrValue Lexer s
x
     | Word8 -> Bool
chrASCIIUpperAlpha Word8
c -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenAttrNameAppend (Word8 -> Word8
chrToLower Word8
c) STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrQuote Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrApostrophe Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLess -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"unexpected-character-in-attribute-name"
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenAttrNameAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrName Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenAttrNameAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrName Lexer s
x
  where
    checkAttr :: ST s ()
checkAttr = do
      Int
i <- STRef s (TokenBuffer s) -> ST s Int
forall s. STRef s (TokenBuffer s) -> ST s Int
tokenTail STRef s (TokenBuffer s)
lexerToken
      ST s Bool -> ST s () -> ST s ()
forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
whenM (Int -> STRef s (TokenBuffer s) -> ST s Bool
forall s. Int -> STRef s (TokenBuffer s) -> ST s Bool
tokenAttrNamePrune Int
i STRef s (TokenBuffer s)
lexerToken) (ST s () -> ST s ()) -> ST s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ do
        Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"duplicate-attribute"

-- 12.2.5.34 After attribute name state
doAfterAttrName :: Lexer s -> ST s ()
doAfterAttrName :: Lexer s -> ST s ()
doAfterAttrName x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterAttrName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doSelfClosingStartTag Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEqual -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrValue Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-tag"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenAttrInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrName Lexer s
x

-- 12.2.5.35 Before attribute value state
doBeforeAttrValue :: Lexer s -> ST s ()
doBeforeAttrValue :: Lexer s -> ST s ()
doBeforeAttrValue x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrValue Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrQuote -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrValueDoubleQuoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrApostrophe -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrValueSingleQuoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-attribute-value"
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrValueUnquoted Lexer s
x

-- 12.2.5.36 Attribute value (double-quoted) state
doAttrValueDoubleQuoted :: Lexer s -> ST s ()
doAttrValueDoubleQuoted :: Lexer s -> ST s ()
doAttrValueDoubleQuoted x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrQuote -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterAttrValue Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrAmpersand -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
returnSet Lexer s
x LexerState
StateAttrValueDoubleQuoted
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCharacterReference Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-tag"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenAttrValAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrValueDoubleQuoted Lexer s
x

-- 12.2.5.37 Attribute value (single-quoted) state
doAttrValueSingleQuoted :: Lexer s -> ST s ()
doAttrValueSingleQuoted :: Lexer s -> ST s ()
doAttrValueSingleQuoted x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrApostrophe -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterAttrValue Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrAmpersand -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
returnSet Lexer s
x LexerState
StateAttrValueSingleQuoted
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCharacterReference Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-tag"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenAttrValAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrValueSingleQuoted Lexer s
x

-- 12.2.5.38 Attribute value (unquoted) state
doAttrValueUnquoted :: Lexer s -> ST s ()
doAttrValueUnquoted :: Lexer s -> ST s ()
doAttrValueUnquoted x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrAmpersand -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
returnSet Lexer s
x LexerState
StateAttrValueUnquoted
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCharacterReference Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrQuote Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrApostrophe Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLess Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEqual Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGrave -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"unexpected-character-in-unquoted-attribute-value"
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenAttrValAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrValueUnquoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-tag"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenAttrValAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAttrValueUnquoted Lexer s
x

-- 12.2.5.39 After attribute value (quoted) state
doAfterAttrValue :: Lexer s -> ST s ()
doAfterAttrValue :: Lexer s -> ST s ()
doAfterAttrValue x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSolidus -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doSelfClosingStartTag Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-tag"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-whitespace-between-attributes"
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrName Lexer s
x

-- 12.2.5.40 Self-closing start tag state
doSelfClosingStartTag :: Lexer s -> ST s ()
doSelfClosingStartTag :: Lexer s -> ST s ()
doSelfClosingStartTag x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenTagStartSetSelfClosing STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-tag"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"unexpected-solidus-in-tag"
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeAttrName Lexer s
x

-- 12.2.5.41 Bogus comment state
doBogusComment :: Lexer s -> ST s ()
doBogusComment :: Lexer s -> ST s ()
doBogusComment x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusComment Lexer s
x

-- 12.2.5.42 Markup declaration open state
doMarkupDeclarationOpen :: Lexer s -> ST s ()
doMarkupDeclarationOpen :: Lexer s -> ST s ()
doMarkupDeclarationOpen x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Int -> Word8
f <- Lexer s -> ST s (Int -> Word8)
forall s. Lexer s -> ST s (Int -> Word8)
dataIndexer Lexer s
x
  Int
n <- Lexer s -> ST s Int
forall s. Lexer s -> ST s Int
dataRemain Lexer s
x
  if | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 Bool -> Bool -> Bool
&&
       Int -> Word8
f Int
0 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen Bool -> Bool -> Bool
&&
       Int -> Word8
f Int
1 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Lexer s -> Int -> ST s ()
forall s. Lexer s -> Int -> ST s ()
skipWord Lexer s
x Int
2
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenCommentInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentStart Lexer s
x
     | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
6 Bool -> Bool -> Bool
&&
       (Int -> Word8
f Int
0 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x44 Bool -> Bool -> Bool
|| Int -> Word8
f Int
0 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x64) Bool -> Bool -> Bool
&&    -- D or d
       (Int -> Word8
f Int
1 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x4F Bool -> Bool -> Bool
|| Int -> Word8
f Int
1 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x6F) Bool -> Bool -> Bool
&&    -- O or o
       (Int -> Word8
f Int
2 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x43 Bool -> Bool -> Bool
|| Int -> Word8
f Int
2 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x63) Bool -> Bool -> Bool
&&    -- C or c
       (Int -> Word8
f Int
3 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x54 Bool -> Bool -> Bool
|| Int -> Word8
f Int
3 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x74) Bool -> Bool -> Bool
&&    -- T or t
       (Int -> Word8
f Int
4 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x59 Bool -> Bool -> Bool
|| Int -> Word8
f Int
4 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x79) Bool -> Bool -> Bool
&&    -- Y or y
       (Int -> Word8
f Int
5 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x50 Bool -> Bool -> Bool
|| Int -> Word8
f Int
5 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x70) Bool -> Bool -> Bool
&&    -- P or p
       (Int -> Word8
f Int
6 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x45 Bool -> Bool -> Bool
|| Int -> Word8
f Int
6 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x65) -> do -- E or e
         Lexer s -> Int -> ST s ()
forall s. Lexer s -> Int -> ST s ()
skipWord Lexer s
x Int
7
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctype Lexer s
x
     | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
6 Bool -> Bool -> Bool
&&
       Int -> Word8
f Int
0 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x5B Bool -> Bool -> Bool
&&    -- [
       Int -> Word8
f Int
1 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x43 Bool -> Bool -> Bool
&&    -- C
       Int -> Word8
f Int
2 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x44 Bool -> Bool -> Bool
&&    -- D
       Int -> Word8
f Int
3 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x41 Bool -> Bool -> Bool
&&    -- A
       Int -> Word8
f Int
4 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x54 Bool -> Bool -> Bool
&&    -- T
       Int -> Word8
f Int
5 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x41 Bool -> Bool -> Bool
&&    -- A
       Int -> Word8
f Int
6 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x5B -> do -- [
         Lexer s -> Int -> ST s ()
forall s. Lexer s -> Int -> ST s ()
skipWord Lexer s
x Int
7
  -- The standard says to check if the parser has an adjusted current node
  -- that is not in the HTML namespace, and if so then CDATA sections are
  -- allowed.  For now we assume that condition is true and we do not
  -- check with the parser to verify.  CDATA sections in HTML are probably
  -- not common and in most cases they are going to be in the correct
  -- locations anyway.
         if Bool
True -- TODO
            then do
              Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateCDATASection
              Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCDATASection Lexer s
x
            else do
              Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"cdata-in-html-content"
              STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenCommentInit STRef s (TokenBuffer s)
lexerToken
              (Word8 -> ST s ()) -> [Word8] -> ST s ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ((Word8 -> STRef s (TokenBuffer s) -> ST s ())
-> STRef s (TokenBuffer s) -> Word8 -> ST s ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend STRef s (TokenBuffer s)
lexerToken)
                [ Word8
0x5B, Word8
0x43, Word8
0x44, Word8
0x41, Word8
0x54, Word8
0x41, Word8
0x5B ]
              Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusComment Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"incorrectly-opened-comment"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenCommentInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusComment Lexer s
x

-- 12.2.5.43 Comment start state
doCommentStart :: Lexer s -> ST s ()
doCommentStart :: Lexer s -> ST s ()
doCommentStart x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentStartDash Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"abrupt-closing-of-empty-comment"
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doComment Lexer s
x

-- 12.2.5.44 Comment start dash state
doCommentStartDash :: Lexer s -> ST s ()
doCommentStartDash :: Lexer s -> ST s ()
doCommentStartDash x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentEnd Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"abrupt-closing-of-empty-comment"
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-comment"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
chrHyphen STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doComment Lexer s
x

-- 12.2.5.45 Comment state
doComment :: Lexer s -> ST s ()
doComment :: Lexer s -> ST s ()
doComment x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLess -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentLessThan Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentEndDash Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-comment"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doComment Lexer s
x

-- 12.2.5.46 Comment less-than sign state
doCommentLessThan :: Lexer s -> ST s ()
doCommentLessThan :: Lexer s -> ST s ()
doCommentLessThan x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrExclamation -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentLessThanBang Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLess -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentLessThan Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doComment Lexer s
x

-- 12.2.5.47 Comment less-than sign bang state
doCommentLessThanBang :: Lexer s -> ST s ()
doCommentLessThanBang :: Lexer s -> ST s ()
doCommentLessThanBang x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentLessThanBangDash Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doComment Lexer s
x

-- 12.2.5.48 Comment less-than sign bang dash state
doCommentLessThanBangDash :: Lexer s -> ST s ()
doCommentLessThanBangDash :: Lexer s -> ST s ()
doCommentLessThanBangDash x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentLessThanBangDashDash Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentEndDash Lexer s
x

-- 12.2.5.49 Comment less-than sign bang dash dash state
doCommentLessThanBangDashDash :: Lexer s -> ST s ()
doCommentLessThanBangDashDash :: Lexer s -> ST s ()
doCommentLessThanBangDashDash x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentEnd Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"nested-comment"
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentEnd Lexer s
x

-- 12.2.5.50 Comment end dash state
doCommentEndDash :: Lexer s -> ST s ()
doCommentEndDash :: Lexer s -> ST s ()
doCommentEndDash x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentEnd Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-comment"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
chrHyphen STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doComment Lexer s
x

-- 12.2.5.51 Comment end state
doCommentEnd :: Lexer s -> ST s ()
doCommentEnd :: Lexer s -> ST s ()
doCommentEnd x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrExclamation -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentEndBang Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
chrHyphen STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentEnd Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-comment"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
chrHyphen STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
chrHyphen STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doComment Lexer s
x

-- 12.2.5.52 Comment end bang state
doCommentEndBang :: Lexer s -> ST s ()
doCommentEndBang :: Lexer s -> ST s ()
doCommentEndBang x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrHyphen -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
chrHyphen STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
chrHyphen STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
chrExclamation STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCommentEndDash Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"incorrectly-closed-comment"
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-comment"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
chrHyphen STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
chrHyphen STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend Word8
chrExclamation STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doComment Lexer s
x

-- 12.2.5.53 DOCTYPE state
doDoctype :: Lexer s -> ST s ()
doDoctype :: Lexer s -> ST s ()
doDoctype x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeDoctypeName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeDoctypeName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeInit STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-whitespace-before-doctype-name"
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeDoctypeName Lexer s
x

-- 12.2.5.54 Before DOCTYPE name state
doBeforeDoctypeName :: Lexer s -> ST s ()
doBeforeDoctypeName :: Lexer s -> ST s ()
doBeforeDoctypeName x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeDoctypeName Lexer s
x
     | Word8 -> Bool
chrASCIIUpperAlpha Word8
c -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeInit STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeNameAppend (Word8 -> Word8
chrToLower Word8
c) STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-doctype-name"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeInit STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeInit STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeInit STRef s (TokenBuffer s)
lexerToken
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeNameAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeName Lexer s
x

-- 12.2.5.55 DOCTYPE name state
doDoctypeName :: Lexer s -> ST s ()
doDoctypeName :: Lexer s -> ST s ()
doDoctypeName x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterDoctypeName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8 -> Bool
chrASCIIUpperAlpha Word8
c -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeNameAppend (Word8 -> Word8
chrToLower Word8
c) STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeNameAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeName Lexer s
x

-- 12.2.5.56 After DOCTYPE name state
doAfterDoctypeName :: Lexer s -> ST s ()
doAfterDoctypeName :: Lexer s -> ST s ()
doAfterDoctypeName x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  -- Get data indexer after the character.
  Int -> Word8
f <- Lexer s -> ST s (Int -> Word8)
forall s. Lexer s -> ST s (Int -> Word8)
dataIndexer Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterDoctypeName Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | (Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x50 Bool -> Bool -> Bool
|| Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x70) Bool -> Bool -> Bool
&&        -- P or p
       (Int -> Word8
f Int
0 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x55 Bool -> Bool -> Bool
|| Int -> Word8
f Int
0 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x75) Bool -> Bool -> Bool
&&    -- U or u
       (Int -> Word8
f Int
1 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x42 Bool -> Bool -> Bool
|| Int -> Word8
f Int
1 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x62) Bool -> Bool -> Bool
&&    -- B or b
       (Int -> Word8
f Int
2 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x4C Bool -> Bool -> Bool
|| Int -> Word8
f Int
2 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x6C) Bool -> Bool -> Bool
&&    -- L or l
       (Int -> Word8
f Int
3 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x49 Bool -> Bool -> Bool
|| Int -> Word8
f Int
3 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x69) Bool -> Bool -> Bool
&&    -- I or i
       (Int -> Word8
f Int
4 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x43 Bool -> Bool -> Bool
|| Int -> Word8
f Int
4 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x63) -> do -- C or c
         Lexer s -> Int -> ST s ()
forall s. Lexer s -> Int -> ST s ()
skipWord Lexer s
x Int
5
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterDoctypePublicKeyword Lexer s
x
     | (Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x53 Bool -> Bool -> Bool
|| Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x73) Bool -> Bool -> Bool
&&        -- S or s
       (Int -> Word8
f Int
0 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x59 Bool -> Bool -> Bool
|| Int -> Word8
f Int
0 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x79) Bool -> Bool -> Bool
&&    -- Y or y
       (Int -> Word8
f Int
1 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x53 Bool -> Bool -> Bool
|| Int -> Word8
f Int
1 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x73) Bool -> Bool -> Bool
&&    -- S or s
       (Int -> Word8
f Int
2 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x54 Bool -> Bool -> Bool
|| Int -> Word8
f Int
2 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x74) Bool -> Bool -> Bool
&&    -- T or t
       (Int -> Word8
f Int
3 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x45 Bool -> Bool -> Bool
|| Int -> Word8
f Int
3 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x65) Bool -> Bool -> Bool
&&    -- E or e
       (Int -> Word8
f Int
4 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x4D Bool -> Bool -> Bool
|| Int -> Word8
f Int
4 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0x6D) -> do -- M or m
         Lexer s -> Int -> ST s ()
forall s. Lexer s -> Int -> ST s ()
skipWord Lexer s
x Int
5
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterDoctypeSystemKeyword Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"invalid-character-sequence-after-doctype-name"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusDoctype Lexer s
x

-- 12.2.5.57 After DOCTYPE public keyword state
doAfterDoctypePublicKeyword :: Lexer s -> ST s ()
doAfterDoctypePublicKeyword :: Lexer s -> ST s ()
doAfterDoctypePublicKeyword x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeDoctypePublicId Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrQuote -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-whitespace-after-doctype-public-keyword"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypePublicIdInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypePublicIdDoubleQuoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrApostrophe -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-whitespace-after-doctype-public-keyword"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypePublicIdInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypePublicIdSingleQuoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-doctype-public-identifier"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-quote-before-doctype-public-identifier"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusDoctype Lexer s
x

-- 12.2.5.58 Before DOCTYPE public identifier state
doBeforeDoctypePublicId :: Lexer s -> ST s ()
doBeforeDoctypePublicId :: Lexer s -> ST s ()
doBeforeDoctypePublicId x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeDoctypePublicId Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrQuote -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypePublicIdInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypePublicIdDoubleQuoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrApostrophe -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypePublicIdInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypePublicIdSingleQuoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-doctype-public-identifier"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-quote-before-doctype-public-identifier"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusDoctype Lexer s
x

-- 12.2.5.59 DOCTYPE public identifier (double-quoted) state
doDoctypePublicIdDoubleQuoted :: Lexer s -> ST s ()
doDoctypePublicIdDoubleQuoted :: Lexer s -> ST s ()
doDoctypePublicIdDoubleQuoted x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrQuote -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterDoctypePublicId Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"abrupt-doctype-public-identifier"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenDoctypePublicIdAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypePublicIdDoubleQuoted Lexer s
x

-- 12.2.5.60 DOCTYPE public identifier (single-quoted) state
doDoctypePublicIdSingleQuoted :: Lexer s -> ST s ()
doDoctypePublicIdSingleQuoted :: Lexer s -> ST s ()
doDoctypePublicIdSingleQuoted x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrApostrophe -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterDoctypePublicId Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"abrupt-doctype-public-identifier"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenDoctypePublicIdAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypePublicIdSingleQuoted Lexer s
x

-- 12.2.5.61 After DOCTYPE public identifier state
doAfterDoctypePublicId :: Lexer s -> ST s ()
doAfterDoctypePublicId :: Lexer s -> ST s ()
doAfterDoctypePublicId x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBetweenDoctypePublicAndSystem Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrQuote -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-whitespace-between-doctype-public-and-system-identifiers"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSystemIdInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeSystemIdDoubleQuoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrApostrophe -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-whitespace-between-doctype-public-and-system-identifiers"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSystemIdInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeSystemIdSingleQuoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-quote-before-doctype-system-identifier"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusDoctype Lexer s
x

-- 12.2.5.62 Between DOCTYPE public and system identifiers state
doBetweenDoctypePublicAndSystem :: Lexer s -> ST s ()
doBetweenDoctypePublicAndSystem :: Lexer s -> ST s ()
doBetweenDoctypePublicAndSystem x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBetweenDoctypePublicAndSystem Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrQuote -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSystemIdInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeSystemIdDoubleQuoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrApostrophe -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSystemIdInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeSystemIdSingleQuoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-quote-before-doctype-system-identifier"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusDoctype Lexer s
x

-- 12.2.5.63 After DOCTYPE system keyword state
doAfterDoctypeSystemKeyword :: Lexer s -> ST s ()
doAfterDoctypeSystemKeyword :: Lexer s -> ST s ()
doAfterDoctypeSystemKeyword x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeDoctypeSystemId Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrQuote -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-whitespace-after-doctype-system-keyword"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSystemIdInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeSystemIdDoubleQuoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrApostrophe -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-whitespace-after-doctype-system-keyword"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSystemIdInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeSystemIdSingleQuoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-doctype-system-identifier"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-quote-before-doctype-system-identifier"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusDoctype Lexer s
x

-- 12.2.5.64 Before DOCTYPE system identifier state
doBeforeDoctypeSystemId :: Lexer s -> ST s ()
doBeforeDoctypeSystemId :: Lexer s -> ST s ()
doBeforeDoctypeSystemId x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBeforeDoctypeSystemId Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrQuote -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSystemIdInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeSystemIdDoubleQuoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrApostrophe -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSystemIdInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeSystemIdSingleQuoted Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-doctype-system-identifier"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-quote-before-doctype-system-identifier"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusDoctype Lexer s
x

-- 12.2.5.65 DOCTYPE system identifier (double-quoted) state
doDoctypeSystemIdDoubleQuoted :: Lexer s -> ST s ()
doDoctypeSystemIdDoubleQuoted :: Lexer s -> ST s ()
doDoctypeSystemIdDoubleQuoted x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrQuote -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterDoctypeSystemId Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"abrupt-doctype-system-identifier"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSystemIdAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeSystemIdDoubleQuoted Lexer s
x

-- 12.2.5.66 DOCTYPE system identifier (single-quoted) state
doDoctypeSystemIdSingleQuoted :: Lexer s -> ST s ()
doDoctypeSystemIdSingleQuoted :: Lexer s -> ST s ()
doDoctypeSystemIdSingleQuoted x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrApostrophe -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterDoctypeSystemId Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"abrupt-doctype-system-identifier"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSystemIdAppend Word8
c STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDoctypeSystemIdSingleQuoted Lexer s
x

-- 12.2.5.67 After DOCTYPE system identifier state
doAfterDoctypeSystemId :: Lexer s -> ST s ()
doAfterDoctypeSystemId :: Lexer s -> ST s ()
doAfterDoctypeSystemId x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrTab Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrFF Bool -> Bool -> Bool
||
       Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSpace -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAfterDoctypeSystemId Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-doctype"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
lexerToken
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"unexpected-character-after-doctype-system-identifier"
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusDoctype Lexer s
x

-- 12.2.5.68 Bogus DOCTYPE state
doBogusDoctype :: Lexer s -> ST s ()
doBogusDoctype :: Lexer s -> ST s ()
doBogusDoctype x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> LexerState -> ST s ()
forall s. Lexer s -> LexerState -> ST s ()
state Lexer s
x LexerState
StateData
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doBogusDoctype Lexer s
x

-- 12.2.5.69 CDATA section state
doCDATASection :: Lexer s -> ST s ()
doCDATASection :: Lexer s -> ST s ()
doCDATASection x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrBracketRight -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCDATASectionBracket Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrEOF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"eof-in-cdata"
         STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
emit Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCDATASection Lexer s
x

-- 12.2.5.70 CDATA section bracket state
doCDATASectionBracket :: Lexer s -> ST s ()
doCDATASectionBracket :: Lexer s -> ST s ()
doCDATASectionBracket x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrBracketRight -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCDATASectionEnd Lexer s
x
     | Bool
otherwise -> do
         Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
chrBracketRight STRef s (TokenBuffer s)
lexerToken
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCDATASection Lexer s
x

-- 12.2.5.71 CDATA section end state
doCDATASectionEnd :: Lexer s -> ST s ()
doCDATASectionEnd :: Lexer s -> ST s ()
doCDATASectionEnd x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrBracketRight -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCDATASectionEnd Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrGreater -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doData Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrBracketRight
         Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
chrBracketRight
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doCDATASection Lexer s
x

-- 12.2.5.72 Character reference state
doCharacterReference :: Lexer s -> ST s ()
doCharacterReference :: Lexer s -> ST s ()
doCharacterReference x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  STRef s (Buffer s) -> ST s ()
forall s. STRef s (Buffer s) -> ST s ()
bufferReset STRef s (Buffer s)
lexerBuffer
  Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend Word8
chrAmpersand STRef s (Buffer s)
lexerBuffer
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Bool
lexerIgnore -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
flushCodePoints Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
returnState Lexer s
x
     | Word8 -> Bool
chrASCIIAlphanumeric Word8
c -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doNamedCharacterReference Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrNumberSign -> do
         Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend Word8
c STRef s (Buffer s)
lexerBuffer
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doNumericCharacterReference Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
flushCodePoints Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
returnState Lexer s
x

-- 12.2.5.73 Named character reference state
doNamedCharacterReference :: Lexer s -> ST s ()
doNamedCharacterReference :: Lexer s -> ST s ()
doNamedCharacterReference x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Int
o <- STRef s Int -> ST s Int
forall s a. STRef s a -> ST s a
rref STRef s Int
lexerOffset
  case BS -> Maybe (BS, BS, BS)
entityMatch (Int -> BS -> BS
bsDrop Int
o BS
lexerData) of
    Just (BS
p, BS
v, BS
_) -> do
      Lexer s -> Int -> ST s ()
forall s. Lexer s -> Int -> ST s ()
skipWord Lexer s
x (Int -> ST s ()) -> Int -> ST s ()
forall a b. (a -> b) -> a -> b
$ BS -> Int
bsLen BS
p
      [Word8] -> (Word8 -> ST s ()) -> ST s ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ (BS -> [Word8]
bsUnpack BS
p) ((Word8 -> ST s ()) -> ST s ()) -> (Word8 -> ST s ()) -> ST s ()
forall a b. (a -> b) -> a -> b
$
        (Word8 -> STRef s (Buffer s) -> ST s ())
-> STRef s (Buffer s) -> Word8 -> ST s ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend STRef s (Buffer s)
lexerBuffer
      Bool
attr <- Lexer s -> ST s Bool
forall s. Lexer s -> ST s Bool
consumingAttibute Lexer s
x
      Bool
semi <- Bool -> ST s Bool
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Bool -> ST s Bool) -> Bool -> ST s Bool
forall a b. (a -> b) -> a -> b
$ BS -> Maybe Word8
bsLast BS
p Maybe Word8 -> Maybe Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8 -> Maybe Word8
forall a. a -> Maybe a
Just Word8
chrSemicolon
      Word8
c    <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
peekWord Lexer s
x
      if | Bool
attr
         , Bool -> Bool
not Bool
semi
         , Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSemicolon Bool -> Bool -> Bool
|| Word8 -> Bool
chrASCIIAlphanumeric Word8
c -> do
             Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
flushCodePoints Lexer s
x
             Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
returnState Lexer s
x
         | Bool
otherwise -> do
             Bool -> ST s () -> ST s ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not Bool
semi) (ST s () -> ST s ()) -> ST s () -> ST s ()
forall a b. (a -> b) -> a -> b
$
               Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-semicolon-after-character-reference"
             STRef s (Buffer s) -> ST s ()
forall s. STRef s (Buffer s) -> ST s ()
bufferReset STRef s (Buffer s)
lexerBuffer
             [Word8] -> (Word8 -> ST s ()) -> ST s ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ (BS -> [Word8]
bsUnpack BS
v) ((Word8 -> ST s ()) -> ST s ()) -> (Word8 -> ST s ()) -> ST s ()
forall a b. (a -> b) -> a -> b
$
               (Word8 -> STRef s (Buffer s) -> ST s ())
-> STRef s (Buffer s) -> Word8 -> ST s ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend STRef s (Buffer s)
lexerBuffer
             Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
flushCodePoints Lexer s
x
             Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
returnState Lexer s
x
    Maybe (BS, BS, BS)
Nothing -> do
      Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
flushCodePoints Lexer s
x
      Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAmbiguousAmpersand Lexer s
x

-- 12.2.5.74 Ambiguous ampersand state
doAmbiguousAmpersand :: Lexer s -> ST s ()
doAmbiguousAmpersand :: Lexer s -> ST s ()
doAmbiguousAmpersand x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8 -> Bool
chrASCIIAlphanumeric Word8
c -> do
         Lexer s -> ST s Bool
forall s. Lexer s -> ST s Bool
consumingAttibute Lexer s
x ST s Bool -> (Bool -> ST s ()) -> ST s ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
           Bool
True  -> Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenAttrValAppend Word8
c STRef s (TokenBuffer s)
lexerToken
           Bool
False -> Lexer s -> Word8 -> ST s ()
forall s. Lexer s -> Word8 -> ST s ()
emitChar Lexer s
x Word8
c
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doAmbiguousAmpersand Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSemicolon -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"unknown-named-character-reference"
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
returnState Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
returnState Lexer s
x

-- 12.2.5.75 Numeric character reference state
doNumericCharacterReference :: Lexer s -> ST s ()
doNumericCharacterReference :: Lexer s -> ST s ()
doNumericCharacterReference x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  STRef s Int -> Int -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s Int
lexerCode Int
0
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrUpperX Bool -> Bool -> Bool
|| Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrLowerX -> do
         Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend Word8
c STRef s (Buffer s)
lexerBuffer
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doHexCharacterReferenceStart Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDecimalCharacterReference Lexer s
x

-- 12.2.5.76 Hexademical character reference start state
doHexCharacterReferenceStart :: Lexer s -> ST s ()
doHexCharacterReferenceStart :: Lexer s -> ST s ()
doHexCharacterReferenceStart x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8 -> Bool
chrASCIIHexDigit Word8
c -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doHexCharacterReference Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"absence-of-digits-in-numeric-character-reference"
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
flushCodePoints Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
returnState Lexer s
x

-- 12.2.5.77 Decimal character reference start state
doDecimalCharacterReferenceStart :: Lexer s -> ST s ()
doDecimalCharacterReferenceStart :: Lexer s -> ST s ()
doDecimalCharacterReferenceStart x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8 -> Bool
chrASCIIDigit Word8
c -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDecimalCharacterReference Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"absence-of-digits-in-numeric-character-reference"
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
flushCodePoints Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
returnState Lexer s
x

-- 12.2.5.78 Hexademical character reference state
doHexCharacterReference :: Lexer s -> ST s ()
doHexCharacterReference :: Lexer s -> ST s ()
doHexCharacterReference x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8 -> Bool
chrASCIIDigit Word8
c -> do
         STRef s Int -> (Int -> Int) -> ST s ()
forall s a. STRef s a -> (a -> a) -> ST s ()
uref STRef s Int
lexerCode ((Int -> Int) -> ST s ()) -> (Int -> Int) -> ST s ()
forall a b. (a -> b) -> a -> b
$ \Int
y -> Int
16 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
y Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
c Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
0x30)
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doHexCharacterReference Lexer s
x
     | Word8 -> Bool
chrASCIIUpperHexDigit Word8
c -> do
         STRef s Int -> (Int -> Int) -> ST s ()
forall s a. STRef s a -> (a -> a) -> ST s ()
uref STRef s Int
lexerCode ((Int -> Int) -> ST s ()) -> (Int -> Int) -> ST s ()
forall a b. (a -> b) -> a -> b
$ \Int
y -> Int
16 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
y Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
c Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
0x37)
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doHexCharacterReference Lexer s
x
     | Word8 -> Bool
chrASCIILowerHexDigit Word8
c -> do
         STRef s Int -> (Int -> Int) -> ST s ()
forall s a. STRef s a -> (a -> a) -> ST s ()
uref STRef s Int
lexerCode ((Int -> Int) -> ST s ()) -> (Int -> Int) -> ST s ()
forall a b. (a -> b) -> a -> b
$ \Int
y -> Int
16 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
y Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
c Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
0x57)
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doHexCharacterReference Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSemicolon -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doNumericCharacterReferenceEnd Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-semicolon-after-character-reference"
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doNumericCharacterReferenceEnd Lexer s
x

-- 12.2.5.79 Decimal character reference state
doDecimalCharacterReference :: Lexer s -> ST s ()
doDecimalCharacterReference :: Lexer s -> ST s ()
doDecimalCharacterReference x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Word8
c <- Lexer s -> ST s Word8
forall s. Lexer s -> ST s Word8
nextWord Lexer s
x
  if | Word8 -> Bool
chrASCIIDigit Word8
c -> do
         STRef s Int -> (Int -> Int) -> ST s ()
forall s a. STRef s a -> (a -> a) -> ST s ()
uref STRef s Int
lexerCode ((Int -> Int) -> ST s ()) -> (Int -> Int) -> ST s ()
forall a b. (a -> b) -> a -> b
$ \Int
y -> Int
10 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
y Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
c Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
0x30)
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doDecimalCharacterReference Lexer s
x
     | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
chrSemicolon -> do
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doNumericCharacterReferenceEnd Lexer s
x
     | Bool
otherwise -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"missing-semicolon-after-character-reference"
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
backWord Lexer s
x
         Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
doNumericCharacterReferenceEnd Lexer s
x

-- 12.2.5.80 Numeric character reference end state
doNumericCharacterReferenceEnd :: Lexer s -> ST s ()
doNumericCharacterReferenceEnd :: Lexer s -> ST s ()
doNumericCharacterReferenceEnd x :: Lexer s
x@Lexer {Bool
STRef s Int
STRef s [Word8]
STRef s (DList BS)
STRef s (Buffer s)
STRef s (TokenBuffer s)
STRef s LexerState
STRef s LexerSkip
BS
lexerCode :: STRef s Int
lexerErrors :: STRef s (DList BS)
lexerSkip :: STRef s LexerSkip
lexerReturn :: STRef s LexerState
lexerState :: STRef s LexerState
lexerLast :: STRef s [Word8]
lexerBuffer :: STRef s (Buffer s)
lexerToken :: STRef s (TokenBuffer s)
lexerOffset :: STRef s Int
lexerLog :: Bool
lexerIgnore :: Bool
lexerData :: BS
lexerCode :: forall s. Lexer s -> STRef s Int
lexerErrors :: forall s. Lexer s -> STRef s (DList BS)
lexerSkip :: forall s. Lexer s -> STRef s LexerSkip
lexerReturn :: forall s. Lexer s -> STRef s LexerState
lexerState :: forall s. Lexer s -> STRef s LexerState
lexerLast :: forall s. Lexer s -> STRef s [Word8]
lexerBuffer :: forall s. Lexer s -> STRef s (Buffer s)
lexerToken :: forall s. Lexer s -> STRef s (TokenBuffer s)
lexerOffset :: forall s. Lexer s -> STRef s Int
lexerLog :: forall s. Lexer s -> Bool
lexerIgnore :: forall s. Lexer s -> Bool
lexerData :: forall s. Lexer s -> BS
..} = do
  Int
c <- STRef s Int -> ST s Int
forall s a. STRef s a -> ST s a
rref STRef s Int
lexerCode
  let n :: Word8
n = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
c
  if | Int
c Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"null-character-reference"
         STRef s Int -> Int -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s Int
lexerCode Int
0xFFFD
     | Int
c Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0x10FFFF -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"character-reference-outside-unicode-range"
         STRef s Int -> Int -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s Int
lexerCode Int
0xFFFD
     | Int -> Bool
chrSurrogate Int
c -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"surrogate-character-reference"
         STRef s Int -> Int -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s Int
lexerCode Int
0xFFFD
     | Int -> Bool
chrNonCharacter Int
c -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"noncharacter-character-reference"
     | Int
c Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0x0D Bool -> Bool -> Bool
|| (Int -> Bool
chrWord8 Int
c Bool -> Bool -> Bool
&& Word8 -> Bool
chrControl Word8
n Bool -> Bool -> Bool
&& Bool -> Bool
not (Word8 -> Bool
chrWhitespace Word8
n)) -> do
         Lexer s -> BS -> ST s ()
forall s. Lexer s -> BS -> ST s ()
parseError Lexer s
x BS
"control-character-reference"
         Maybe Int -> (Int -> ST s ()) -> ST s ()
forall (m :: * -> *) a.
Applicative m =>
Maybe a -> (a -> m ()) -> m ()
whenJust (Int -> Map Int Int -> Maybe Int
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Int
c Map Int Int
codeMap) ((Int -> ST s ()) -> ST s ()) -> (Int -> ST s ()) -> ST s ()
forall a b. (a -> b) -> a -> b
$ STRef s Int -> Int -> ST s ()
forall s a. STRef s a -> a -> ST s ()
wref STRef s Int
lexerCode
     | Bool
otherwise ->
         () -> ST s ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
  STRef s (Buffer s) -> ST s ()
forall s. STRef s (Buffer s) -> ST s ()
bufferReset STRef s (Buffer s)
lexerBuffer
  [Word8] -> (Word8 -> ST s ()) -> ST s ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ (Int -> [Word8]
chrUTF8 Int
c) ((Word8 -> ST s ()) -> ST s ()) -> (Word8 -> ST s ()) -> ST s ()
forall a b. (a -> b) -> a -> b
$ (Word8 -> STRef s (Buffer s) -> ST s ())
-> STRef s (Buffer s) -> Word8 -> ST s ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip Word8 -> STRef s (Buffer s) -> ST s ()
forall s. Word8 -> STRef s (Buffer s) -> ST s ()
bufferAppend STRef s (Buffer s)
lexerBuffer
  Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
flushCodePoints Lexer s
x
  Lexer s -> ST s ()
forall s. Lexer s -> ST s ()
returnState Lexer s
x

-- | Character code map.
codeMap :: Map Int Int
codeMap :: Map Int Int
codeMap = [(Int, Int)] -> Map Int Int
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
  [ (Int
0x80, Int
0x20AC)
  , (Int
0x82, Int
0x201A)
  , (Int
0x83, Int
0x0192)
  , (Int
0x84, Int
0x201E)
  , (Int
0x85, Int
0x2026)
  , (Int
0x86, Int
0x2020)
  , (Int
0x87, Int
0x2021)
  , (Int
0x88, Int
0x02C6)
  , (Int
0x89, Int
0x2030)
  , (Int
0x8A, Int
0x0160)
  , (Int
0x8B, Int
0x2039)
  , (Int
0x8C, Int
0x0152)
  , (Int
0x8E, Int
0x017D)
  , (Int
0x91, Int
0x2018)
  , (Int
0x92, Int
0x2019)
  , (Int
0x93, Int
0x201C)
  , (Int
0x94, Int
0x201D)
  , (Int
0x95, Int
0x2022)
  , (Int
0x96, Int
0x2013)
  , (Int
0x97, Int
0x2014)
  , (Int
0x98, Int
0x02DC)
  , (Int
0x99, Int
0x2122)
  , (Int
0x9A, Int
0x0161)
  , (Int
0x9B, Int
0x203A)
  , (Int
0x9C, Int
0x0153)
  , (Int
0x9E, Int
0x017E)
  , (Int
0x9F, Int
0x0178)
  ]