Token(..), lexer, lexerDbg,

    ParserOpts(..), mkParserOpts,

    PState (..), initParserState, initPragState,

    startSkipping, stopSkipping,

    P(..), ParseResult(POk, PFailed),

    allocateComments, allocatePriorComments, allocateFinalComments,

 -- set.

 "{-" / { isNormalComment }       { nested_comment }

 -- Single-line comments are a bit tricky.  Haskell 98 says that two or

 -- more dashes followed by a symbol should be parsed as a varsym, so we

 hopefully_open_brace span buf len buf2

  = do relaxed <- getBit RelaxedLayoutBit

       ctx <- getContext

       offset <- getOffset

       let

           isOK = relaxed ||

         dropTrailingDec "-}" = ""

         dropTrailingDec (x:xs) = x:dropTrailingDec xs

 {-# INLINE nested_comment_logic #-}

 -- | Includes the trailing '-}' decorators

 -- drop the last two elements with the callback if you don't want them to be included

         Just (_,_)   -> go ('\n':commentAcc) n input

       Just (c,input) -> go (c:commentAcc) n input

 ghcCppSet :: P p Bool

 ghcCppSet = do

   exts <- getExts

   usePosPrags <- getBit UsePosPragsBit

   if usePosPrags

     then begin line_prag2 span buf len buf2

     -- else let !src = lexemeToFastString buf len

     --      in return (L span (ITline_prag (SourceText src)))

     else nested_comment span buf len buf2

         -- See Note [Nested comment line pragmas]

         b <- getBit InNestedCommentBit

         if b then return (L span ITcomment_line_prag) else do

           resetOffset

           (pos, gen_semic) <- getOffside

           case pos of

 new_layout_context :: Bool -> Bool -> Token -> Action p

 new_layout_context strict gen_semic tok span _buf len _buf2 = do

     _ <- popLexState

     current_col <- getOffset

     let offset = current_col - len

     ctx <- getContext

         pp :: !a,

         -- If a CPP directive occurs in the layout context, we need to

         -- store the prior column so any alr processing can continue.

         pp_last_col :: !(Maybe Int)

      }

         -- last_loc and last_len are used when generating error messages,

         -- of the action, it is the *current* token.  Do I understand

         -- correctly?

 data PpContext = PpContextIf [Located Token]

     deriving (Show)

 getLastLen :: P p Int

 getLastLen = P $ \s@(PState { last_len = last_len }) -> POk s last_len

 getOffset :: P p Int

 getOffset = P $ \s@(PState { pp_last_col = last_col,

                              loc = l}) ->

     --          (fromMaybe (srcLocCol (psRealLoc l)) last_col)

   in POk s { pp_last_col = Nothing} offset

 resetOffset :: P p ()

 resetOffset = P $ \s -> POk s { pp_last_col = Nothing} ()

 startSkipping :: P p ()

 startSkipping = do

   pushLexState skipping

   -- pushLexState (trace ("startSkipping:" ++ show skipping) skipping)

 stopSkipping = do

   -- We just processed a CPP directive, which included a trailing newline.

   -- To properly sync up, we now need to ensure that `do_bol` processing occurs.

   last_tk <- getLastTk

   case last_tk of

     Strict.Just (L l _) -> do

       let ps' = PsLoc (realSrcSpanEnd (psRealSpan l)) (bufSpanEnd (psBufSpan l))

       let cur' = (cur buf) - 1

       setInput (AI ps' (buf { cur = cur'}))

     _ -> return ()

   -- old <- popLexState

   -- return (trace ("stopSkipping:" ++ show old) old)

 {-# INLINE alexGetChar' #-}

 -- This version does not squash unicode characters, it is used when

   where

     upd_bitmap f = opts { pExtsBitmap = f (pExtsBitmap opts) }

 enableGhcCpp :: ParserOpts -> ParserOpts

 enableGhcCpp = enableExtBit GhcCppBit

 %************************************************************************

 -}

 -- |Given a 'RealSrcSpan' that surrounds a 'HsPar' or 'HsParTy', generate

 -- 'EpToken' values for the opening and closing bordering on the start

 -- and end of the span

 ) where

 import Data.List (intercalate, sortBy)

 import Data.Map qualified as Map

 import Debug.Trace (trace)

 import GHC.Data.FastString

 import GHC.Data.Strict qualified as Strict

 import GHC.Driver.DynFlags (DynFlags, xopt)

 import GHC.LanguageExtensions qualified as LangExt

 import GHC.Parser.Errors.Ppr ()

 import GHC.Parser.Lexer (P (..), PState (..), ParseResult (..), Token (..))

 import GHC.Parser.Lexer qualified as Lexer

 import GHC.Parser.PreProcess.Macro

 import GHC.Utils.Error

 import GHC.Utils.Outputable (text)

 import GHC.Utils.Panic.Plain (panic)

 -- ---------------------------------------------------------------------

 dumpGhcCpp dflags pst = output

   where

     ghc_cpp_enabled = xopt LangExt.GhcCpp dflags

     -- Note: pst is the state /before/ the parser runs, so we can use it to lex.

     (pst_final, bare_toks) = lexAll pst

     comments = reverse (Lexer.comment_q pst_final)

 -- ---------------------------------------------------------------------

 -- addSourceToTokens copied here to unbreak an import loop.

 -- It should probably move somewhere else

 {- | Given a source location and a StringBuffer corresponding to this

 location, return a rich token stream with the source associated to the

 -- ---------------------------------------------------------------------

 showCppTokenStream :: [(Located Token, String)] -> String

 showCppTokenStream ts0 = go startLoc ts0 ""

   where

                     ppLexer queueComments cont

              in

                 case tk of

                     L _ ITeof -> do

                         mInp <- popIncludeLoc

                         case mInp of

                                         case mdump of

                                             Just dump ->

                                                 -- We have a dump of the state, put it into an ignored token

                                                 contIgnoreTok (L l (ITcpp continuation (appendFS s (fsLit dump)) sp))

                                             Nothing -> contIgnoreTok tk

                             else contInner tk

                     L _ (ITcppIgnored _ _) -> contIgnoreTok tk

                     _ -> do

                         state <- getCppState

                         inLinePragma <- getInLinePragma

     -- Combine any prior continuation tokens

     cs <- popContinuation

     let loc = combineLocs fs (fromMaybe fs (listToMaybe cs))

 processCpp :: SrcSpan -> String -> PP (Maybe String)

 processCpp loc s = do

         then return (Just "\ndumped state\n")

         else do

             case directive of

                 Right (CppInclude filename) -> do

                     ppInclude filename

                 Right (CppIf cond) -> do

                     val <- cppCond loc cond

                     ar <- pushAccepting val

         , pp_continuation = []

         , pp_defines = Map.empty

         , pp_scope = (PpScope True PpNoGroup) :| []

         , pp_in_line_pragma = False

         }

     , pp_continuation :: ![Located Lexer.Token]

     , pp_defines :: !MacroDefines

     , pp_scope :: !(NonEmpty PpScope)

     , pp_in_line_pragma :: !Bool

     }

 acceptStateChange :: AcceptingResult -> PP ()

 acceptStateChange ArNoChange = return ()

 acceptStateChange ArNowIgnoring = do

     Lexer.startSkipping

 acceptStateChange ArNowAccepting = do

     _ <- Lexer.stopSkipping

     return ()