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

-- | Defines a token type used by the lexer.
module Zenacy.HTML.Internal.Token
  ( Token(..)
  , TokenBuffer(..)
  , TAttr(..)
  , tokenAttr
  , tokenHasAttr
  , tokenGetAttr
  , tokenGetAttrVal
  , tokenBuffer
  , tokenCapacity
  , tokenReset
  , tokenTail
  , tokenFirst
  , tokenNext
  , tokenCount
  , tokenOffset
  , tokenList
  , tokenDrop
  , tokenHasEOF
  , tokenSlice
  , tokenTagStartName
  , tokenTagEndName
  , tokenDoctypeType
  , tokenTagStartType
  , tokenTagEndType
  , tokenCommentType
  , tokenCharType
  , tokenEOFType
  , tokenDoctypeInit
  , tokenDoctypeNameAppend
  , tokenDoctypeSetForceQuirks
  , tokenDoctypePublicIdInit
  , tokenDoctypePublicIdAppend
  , tokenDoctypeSystemIdInit
  , tokenDoctypeSystemIdAppend
  , tokenTagStartInit
  , tokenTagStartSetSelfClosing
  , tokenTagEndInit
  , tokenTagNameAppend
  , tokenAttrInit
  , tokenAttrNameAppend
  , tokenAttrValAppend
  , tokenAttrNamePrune
  , tokenCommentInit
  , tokenCommentAppend
  , tokenCharInit
  , tokenEOFInit
  , tokenType
  , tokenSize
  , tokenPack
  ) where

import Zenacy.HTML.Internal.BS
import Zenacy.HTML.Internal.Buffer
import Zenacy.HTML.Internal.Core
import Zenacy.HTML.Internal.Types
import Control.Monad
  ( when
  , forM
  )
import Control.Monad.Extra
  ( anyM
  )
import Control.Monad.ST
  ( ST
  )
import Data.STRef
  ( STRef
  , newSTRef
  , readSTRef
  , writeSTRef
  )
import Data.DList
  ( DList
  )
import qualified Data.DList as D
  ( empty
  , snoc
  , toList
  )
import Data.List
  ( find
  , or
  )
import Data.Maybe
  ( catMaybes
  , isJust
  )
import Data.Vector.Unboxed.Mutable
  ( MVector
  )
import qualified Data.Vector.Unboxed.Mutable as U
  ( new
  , length
  , read
  , write
  , grow
  )
import Data.Word
  ( Word8
  )

-- | Defines the token type.
-- The token type is used for testing and debugging only.
data Token
  = TDoctype
    { Token -> BS
tDoctypeName   :: !BS
    , Token -> Bool
tDoctypeQuirks :: !Bool
    , Token -> Maybe BS
tDoctypePublic :: !(Maybe BS)
    , Token -> Maybe BS
tDoctypeSystem :: !(Maybe BS)
    }
  | TStart
    { Token -> BS
tStartName     :: !BS
    , Token -> Bool
tStartClosed   :: !Bool
    , Token -> [TAttr]
tStartAttr     :: ![TAttr]
    }
  | TEnd
    { Token -> BS
tEndName       :: !BS
    }
  | TComment
    { Token -> BS
tCommentData   :: !BS
    }
  | TChar
    { Token -> Word8
tCharData      :: !Word8
    }
  | TEOF
    deriving (Token -> Token -> Bool
(Token -> Token -> Bool) -> (Token -> Token -> Bool) -> Eq Token
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Token -> Token -> Bool
$c/= :: Token -> Token -> Bool
== :: Token -> Token -> Bool
$c== :: Token -> Token -> Bool
Eq, Eq Token
Eq Token
-> (Token -> Token -> Ordering)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Bool)
-> (Token -> Token -> Token)
-> (Token -> Token -> Token)
-> Ord Token
Token -> Token -> Bool
Token -> Token -> Ordering
Token -> Token -> Token
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 :: Token -> Token -> Token
$cmin :: Token -> Token -> Token
max :: Token -> Token -> Token
$cmax :: Token -> Token -> Token
>= :: Token -> Token -> Bool
$c>= :: Token -> Token -> Bool
> :: Token -> Token -> Bool
$c> :: Token -> Token -> Bool
<= :: Token -> Token -> Bool
$c<= :: Token -> Token -> Bool
< :: Token -> Token -> Bool
$c< :: Token -> Token -> Bool
compare :: Token -> Token -> Ordering
$ccompare :: Token -> Token -> Ordering
$cp1Ord :: Eq Token
Ord, Int -> Token -> ShowS
[Token] -> ShowS
Token -> String
(Int -> Token -> ShowS)
-> (Token -> String) -> ([Token] -> ShowS) -> Show Token
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Token] -> ShowS
$cshowList :: [Token] -> ShowS
show :: Token -> String
$cshow :: Token -> String
showsPrec :: Int -> Token -> ShowS
$cshowsPrec :: Int -> Token -> ShowS
Show)

-- | An HTML element attribute type.
data TAttr = TAttr
  { TAttr -> BS
tAttrName      :: BS
  , TAttr -> BS
tAttrVal       :: BS
  , TAttr -> HTMLAttrNamespace
tAttrNamespace :: HTMLAttrNamespace
  } deriving (TAttr -> TAttr -> Bool
(TAttr -> TAttr -> Bool) -> (TAttr -> TAttr -> Bool) -> Eq TAttr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TAttr -> TAttr -> Bool
$c/= :: TAttr -> TAttr -> Bool
== :: TAttr -> TAttr -> Bool
$c== :: TAttr -> TAttr -> Bool
Eq, Eq TAttr
Eq TAttr
-> (TAttr -> TAttr -> Ordering)
-> (TAttr -> TAttr -> Bool)
-> (TAttr -> TAttr -> Bool)
-> (TAttr -> TAttr -> Bool)
-> (TAttr -> TAttr -> Bool)
-> (TAttr -> TAttr -> TAttr)
-> (TAttr -> TAttr -> TAttr)
-> Ord TAttr
TAttr -> TAttr -> Bool
TAttr -> TAttr -> Ordering
TAttr -> TAttr -> TAttr
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 :: TAttr -> TAttr -> TAttr
$cmin :: TAttr -> TAttr -> TAttr
max :: TAttr -> TAttr -> TAttr
$cmax :: TAttr -> TAttr -> TAttr
>= :: TAttr -> TAttr -> Bool
$c>= :: TAttr -> TAttr -> Bool
> :: TAttr -> TAttr -> Bool
$c> :: TAttr -> TAttr -> Bool
<= :: TAttr -> TAttr -> Bool
$c<= :: TAttr -> TAttr -> Bool
< :: TAttr -> TAttr -> Bool
$c< :: TAttr -> TAttr -> Bool
compare :: TAttr -> TAttr -> Ordering
$ccompare :: TAttr -> TAttr -> Ordering
$cp1Ord :: Eq TAttr
Ord, Int -> TAttr -> ShowS
[TAttr] -> ShowS
TAttr -> String
(Int -> TAttr -> ShowS)
-> (TAttr -> String) -> ([TAttr] -> ShowS) -> Show TAttr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TAttr] -> ShowS
$cshowList :: [TAttr] -> ShowS
show :: TAttr -> String
$cshow :: TAttr -> String
showsPrec :: Int -> TAttr -> ShowS
$cshowsPrec :: Int -> TAttr -> ShowS
Show)

-- | A type of buffer used to hold tokens.
data TokenBuffer s = TokenBuffer
  { TokenBuffer s -> MVector s Int
tbCntl :: MVector s Int
  , TokenBuffer s -> MVector s Word8
tbData :: MVector s Word8
  }

-- | Makes an attribute.
tokenAttr :: BS -> BS -> TAttr
tokenAttr :: BS -> BS -> TAttr
tokenAttr BS
n BS
v = BS -> BS -> HTMLAttrNamespace -> TAttr
TAttr BS
n BS
v HTMLAttrNamespace
HTMLAttrNamespaceNone

-- | Determines if a token has an attribute.
tokenHasAttr :: BS -> Token -> Bool
tokenHasAttr :: BS -> Token -> Bool
tokenHasAttr BS
x Token
t = Maybe TAttr -> Bool
forall a. Maybe a -> Bool
isJust (Maybe TAttr -> Bool) -> Maybe TAttr -> Bool
forall a b. (a -> b) -> a -> b
$ BS -> Token -> Maybe TAttr
tokenGetAttr BS
x Token
t

-- | Finds an attribute in a token.
tokenGetAttr :: BS -> Token -> Maybe TAttr
tokenGetAttr :: BS -> Token -> Maybe TAttr
tokenGetAttr BS
x = \case
  TStart{Bool
[TAttr]
BS
tStartAttr :: [TAttr]
tStartClosed :: Bool
tStartName :: BS
tStartAttr :: Token -> [TAttr]
tStartClosed :: Token -> Bool
tStartName :: Token -> BS
..} -> (TAttr -> Bool) -> [TAttr] -> Maybe TAttr
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find (\TAttr{BS
HTMLAttrNamespace
tAttrNamespace :: HTMLAttrNamespace
tAttrVal :: BS
tAttrName :: BS
tAttrNamespace :: TAttr -> HTMLAttrNamespace
tAttrVal :: TAttr -> BS
tAttrName :: TAttr -> BS
..} -> BS
tAttrName BS -> BS -> Bool
forall a. Eq a => a -> a -> Bool
== BS
x) [TAttr]
tStartAttr
  Token
_otherwise -> Maybe TAttr
forall a. Maybe a
Nothing

-- | Finds an attribute value for a token.
tokenGetAttrVal :: BS -> Token -> Maybe BS
tokenGetAttrVal :: BS -> Token -> Maybe BS
tokenGetAttrVal BS
x Token
t = TAttr -> BS
tAttrVal (TAttr -> BS) -> Maybe TAttr -> Maybe BS
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> BS -> Token -> Maybe TAttr
tokenGetAttr BS
x Token
t

-- | Makes a new token buffer.
tokenBuffer :: ST s (STRef s (TokenBuffer s))
tokenBuffer :: ST s (STRef s (TokenBuffer s))
tokenBuffer = do
  MVector s Int
c <- Int -> ST s (MVector (PrimState (ST s)) Int)
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
U.new Int
100
  MVector s Word8
d <- Int -> ST s (MVector (PrimState (ST s)) Word8)
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
U.new Int
100
  STRef s (TokenBuffer s)
r <- TokenBuffer s -> ST s (STRef s (TokenBuffer s))
forall a s. a -> ST s (STRef s a)
newSTRef (MVector s Int -> MVector s Word8 -> TokenBuffer s
forall s. MVector s Int -> MVector s Word8 -> TokenBuffer s
TokenBuffer MVector s Int
c MVector s Word8
d)
  STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenReset STRef s (TokenBuffer s)
r
  STRef s (TokenBuffer s) -> ST s (STRef s (TokenBuffer s))
forall (f :: * -> *) a. Applicative f => a -> f a
pure STRef s (TokenBuffer s)
r

-- | Gets the capacity of the buffer.
tokenCapacity :: STRef s (TokenBuffer s) -> ST s (Int, Int)
tokenCapacity :: STRef s (TokenBuffer s) -> ST s (Int, Int)
tokenCapacity STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  (Int, Int) -> ST s (Int, Int)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MVector s Int -> Int
forall a s. Unbox a => MVector s a -> Int
U.length MVector s Int
tbCntl, MVector s Word8 -> Int
forall a s. Unbox a => MVector s a -> Int
U.length MVector s Word8
tbData)

-- | Size of the buffer header.
headerSize :: Int
headerSize :: Int
headerSize = Int
4

-- | Resets a token buffer.
tokenReset :: STRef s (TokenBuffer s) -> ST s ()
tokenReset :: STRef s (TokenBuffer s) -> ST s ()
tokenReset STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
0 Int
1 -- data buffer length (skip first byte)
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
1 Int
0 -- token list head offset
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2 Int
0 -- token list tail offset
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
3 Int
0 -- token emit offset
  MVector (PrimState (ST s)) Word8 -> Int -> Word8 -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Word8
MVector (PrimState (ST s)) Word8
tbData Int
0 Word8
0 -- first byte is unsed

-- | Get the token buffer tail offset.
tokenTail :: STRef s (TokenBuffer s) -> ST s Int
tokenTail :: STRef s (TokenBuffer s) -> ST s Int
tokenTail STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2

-- | Positions the emitter to the first token and returns its offset.
tokenFirst :: STRef s (TokenBuffer s) -> ST s Int
tokenFirst :: STRef s (TokenBuffer s) -> ST s Int
tokenFirst STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
h <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
1
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
3 Int
h
  Int -> ST s Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
h

-- | Positions the emitter to the next token and returns its offset.
tokenNext :: STRef s (TokenBuffer s) -> ST s Int
tokenNext :: STRef s (TokenBuffer s) -> ST s Int
tokenNext STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
t <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2
  Int
i <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
3
  Int
n <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
  if Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
t
     then Int -> ST s Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
0
     else do
       let j :: Int
j = Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n
       MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
3 Int
j
       Int -> ST s Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
j

-- | Counts the number of tokens in the buffer.
tokenCount :: STRef s (TokenBuffer s) -> ST s Int
tokenCount :: STRef s (TokenBuffer s) -> ST s Int
tokenCount STRef s (TokenBuffer s)
r = (Int -> Int -> Int) -> Int -> STRef s (TokenBuffer s) -> ST s Int
forall a s.
(Int -> a -> a) -> a -> STRef s (TokenBuffer s) -> ST s a
tokenFold (\Int
i Int
n -> Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
0 STRef s (TokenBuffer s)
r

-- | Gets a list of the tokens in the buffer.
tokenOffset :: STRef s (TokenBuffer s) -> ST s [Int]
tokenOffset :: STRef s (TokenBuffer s) -> ST s [Int]
tokenOffset STRef s (TokenBuffer s)
r = DList Int -> [Int]
forall a. DList a -> [a]
D.toList (DList Int -> [Int]) -> ST s (DList Int) -> ST s [Int]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> DList Int -> DList Int)
-> DList Int -> STRef s (TokenBuffer s) -> ST s (DList Int)
forall a s.
(Int -> a -> a) -> a -> STRef s (TokenBuffer s) -> ST s a
tokenFold ((DList Int -> Int -> DList Int) -> Int -> DList Int -> DList Int
forall a b c. (a -> b -> c) -> b -> a -> c
flip DList Int -> Int -> DList Int
forall a. DList a -> a -> DList a
D.snoc) DList Int
forall a. DList a
D.empty STRef s (TokenBuffer s)
r

-- | Gets a list of the tokens in the buffer.
tokenList :: STRef s (TokenBuffer s) -> ST s [Token]
tokenList :: STRef s (TokenBuffer s) -> ST s [Token]
tokenList STRef s (TokenBuffer s)
r = STRef s (TokenBuffer s) -> ST s [Int]
forall s. STRef s (TokenBuffer s) -> ST s [Int]
tokenOffset STRef s (TokenBuffer s)
r ST s [Int] -> ([Int] -> ST s [Token]) -> ST s [Token]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Int -> ST s Token) -> [Int] -> ST s [Token]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((Int -> STRef s (TokenBuffer s) -> ST s Token)
-> STRef s (TokenBuffer s) -> Int -> ST s Token
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> STRef s (TokenBuffer s) -> ST s Token
forall s. Int -> STRef s (TokenBuffer s) -> ST s Token
tokenPack STRef s (TokenBuffer s)
r)

-- | Performs a fold over the token offsets in the buffer.
tokenFold :: (Int -> a -> a) -> a -> STRef s (TokenBuffer s) -> ST s a
tokenFold :: (Int -> a -> a) -> a -> STRef s (TokenBuffer s) -> ST s a
tokenFold Int -> a -> a
f a
a STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
i <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
3
  a
x <- a -> (STRef s (TokenBuffer s) -> ST s Int) -> ST s a
go a
a STRef s (TokenBuffer s) -> ST s Int
forall s. STRef s (TokenBuffer s) -> ST s Int
tokenFirst
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
3 Int
i
  a -> ST s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x
  where
    go :: a -> (STRef s (TokenBuffer s) -> ST s Int) -> ST s a
go a
b STRef s (TokenBuffer s) -> ST s Int
g = do
      Int
i <- STRef s (TokenBuffer s) -> ST s Int
g STRef s (TokenBuffer s)
r
      if Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
         then a -> ST s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
b
         else a -> (STRef s (TokenBuffer s) -> ST s Int) -> ST s a
go (Int -> a -> a
f Int
i a
b) STRef s (TokenBuffer s) -> ST s Int
forall s. STRef s (TokenBuffer s) -> ST s Int
tokenNext

-- | Drops the last token from the buffer.
tokenDrop :: STRef s (TokenBuffer s) -> ST s ()
tokenDrop :: STRef s (TokenBuffer s) -> ST s ()
tokenDrop STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
headPtr <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
1
  Int
tailPtr <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2
  Bool -> ST s () -> ST s ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
tailPtr Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0) (ST s () -> ST s ()) -> ST s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ do
    if Int
tailPtr Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
headPtr
       then STRef s (TokenBuffer s) -> ST s ()
forall s. STRef s (TokenBuffer s) -> ST s ()
tokenReset STRef s (TokenBuffer s)
r
       else MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *).
PrimMonad m =>
MVector (PrimState m) Int -> Int -> Int -> m ()
go MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
tailPtr Int
headPtr
  where
    go :: MVector (PrimState m) Int -> Int -> Int -> m ()
go MVector (PrimState m) Int
d Int
t Int
i = do
      Int
n <- MVector (PrimState m) Int -> Int -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector (PrimState m) Int
d (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
offsetSize)
      if Int
t Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n
         then MVector (PrimState m) Int -> Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector (PrimState m) Int
d Int
2 Int
i
         else MVector (PrimState m) Int -> Int -> Int -> m ()
go MVector (PrimState m) Int
d Int
t (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n)

-- | Returns whether a buffer includes an EOF token.
tokenHasEOF :: STRef s (TokenBuffer s) -> ST s Bool
tokenHasEOF :: STRef s (TokenBuffer s) -> ST s Bool
tokenHasEOF STRef s (TokenBuffer s)
r =
  STRef s (TokenBuffer s) -> ST s [Int]
forall s. STRef s (TokenBuffer s) -> ST s [Int]
tokenOffset STRef s (TokenBuffer s)
r ST s [Int] -> ([Int] -> ST s Bool) -> ST s Bool
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Int -> ST s Bool) -> [Int] -> ST s Bool
forall (m :: * -> *) a. Monad m => (a -> m Bool) -> [a] -> m Bool
anyM Int -> ST s Bool
isEOF
  where
    isEOF :: Int -> ST s Bool
isEOF Int
i = (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
tokenEOFType) (Int -> Bool) -> ST s Int -> ST s Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> STRef s (TokenBuffer s) -> ST s Int
forall s. Int -> STRef s (TokenBuffer s) -> ST s Int
tokenType Int
i STRef s (TokenBuffer s)
r

-- | Returns a slice of the data area of a token buffer.
tokenSlice :: Int -> Int -> STRef s (TokenBuffer s) -> ST s [Word8]
tokenSlice :: Int -> Int -> STRef s (TokenBuffer s) -> ST s [Word8]
tokenSlice Int
offset Int
len STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  MVector (PrimState (ST s)) Word8
-> Int -> Int -> DList Word8 -> ST s [Word8]
forall t (f :: * -> *) a.
(Eq t, Num t, PrimMonad f, Unbox a) =>
MVector (PrimState f) a -> Int -> t -> DList a -> f [a]
go MVector s Word8
MVector (PrimState (ST s)) Word8
tbData Int
offset Int
len DList Word8
forall a. DList a
D.empty
  where
    go :: MVector (PrimState f) a -> Int -> t -> DList a -> f [a]
go MVector (PrimState f) a
d Int
i t
0 DList a
a = [a] -> f [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([a] -> f [a]) -> [a] -> f [a]
forall a b. (a -> b) -> a -> b
$ DList a -> [a]
forall a. DList a -> [a]
D.toList DList a
a
    go MVector (PrimState f) a
d Int
i t
n DList a
a = do
      a
w <- MVector (PrimState f) a -> Int -> f a
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector (PrimState f) a
d Int
i
      MVector (PrimState f) a -> Int -> t -> DList a -> f [a]
go MVector (PrimState f) a
d (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (t
n t -> t -> t
forall a. Num a => a -> a -> a
- t
1) (DList a -> f [a]) -> DList a -> f [a]
forall a b. (a -> b) -> a -> b
$ DList a -> a -> DList a
forall a. DList a -> a -> DList a
D.snoc DList a
a a
w

-- | Returns the start tag name at for the token at an offset.
tokenTagStartName :: Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8])
tokenTagStartName :: Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8])
tokenTagStartName = Int -> Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8])
forall s.
Int -> Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8])
tagNameIfType Int
tokenTagStartType

-- | Returns the end tag name at for the token at an offset.
tokenTagEndName :: Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8])
tokenTagEndName :: Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8])
tokenTagEndName = Int -> Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8])
forall s.
Int -> Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8])
tagNameIfType Int
tokenTagEndType

-- | Returns the start tag name at for the token at an offset.
tagNameIfType :: Int -> Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8])
tagNameIfType :: Int -> Int -> STRef s (TokenBuffer s) -> ST s (Maybe [Word8])
tagNameIfType Int
t Int
x STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
a <- Int -> STRef s (TokenBuffer s) -> ST s Int
forall s. Int -> STRef s (TokenBuffer s) -> ST s Int
tokenType Int
x STRef s (TokenBuffer s)
r
  if Int
a Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
t
     then do
       Int
o <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
       Int
n <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3)
       [Word8] -> Maybe [Word8]
forall a. a -> Maybe a
Just ([Word8] -> Maybe [Word8]) -> ST s [Word8] -> ST s (Maybe [Word8])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Int -> STRef s (TokenBuffer s) -> ST s [Word8]
forall s. Int -> Int -> STRef s (TokenBuffer s) -> ST s [Word8]
tokenSlice Int
o Int
n STRef s (TokenBuffer s)
r
     else
       Maybe [Word8] -> ST s (Maybe [Word8])
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe [Word8]
forall a. Maybe a
Nothing

-- | Defines the type for a DOCTYPE token.
tokenDoctypeType :: Int
tokenDoctypeType :: Int
tokenDoctypeType = Int
101

-- | Defines the type for a start tag token.
tokenTagStartType :: Int
tokenTagStartType :: Int
tokenTagStartType = Int
102

-- | Defines the type for a end tag token.
tokenTagEndType :: Int
tokenTagEndType :: Int
tokenTagEndType = Int
103

-- | Defines the type for a comment token.
tokenCommentType :: Int
tokenCommentType :: Int
tokenCommentType = Int
104

-- | Defines the type for a character token.
tokenCharType :: Int
tokenCharType :: Int
tokenCharType = Int
105

-- | Defines the type for an EOF token.
tokenEOFType :: Int
tokenEOFType :: Int
tokenEOFType = Int
106

tokenInit :: Int -> STRef s (TokenBuffer s) -> ST s (MVector s Int, Int)
tokenInit :: Int -> STRef s (TokenBuffer s) -> ST s (MVector s Int, Int)
tokenInit Int
maxIndex STRef s (TokenBuffer s)
r = do
  t :: TokenBuffer s
t@TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
tailPtr <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2
  Int
i <- if Int
tailPtr Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
       then do
         MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
1 Int
headerSize
         MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2 Int
headerSize
         Int -> ST s Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
headerSize
       else do
         Int
n <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
tailPtr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
offsetSize)
         let j :: Int
j = Int
tailPtr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n
         MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2 Int
j
         Int -> ST s Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
j
  MVector s Int
c <- Int
-> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s (MVector s Int)
forall s.
Int
-> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s (MVector s Int)
ensureCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
maxIndex) TokenBuffer s
t STRef s (TokenBuffer s)
r
  (MVector s Int, Int) -> ST s (MVector s Int, Int)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MVector s Int
c, Int
i)

-- | Defines the size of the doctype token.
tokenDoctypeSize :: Int
tokenDoctypeSize :: Int
tokenDoctypeSize = Int
11

-- | Adds a new DOCTYPE token to the lexer.
tokenDoctypeInit :: STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeInit :: STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeInit STRef s (TokenBuffer s)
r = do
  (MVector s Int
c, Int
i) <- Int -> STRef s (TokenBuffer s) -> ST s (MVector s Int, Int)
forall s.
Int -> STRef s (TokenBuffer s) -> ST s (MVector s Int, Int)
tokenInit Int
10 STRef s (TokenBuffer s)
r
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0) Int
tokenDoctypeType
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
tokenDoctypeSize
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) Int
0 -- name offset
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3) Int
0 -- name length
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4) Int
0 -- force quirks flag
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5) Int
0 -- public id exists flag
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
6) Int
0 -- public id offset
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
7) Int
0 -- public id length
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
8) Int
0 -- system id exists flag
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
9) Int
0 -- system id offset
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
10) Int
0 -- system id length

-- | Appends a character to the current DOCTYPE token.
tokenDoctypeNameAppend :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeNameAppend :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeNameAppend = Int -> Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Int -> Word8 -> STRef s (TokenBuffer s) -> ST s ()
stringAppendTail Int
2

-- | Sets the force quirks flag for the current DOCTYPE.
tokenDoctypeSetForceQuirks :: STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks :: STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSetForceQuirks STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
i <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4) Int
1

-- | Initializes the DOCTYPE public ID.
tokenDoctypePublicIdInit :: STRef s (TokenBuffer s) -> ST s ()
tokenDoctypePublicIdInit :: STRef s (TokenBuffer s) -> ST s ()
tokenDoctypePublicIdInit STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
i <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5) Int
1

-- | Appends a character to the DOCTYPE public ID.
tokenDoctypePublicIdAppend :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenDoctypePublicIdAppend :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenDoctypePublicIdAppend = Int -> Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Int -> Word8 -> STRef s (TokenBuffer s) -> ST s ()
stringAppendTail Int
6

-- | Initializes the DOCTYPE system ID.
tokenDoctypeSystemIdInit :: STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSystemIdInit :: STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSystemIdInit STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
i <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
8) Int
1

-- | Appends a character to the DOCTYPE system ID.
tokenDoctypeSystemIdAppend :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSystemIdAppend :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenDoctypeSystemIdAppend = Int -> Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Int -> Word8 -> STRef s (TokenBuffer s) -> ST s ()
stringAppendTail Int
9

-- | Defines the size of an attribute record.
attrSize :: Int
attrSize :: Int
attrSize = Int
4

-- | Defines the offset to the start of the attributes.
attrStart :: Int
attrStart :: Int
attrStart = Int
6

-- | Defines the size of the start tag token.
tokenTagStartSize :: Int
tokenTagStartSize :: Int
tokenTagStartSize = Int
6

-- | Adds a new start tag to the lexer.
tokenTagStartInit :: STRef s (TokenBuffer s) -> ST s ()
tokenTagStartInit :: STRef s (TokenBuffer s) -> ST s ()
tokenTagStartInit STRef s (TokenBuffer s)
r = do
  (MVector s Int
c, Int
i) <- Int -> STRef s (TokenBuffer s) -> ST s (MVector s Int, Int)
forall s.
Int -> STRef s (TokenBuffer s) -> ST s (MVector s Int, Int)
tokenInit Int
5 STRef s (TokenBuffer s)
r
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0) Int
tokenTagStartType
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
tokenTagStartSize
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) Int
0 -- name offset
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3) Int
0 -- name length
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4) Int
0 -- self closing flag
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5) Int
0 -- attribute count

-- | Defines the size of the end tag token.
tokenTagEndSize :: Int
tokenTagEndSize :: Int
tokenTagEndSize = Int
4

-- | Adds a new end tag to the lexer.
tokenTagEndInit :: STRef s (TokenBuffer s) -> ST s ()
tokenTagEndInit :: STRef s (TokenBuffer s) -> ST s ()
tokenTagEndInit STRef s (TokenBuffer s)
r = do
  (MVector s Int
c, Int
i) <- Int -> STRef s (TokenBuffer s) -> ST s (MVector s Int, Int)
forall s.
Int -> STRef s (TokenBuffer s) -> ST s (MVector s Int, Int)
tokenInit Int
3 STRef s (TokenBuffer s)
r
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0) Int
tokenTagEndType
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
tokenTagEndSize
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) Int
0 -- name offset
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3) Int
0 -- name length

-- | Adds a new start tag to the lexer.
tokenTagStartSetSelfClosing :: STRef s (TokenBuffer s) -> ST s ()
tokenTagStartSetSelfClosing :: STRef s (TokenBuffer s) -> ST s ()
tokenTagStartSetSelfClosing STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
i <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4) Int
1

-- | Appends a character to a tag name if the token is a tag.
tokenTagNameAppend :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenTagNameAppend :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenTagNameAppend = Int -> Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Int -> Word8 -> STRef s (TokenBuffer s) -> ST s ()
stringAppendTail Int
2

-- | Starts a new attribute
tokenAttrInit :: STRef s (TokenBuffer s) -> ST s ()
tokenAttrInit :: STRef s (TokenBuffer s) -> ST s ()
tokenAttrInit STRef s (TokenBuffer s)
r = do
  t :: TokenBuffer s
t@TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
tailPtr <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2
  Int
m <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
tailPtr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
  Int
n <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
tailPtr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5)
  let i :: Int
i = Int
attrSize Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
attrStart Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
tailPtr
  MVector s Int
c <- Int
-> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s (MVector s Int)
forall s.
Int
-> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s (MVector s Int)
ensureCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3) TokenBuffer s
t STRef s (TokenBuffer s)
r
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0) Int
0 -- attribute name offset
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
0 -- attribute name length
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) Int
0 -- attribute value offset
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3) Int
0 -- attribute value length
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
tailPtr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (Int
m Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4) -- add attr to size of token
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
tailPtr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5) (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)

-- | Appends a character to the latest attribute name.
tokenAttrNameAppend :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenAttrNameAppend :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenAttrNameAppend Word8
x STRef s (TokenBuffer s)
r = do
  t :: TokenBuffer s
t@TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
tailPtr <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2
  Int
n <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
tailPtr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5)
  let i :: Int
i = Int
attrSize Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
attrStart Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
tailPtr
  Int -> Word8 -> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s ()
forall s.
Int -> Word8 -> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s ()
stringAppend (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0) Word8
x TokenBuffer s
t STRef s (TokenBuffer s)
r

-- | Appends a character to the latest attribute value.
tokenAttrValAppend :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenAttrValAppend :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenAttrValAppend Word8
x STRef s (TokenBuffer s)
r = do
  t :: TokenBuffer s
t@TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
tailPtr <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2
  Int
n <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
tailPtr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5)
  let i :: Int
i = Int
attrSize Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
attrStart Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
tailPtr
  Int -> Word8 -> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s ()
forall s.
Int -> Word8 -> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s ()
stringAppend (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) Word8
x TokenBuffer s
t STRef s (TokenBuffer s)
r

-- | Checks for duplicate attribute names.
--   Refer to section 12.2.5.33 for details.
tokenAttrNamePrune :: Int -> STRef s (TokenBuffer s) -> ST s Bool
tokenAttrNamePrune :: Int -> STRef s (TokenBuffer s) -> ST s Bool
tokenAttrNamePrune Int
x STRef s (TokenBuffer s)
r = do
  t :: TokenBuffer s
t@TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
a <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
offsetType)
  if Int
a Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
tokenTagStartType
  then Bool -> ST s Bool
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
  else do
    Int
attrCount <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5)
    [Bool]
u <- [Int] -> (Int -> ST s Bool) -> ST s [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Int
1 .. Int
attrCount] ((Int -> ST s Bool) -> ST s [Bool])
-> (Int -> ST s Bool) -> ST s [Bool]
forall a b. (a -> b) -> a -> b
$ \Int
j -> do
      let i :: Int
i = (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
attrSize Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
attrStart Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
x
      Int
no0 <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0)
      Int
nc0 <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
      [Bool]
match <- [Int] -> (Int -> ST s Bool) -> ST s [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Int
1 .. Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1] ((Int -> ST s Bool) -> ST s [Bool])
-> (Int -> ST s Bool) -> ST s [Bool]
forall a b. (a -> b) -> a -> b
$ \Int
k -> do
        let m :: Int
m = (Int
k Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
attrSize Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
attrStart Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
x
        Int
no1 <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
m Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0)
        Int
nc1 <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
m Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
        [Word8]
s0 <- Int -> Int -> STRef s (TokenBuffer s) -> ST s [Word8]
forall s. Int -> Int -> STRef s (TokenBuffer s) -> ST s [Word8]
tokenSlice Int
no0 Int
nc0 STRef s (TokenBuffer s)
r
        [Word8]
s1 <- Int -> Int -> STRef s (TokenBuffer s) -> ST s [Word8]
forall s. Int -> Int -> STRef s (TokenBuffer s) -> ST s [Word8]
tokenSlice Int
no1 Int
nc1 STRef s (TokenBuffer s)
r
        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
$ Int
nc0 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
nc1 Bool -> Bool -> Bool
&& [Word8]
s0 [Word8] -> [Word8] -> Bool
forall a. Eq a => a -> a -> Bool
== [Word8]
s1
      if [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or [Bool]
match
      then do
        MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0) Int
0
        MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
0
        Bool -> ST s Bool
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True
      else
        Bool -> ST s Bool
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
    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
$ [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or [Bool]
u

-- | Defines the size of the comment token.
tokenCommentSize :: Int
tokenCommentSize :: Int
tokenCommentSize = Int
4

-- | Adds a new comment token to the lexer.
tokenCommentInit :: STRef s (TokenBuffer s) -> ST s ()
tokenCommentInit :: STRef s (TokenBuffer s) -> ST s ()
tokenCommentInit STRef s (TokenBuffer s)
r = do
  (MVector s Int
c, Int
i) <- Int -> STRef s (TokenBuffer s) -> ST s (MVector s Int, Int)
forall s.
Int -> STRef s (TokenBuffer s) -> ST s (MVector s Int, Int)
tokenInit Int
3 STRef s (TokenBuffer s)
r
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0) Int
tokenCommentType
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
tokenCommentSize
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) Int
0 -- string offset
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3) Int
0 -- string length

-- | Appends a character to the current comment token.
tokenCommentAppend :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCommentAppend = Int -> Word8 -> STRef s (TokenBuffer s) -> ST s ()
forall s. Int -> Word8 -> STRef s (TokenBuffer s) -> ST s ()
stringAppendTail Int
2

-- | Defines the size of the char token.
tokenCharSize :: Int
tokenCharSize :: Int
tokenCharSize = Int
3

-- | Initializes a text token.
tokenCharInit :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit :: Word8 -> STRef s (TokenBuffer s) -> ST s ()
tokenCharInit Word8
x STRef s (TokenBuffer s)
r = do
  TokenBuffer s
t <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  (MVector s Int
c, Int
i) <- Int -> STRef s (TokenBuffer s) -> ST s (MVector s Int, Int)
forall s.
Int -> STRef s (TokenBuffer s) -> ST s (MVector s Int, Int)
tokenInit Int
2 STRef s (TokenBuffer s)
r
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0) Int
tokenCharType
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
tokenCharSize
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
x)

-- | Defines the size of the eof token.
tokenEOFSize :: Int
tokenEOFSize :: Int
tokenEOFSize = Int
2

-- | Initializes an EOF token.
tokenEOFInit :: STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit :: STRef s (TokenBuffer s) -> ST s ()
tokenEOFInit STRef s (TokenBuffer s)
r = do
  (MVector s Int
c, Int
i) <- Int -> STRef s (TokenBuffer s) -> ST s (MVector s Int, Int)
forall s.
Int -> STRef s (TokenBuffer s) -> ST s (MVector s Int, Int)
tokenInit Int
2 STRef s (TokenBuffer s)
r
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0) Int
tokenEOFType
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
c (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
tokenEOFSize

-- | Defines the token offset for the type field.
offsetType :: Int
offsetType :: Int
offsetType = Int
0

-- | Defines the token offset for the size field.
offsetSize :: Int
offsetSize :: Int
offsetSize = Int
1

-- | Gets the type of a token.
tokenType :: Int -> STRef s (TokenBuffer s) -> ST s Int
tokenType :: Int -> STRef s (TokenBuffer s) -> ST s Int
tokenType Int
x STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
offsetType)

-- | Gets the size of a token.
tokenSize :: Int -> STRef s (TokenBuffer s) -> ST s Int
tokenSize :: Int -> STRef s (TokenBuffer s) -> ST s Int
tokenSize Int
x STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
offsetSize)

-- | Unpacks a token at the specified index.
tokenPack :: Int -> STRef s (TokenBuffer s) -> ST s Token
tokenPack :: Int -> STRef s (TokenBuffer s) -> ST s Token
tokenPack Int
x STRef s (TokenBuffer s)
r = do
  TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
t <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
x
  Int
n <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
0
  BS
s <- MVector s Word8 -> Int -> ST s BS
forall s. MVector s Word8 -> Int -> ST s BS
bufferString MVector s Word8
tbData Int
n
  if | Int
t Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
tokenDoctypeType ->  Int -> MVector s Int -> BS -> ST s Token
forall s. Int -> MVector s Int -> BS -> ST s Token
packDoctype Int
x MVector s Int
tbCntl BS
s
     | Int
t Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
tokenTagStartType -> Int -> MVector s Int -> BS -> ST s Token
forall s. Int -> MVector s Int -> BS -> ST s Token
packTagStart Int
x MVector s Int
tbCntl BS
s
     | Int
t Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
tokenTagEndType ->   Int -> MVector s Int -> BS -> ST s Token
forall s. Int -> MVector s Int -> BS -> ST s Token
packTagEnd Int
x MVector s Int
tbCntl BS
s
     | Int
t Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
tokenCommentType ->  Int -> MVector s Int -> BS -> ST s Token
forall s. Int -> MVector s Int -> BS -> ST s Token
packComment Int
x MVector s Int
tbCntl BS
s
     | Int
t Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
tokenCharType ->     Int -> MVector s Int -> ST s Token
forall s. Int -> MVector s Int -> ST s Token
packChar Int
x MVector s Int
tbCntl
     | Int
t Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
tokenEOFType ->      Token -> ST s Token
forall (f :: * -> *) a. Applicative f => a -> f a
pure Token
TEOF
     | Bool
otherwise ->              Token -> ST s Token
forall (f :: * -> *) a. Applicative f => a -> f a
pure Token
TEOF

-- | Unpacks a doctype token.
packDoctype :: Int -> MVector s Int -> BS -> ST s Token
packDoctype :: Int -> MVector s Int -> BS -> ST s Token
packDoctype Int
x MVector s Int
tbCntl BS
bs = do
  Int
nameOffset <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
  Int
nameLen    <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3)
  Int
quirks     <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4)
  Int
pubExists  <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5)
  Int
pubOffset  <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
6)
  Int
pubLen     <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
7)
  Int
sysExists  <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
8)
  Int
sysOffset  <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
9)
  Int
sysLen     <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
10)
  Token -> ST s Token
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Token -> ST s Token) -> Token -> ST s Token
forall a b. (a -> b) -> a -> b
$ BS -> Bool -> Maybe BS -> Maybe BS -> Token
TDoctype
    (Int -> Int -> BS -> BS
bsPart Int
nameOffset Int
nameLen BS
bs)
    (Int
quirks Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1)
    (if Int
pubExists Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 then BS -> Maybe BS
forall a. a -> Maybe a
Just (Int -> Int -> BS -> BS
bsPart Int
pubOffset Int
pubLen BS
bs) else Maybe BS
forall a. Maybe a
Nothing)
    (if Int
sysExists Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 then BS -> Maybe BS
forall a. a -> Maybe a
Just (Int -> Int -> BS -> BS
bsPart Int
sysOffset Int
sysLen BS
bs) else Maybe BS
forall a. Maybe a
Nothing)

-- | Unpacks an start tag token.
packTagStart :: Int -> MVector s Int -> BS -> ST s Token
packTagStart :: Int -> MVector s Int -> BS -> ST s Token
packTagStart Int
x MVector s Int
tbCntl BS
bs = do
  Int
nameOffset <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
  Int
nameLen    <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3)
  Int
selfClose  <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4)
  Int
attrCount  <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5)
  [Maybe TAttr]
attr <- [Int] -> (Int -> ST s (Maybe TAttr)) -> ST s [Maybe TAttr]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Int
1 .. Int
attrCount] ((Int -> ST s (Maybe TAttr)) -> ST s [Maybe TAttr])
-> (Int -> ST s (Maybe TAttr)) -> ST s [Maybe TAttr]
forall a b. (a -> b) -> a -> b
$ \Int
j -> do
    let i :: Int
i = (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
attrSize Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
attrStart Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
x
    Int
no <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0)
    Int
nc <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
    Int
ao <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
    Int
ac <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3)
    Maybe TAttr -> ST s (Maybe TAttr)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe TAttr -> ST s (Maybe TAttr))
-> Maybe TAttr -> ST s (Maybe TAttr)
forall a b. (a -> b) -> a -> b
$
      if Int
no Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0
      then TAttr -> Maybe TAttr
forall a. a -> Maybe a
Just (TAttr -> Maybe TAttr) -> TAttr -> Maybe TAttr
forall a b. (a -> b) -> a -> b
$ BS -> BS -> HTMLAttrNamespace -> TAttr
TAttr
        (Int -> Int -> BS -> BS
bsPart Int
no Int
nc BS
bs)
        (Int -> Int -> BS -> BS
bsPart Int
ao Int
ac BS
bs)
        HTMLAttrNamespace
HTMLAttrNamespaceNone
      else Maybe TAttr
forall a. Maybe a
Nothing
  Token -> ST s Token
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Token -> ST s Token) -> Token -> ST s Token
forall a b. (a -> b) -> a -> b
$ BS -> Bool -> [TAttr] -> Token
TStart
    (Int -> Int -> BS -> BS
bsPart Int
nameOffset Int
nameLen BS
bs)
    (Int
selfClose Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1)
    ([Maybe TAttr] -> [TAttr]
forall a. [Maybe a] -> [a]
catMaybes [Maybe TAttr]
attr)

-- | Unpacks an end tag token.
packTagEnd :: Int -> MVector s Int -> BS -> ST s Token
packTagEnd :: Int -> MVector s Int -> BS -> ST s Token
packTagEnd Int
x MVector s Int
tbCntl BS
bs = do
  Int
nameOffset <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
  Int
nameLen    <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3)
  Token -> ST s Token
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Token -> ST s Token) -> Token -> ST s Token
forall a b. (a -> b) -> a -> b
$ BS -> Token
TEnd (BS -> Token) -> BS -> Token
forall a b. (a -> b) -> a -> b
$ Int -> Int -> BS -> BS
bsPart Int
nameOffset Int
nameLen BS
bs

-- | Unpacks a comment token.
packComment :: Int -> MVector s Int -> BS -> ST s Token
packComment :: Int -> MVector s Int -> BS -> ST s Token
packComment Int
x MVector s Int
tbCntl BS
bs = do
  Int
o <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
  Int
n <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3)
  Token -> ST s Token
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Token -> ST s Token) -> Token -> ST s Token
forall a b. (a -> b) -> a -> b
$ BS -> Token
TComment (BS -> Token) -> BS -> Token
forall a b. (a -> b) -> a -> b
$ Int -> Int -> BS -> BS
bsPart Int
o Int
n BS
bs

-- | Unpacks a character token.
packChar :: Int -> MVector s Int -> ST s Token
packChar :: Int -> MVector s Int -> ST s Token
packChar Int
x MVector s Int
tbCntl = do
  Int
c <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
  Token -> ST s Token
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Token -> ST s Token) -> Token -> ST s Token
forall a b. (a -> b) -> a -> b
$ Word8 -> Token
TChar (Word8 -> Token) -> Word8 -> Token
forall a b. (a -> b) -> a -> b
$ Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
c

-- | Appends a character to a string at an offset in the current token.
stringAppendTail :: Int -> Word8 -> STRef s (TokenBuffer s) -> ST s ()
stringAppendTail :: Int -> Word8 -> STRef s (TokenBuffer s) -> ST s ()
stringAppendTail Int
offset Word8
word STRef s (TokenBuffer s)
r = do
  t :: TokenBuffer s
t@TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} <- STRef s (TokenBuffer s) -> ST s (TokenBuffer s)
forall s a. STRef s a -> ST s a
readSTRef STRef s (TokenBuffer s)
r
  Int
tailPtr <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
2
  Int -> Word8 -> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s ()
forall s.
Int -> Word8 -> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s ()
stringAppend (Int
tailPtr Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
offset) Word8
word TokenBuffer s
t STRef s (TokenBuffer s)
r
{-# INLINE stringAppendTail #-}

-- | Appends a character to a string at an offset.
stringAppend :: Int -> Word8 -> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s ()
stringAppend :: Int -> Word8 -> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s ()
stringAppend Int
x Word8
word t :: TokenBuffer s
t@TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} STRef s (TokenBuffer s)
r = do
  let y :: Int
y = Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
  Int
i <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
0
  Int
o <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
x
  Int
n <- MVector (PrimState (ST s)) Int -> Int -> ST s Int
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
U.read MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
y
  MVector s Word8
d <- Int
-> TokenBuffer s
-> STRef s (TokenBuffer s)
-> ST s (MVector s Word8)
forall s.
Int
-> TokenBuffer s
-> STRef s (TokenBuffer s)
-> ST s (MVector s Word8)
ensureData Int
i TokenBuffer s
t STRef s (TokenBuffer s)
r
  MVector (PrimState (ST s)) Word8 -> Int -> Word8 -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Word8
MVector (PrimState (ST s)) Word8
d Int
i Word8
word
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
0 (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
  MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
y (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
  Bool -> ST s () -> ST s ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
o Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0) (ST s () -> ST s ()) -> ST s () -> ST s ()
forall a b. (a -> b) -> a -> b
$
    MVector (PrimState (ST s)) Int -> Int -> Int -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
U.write MVector s Int
MVector (PrimState (ST s)) Int
tbCntl Int
x Int
i
{-# INLINE stringAppend #-}

-- | Ensures that the control buffer has enough space and grows it if needed.
ensureCntl :: Int -> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s (MVector s Int)
ensureCntl :: Int
-> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s (MVector s Int)
ensureCntl Int
x TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} STRef s (TokenBuffer s)
r
  | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< MVector s Int -> Int
forall a s. Unbox a => MVector s a -> Int
U.length MVector s Int
tbCntl =
      MVector s Int -> ST s (MVector s Int)
forall (f :: * -> *) a. Applicative f => a -> f a
pure MVector s Int
tbCntl
  | Bool
otherwise = do
      MVector s Int
v <- MVector (PrimState (ST s)) Int
-> Int -> ST s (MVector (PrimState (ST s)) Int)
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
U.grow MVector s Int
MVector (PrimState (ST s)) Int
tbCntl (Int -> ST s (MVector (PrimState (ST s)) Int))
-> Int -> ST s (MVector (PrimState (ST s)) Int)
forall a b. (a -> b) -> a -> b
$ MVector s Int -> Int
forall a s. Unbox a => MVector s a -> Int
U.length MVector s Int
tbCntl
      STRef s (TokenBuffer s) -> TokenBuffer s -> ST s ()
forall s a. STRef s a -> a -> ST s ()
writeSTRef STRef s (TokenBuffer s)
r (TokenBuffer s -> ST s ()) -> TokenBuffer s -> ST s ()
forall a b. (a -> b) -> a -> b
$ MVector s Int -> MVector s Word8 -> TokenBuffer s
forall s. MVector s Int -> MVector s Word8 -> TokenBuffer s
TokenBuffer MVector s Int
v MVector s Word8
tbData
      MVector s Int -> ST s (MVector s Int)
forall (f :: * -> *) a. Applicative f => a -> f a
pure MVector s Int
v
{-# INLINE ensureCntl #-}

-- | Ensures that the data buffer has enough space and grows it if needed.
ensureData :: Int -> TokenBuffer s -> STRef s (TokenBuffer s) -> ST s (MVector s Word8)
ensureData :: Int
-> TokenBuffer s
-> STRef s (TokenBuffer s)
-> ST s (MVector s Word8)
ensureData Int
x TokenBuffer{MVector s Int
MVector s Word8
tbData :: MVector s Word8
tbCntl :: MVector s Int
tbData :: forall s. TokenBuffer s -> MVector s Word8
tbCntl :: forall s. TokenBuffer s -> MVector s Int
..} STRef s (TokenBuffer s)
r
  | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< MVector s Word8 -> Int
forall a s. Unbox a => MVector s a -> Int
U.length MVector s Word8
tbData =
      MVector s Word8 -> ST s (MVector s Word8)
forall (f :: * -> *) a. Applicative f => a -> f a
pure MVector s Word8
tbData
  | Bool
otherwise = do
      MVector s Word8
v <- MVector (PrimState (ST s)) Word8
-> Int -> ST s (MVector (PrimState (ST s)) Word8)
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
U.grow MVector s Word8
MVector (PrimState (ST s)) Word8
tbData (Int -> ST s (MVector (PrimState (ST s)) Word8))
-> Int -> ST s (MVector (PrimState (ST s)) Word8)
forall a b. (a -> b) -> a -> b
$ MVector s Word8 -> Int
forall a s. Unbox a => MVector s a -> Int
U.length MVector s Word8
tbData
      STRef s (TokenBuffer s) -> TokenBuffer s -> ST s ()
forall s a. STRef s a -> a -> ST s ()
writeSTRef STRef s (TokenBuffer s)
r (TokenBuffer s -> ST s ()) -> TokenBuffer s -> ST s ()
forall a b. (a -> b) -> a -> b
$ MVector s Int -> MVector s Word8 -> TokenBuffer s
forall s. MVector s Int -> MVector s Word8 -> TokenBuffer s
TokenBuffer MVector s Int
tbCntl MVector s Word8
v
      MVector s Word8 -> ST s (MVector s Word8)
forall (f :: * -> *) a. Applicative f => a -> f a
pure MVector s Word8
v
{-# INLINE ensureData #-}