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

 -- When 'UsePosPragsBit' is not set, it is expected that we emit a token instead

 -- of updating the position in 'PState'

         -- 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

 import Data.Maybe

 import Data.Semigroup qualified as S

 import GHC.Parser.PreProcess.Eval

 import GHC.Parser.PreProcess.ParsePP

 import GHC.Parser.PreProcess.Parser qualified as Parser

 import GHC.Parser.PreProcess.ParserM

 import GHC.Parser.PreProcess.State

 import GHC.Prelude

 import GHC.Types.SrcLoc

 import GHC.Utils.Outputable

 import GHC.Utils.Panic (panic)

 cppCond loc str = do

     s <- getPpState

     expanded <- expand loc (pp_defines s) str

         Left err -> do

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

 expand loc s str = do

         Left err -> do

                 )

 maxExpansions :: Int

 maxExpansions = 15

 expandToks loc 0 _ ts = do

 expandToks loc cnt s ts = do

 doExpandToks loc ed s (TIdentifierLParen n : ts) =

     -- TIdentifierLParen has no meaning here (only in a #define), so

     -- restore it to its constituent tokens

     case expandedArgs of

         (Just [[TIdentifier macro_name]], rest0) ->

             case Map.lookup macro_name s of

         (Nothing, TIdentifier macro_name : ts0) ->

             case Map.lookup macro_name s of

         (Nothing, _) -> do

         (Just args, _) -> do

 doExpandToks loc ed s (TIdentifier n : ts) = do

     (args, rest0) <- getExpandArgs loc ts

     let

                 (ed0, r, rest1) = case m_args of

                     Nothing -> (True, rhs, ts)

                     Just _ -> (True, replace_args args m_args rhs, rest0)

 doExpandToks loc ed s (t : ts) = do

 {-

 Note: ['defined' unary operator]

     ghcCppEnabled,

     setInLinePragma,

     getInLinePragma,

     addGhcCPPError,

 ) where

         , 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

     }

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

 addGhcCPPError :: SrcSpan -> SDoc -> P p ()

     Error evaluating CPP condition:

       Parse error at line 1, column 23 of

       2 + NONEXISTENT_MACRO ( 4 )

 GhcCpp02.hs:17:1: error: [GHC-93098]

     CPP macro expansion limit hit: FOO( 3 )

 GhcCpp02.hs:21:1: error: [GHC-93098]

     CPP defined: expected an identifier, got: 34

 GhcCpp02.hs:24:1: error: [GHC-93098]

     CPP defined: expected a single arg, got: A,B

 acceptStateChange :: AcceptingResult -> PP ()

 acceptStateChange ArNoChange = return ()

 acceptStateChange ArNowIgnoring = do

     Lexer.startSkipping

 acceptStateChange ArNowAccepting = do

     _ <- Lexer.stopSkipping

     return ()