c76ef95 · typeable/pandoc

155a >>~ b = a >>= \x -> b >> return x

156

157-- | Parse any line of text

158−anyLine :: Parsec [Char] st [Char]

158+anyLine :: Parser [Char] st [Char]

159anyLine = manyTill anyChar newline

160

161-- | Like @manyTill@, but reads at least one item.

162−many1Till :: Parsec [tok] st a

162+many1Till :: Parser [tok] st a

163− -> Parsec [tok] st end

163+ -> Parser [tok] st end

164− -> Parsec [tok] st [a]

164+ -> Parser [tok] st [a]

165many1Till p end = do

166 first <- p

167 rest <- manyTill p end

170-- | A more general form of @notFollowedBy@. This one allows any

171-- type of parser to be specified, and succeeds only if that parser fails.

172-- It does not consume any input.

173−notFollowedBy' :: Show b => Parsec [a] st b -> Parsec [a] st ()

173+notFollowedBy' :: Show b => Parser [a] st b -> Parser [a] st ()

174notFollowedBy' p = try $ join $ do a <- try p

175 return (unexpected (show a))

176 <|>

178-- (This version due to Andrew Pimlott on the Haskell mailing list.)

179

180-- | Parses one of a list of strings (tried in order).

181−oneOfStrings :: [String] -> Parsec [Char] st String

181+oneOfStrings :: [String] -> Parser [Char] st String

182oneOfStrings [] = fail "no strings"

183oneOfStrings strs = do

184 c <- anyChar

189 | otherwise -> (c:) `fmap` oneOfStrings strs'

190

191-- | Parses a space or tab.

192−spaceChar :: Parsec [Char] st Char

192+spaceChar :: Parser [Char] st Char

193spaceChar = satisfy $ \c -> c == ' ' || c == '\t'

194

195-- | Parses a nonspace, nonnewline character.

196−nonspaceChar :: Parsec [Char] st Char

196+nonspaceChar :: Parser [Char] st Char

197nonspaceChar = satisfy $ \x -> x /= '\t' && x /= '\n' && x /= ' ' && x /= '\r'

198

199-- | Skips zero or more spaces or tabs.

200−skipSpaces :: Parsec [Char] st ()

200+skipSpaces :: Parser [Char] st ()

201skipSpaces = skipMany spaceChar

202

203-- | Skips zero or more spaces or tabs, then reads a newline.

204−blankline :: Parsec [Char] st Char

204+blankline :: Parser [Char] st Char

205blankline = try $ skipSpaces >> newline

206

207-- | Parses one or more blank lines and returns a string of newlines.

208−blanklines :: Parsec [Char] st [Char]

208+blanklines :: Parser [Char] st [Char]

209blanklines = many1 blankline

210

211-- | Parses material enclosed between start and end parsers.

212−enclosed :: Parsec [Char] st t -- ^ start parser

212+enclosed :: Parser [Char] st t -- ^ start parser

213− -> Parsec [Char] st end -- ^ end parser

213+ -> Parser [Char] st end -- ^ end parser

214− -> Parsec [Char] st a -- ^ content parser (to be used repeatedly)

214+ -> Parser [Char] st a -- ^ content parser (to be used repeatedly)

215− -> Parsec [Char] st [a]

215+ -> Parser [Char] st [a]

216enclosed start end parser = try $

217 start >> notFollowedBy space >> many1Till parser end

218

219-- | Parse string, case insensitive.

220−stringAnyCase :: [Char] -> Parsec [Char] st String

220+stringAnyCase :: [Char] -> Parser [Char] st String

221stringAnyCase [] = string ""

222stringAnyCase (x:xs) = do

223 firstChar <- char (toUpper x) <|> char (toLower x)

225 return (firstChar:rest)

226

227-- | Parse contents of 'str' using 'parser' and return result.

228−parseFromString :: Parsec [tok] st a -> [tok] -> Parsec [tok] st a

228+parseFromString :: Parser [tok] st a -> [tok] -> Parser [tok] st a

229parseFromString parser str = do

230 oldPos <- getPosition

231 oldInput <- getInput

236 return result

237

238-- | Parse raw line block up to and including blank lines.

239−lineClump :: Parsec [Char] st String

239+lineClump :: Parser [Char] st String

240lineClump = blanklines

241 <|> (many1 (notFollowedBy blankline >> anyLine) >>= return . unlines)

242

245-- pairs of open and close, which must be different. For example,

246-- @charsInBalanced '(' ')' anyChar@ will parse "(hello (there))"

247-- and return "hello (there)".

248−charsInBalanced :: Char -> Char -> Parsec [Char] st Char

248+charsInBalanced :: Char -> Char -> Parser [Char] st Char

249− -> Parsec [Char] st String

249+ -> Parser [Char] st String

250charsInBalanced open close parser = try $ do

251 char open

252 let isDelim c = c == open || c == close

271

272-- | Parses a roman numeral (uppercase or lowercase), returns number.

273romanNumeral :: Bool -- ^ Uppercase if true

274− -> Parsec [Char] st Int

274+ -> Parser [Char] st Int

275romanNumeral upperCase = do

276 let romanDigits = if upperCase

277 then uppercaseRomanDigits

301

302-- Parsers for email addresses and URIs

303

304−emailChar :: Parsec [Char] st Char

304+emailChar :: Parser [Char] st Char

305emailChar = alphaNum <|>

306 satisfy (\c -> c == '-' || c == '+' || c == '_' || c == '.')

307

308−domainChar :: Parsec [Char] st Char

308+domainChar :: Parser [Char] st Char

309domainChar = alphaNum <|> char '-'

310

311−domain :: Parsec [Char] st [Char]

311+domain :: Parser [Char] st [Char]

312domain = do

313 first <- many1 domainChar

314 dom <- many1 $ try (char '.' >> many1 domainChar )

316

317-- | Parses an email address; returns original and corresponding

318-- escaped mailto: URI.

319−emailAddress :: Parsec [Char] st (String, String)

319+emailAddress :: Parser [Char] st (String, String)

320emailAddress = try $ do

321 firstLetter <- alphaNum

322 restAddr <- many emailChar

327 return (full, escapeURI $ "mailto:" ++ full)

328

329-- | Parses a URI. Returns pair of original and URI-escaped version.

330−uri :: Parsec [Char] st (String, String)

330+uri :: Parser [Char] st (String, String)

331uri = try $ do

332 let protocols = [ "http:", "https:", "ftp:", "file:", "mailto:",

333 "news:", "telnet:" ]

361-- displacement (the difference between the source column at the end

362-- and the source column at the beginning). Vertical displacement

363-- (source row) is ignored.

364−withHorizDisplacement :: Parsec [Char] st a -- ^ Parser to apply

364+withHorizDisplacement :: Parser [Char] st a -- ^ Parser to apply

365− -> Parsec [Char] st (a, Int) -- ^ (result, displacement)

365+ -> Parser [Char] st (a, Int) -- ^ (result, displacement)

366withHorizDisplacement parser = do

367 pos1 <- getPosition

368 result <- parser

371

372-- | Applies a parser and returns the raw string that was parsed,

373-- along with the value produced by the parser.

374−withRaw :: Parsec [Char] st a -> Parsec [Char] st (a, [Char])

374+withRaw :: Parser [Char] st a -> Parser [Char] st (a, [Char])

375withRaw parser = do

376 pos1 <- getPosition

377 inp <- getInput

388

389-- | Parses a character and returns 'Null' (so that the parser can move on

390-- if it gets stuck).

391−nullBlock :: Parsec [Char] st Block

391+nullBlock :: Parser [Char] st Block

392nullBlock = anyChar >> return Null

393

394-- | Fail unless we're in literate haskell mode.

395−failUnlessLHS :: Parsec [tok] ParserState ()

395+failUnlessLHS :: Parser [tok] ParserState ()

396failUnlessLHS = getOption readerLiterateHaskell >>= guard

397

398-- | Parses backslash, then applies character parser.

399−escaped :: Parsec [Char] st Char -- ^ Parser for character to escape

399+escaped :: Parser [Char] st Char -- ^ Parser for character to escape

400− -> Parsec [Char] st Char

400+ -> Parser [Char] st Char

401escaped parser = try $ char '\\' >> parser

402

403-- | Parse character entity.

404−characterReference :: Parsec [Char] st Char

404+characterReference :: Parser [Char] st Char

405characterReference = try $ do

406 char '&'

407 ent <- many1Till nonspaceChar (char ';')

410 Nothing -> fail "entity not found"

411

412-- | Parses an uppercase roman numeral and returns (UpperRoman, number).

413−upperRoman :: Parsec [Char] st (ListNumberStyle, Int)

413+upperRoman :: Parser [Char] st (ListNumberStyle, Int)

414upperRoman = do

415 num <- romanNumeral True

416 return (UpperRoman, num)

417

418-- | Parses a lowercase roman numeral and returns (LowerRoman, number).

419−lowerRoman :: Parsec [Char] st (ListNumberStyle, Int)

419+lowerRoman :: Parser [Char] st (ListNumberStyle, Int)

420lowerRoman = do

421 num <- romanNumeral False

422 return (LowerRoman, num)

423

424-- | Parses a decimal numeral and returns (Decimal, number).

425−decimal :: Parsec [Char] st (ListNumberStyle, Int)

425+decimal :: Parser [Char] st (ListNumberStyle, Int)

426decimal = do

427 num <- many1 digit

428 return (Decimal, read num)

431-- returns (DefaultStyle, [next example number]). The next

432-- example number is incremented in parser state, and the label

433-- (if present) is added to the label table.

434−exampleNum :: Parsec [Char] ParserState (ListNumberStyle, Int)

434+exampleNum :: Parser [Char] ParserState (ListNumberStyle, Int)

435exampleNum = do

436 char '@'

437 lab <- many (alphaNum <|> satisfy (\c -> c == '_' || c == '-'))

445 return (Example, num)

446

447-- | Parses a '#' returns (DefaultStyle, 1).

448−defaultNum :: Parsec [Char] st (ListNumberStyle, Int)

448+defaultNum :: Parser [Char] st (ListNumberStyle, Int)

449defaultNum = do

450 char '#'

451 return (DefaultStyle, 1)

452

453-- | Parses a lowercase letter and returns (LowerAlpha, number).

454−lowerAlpha :: Parsec [Char] st (ListNumberStyle, Int)

454+lowerAlpha :: Parser [Char] st (ListNumberStyle, Int)

455lowerAlpha = do

456 ch <- oneOf ['a'..'z']

457 return (LowerAlpha, ord ch - ord 'a' + 1)

458

459-- | Parses an uppercase letter and returns (UpperAlpha, number).

460−upperAlpha :: Parsec [Char] st (ListNumberStyle, Int)

460+upperAlpha :: Parser [Char] st (ListNumberStyle, Int)

461upperAlpha = do

462 ch <- oneOf ['A'..'Z']

463 return (UpperAlpha, ord ch - ord 'A' + 1)

464

465-- | Parses a roman numeral i or I

466−romanOne :: Parsec [Char] st (ListNumberStyle, Int)

466+romanOne :: Parser [Char] st (ListNumberStyle, Int)

467romanOne = (char 'i' >> return (LowerRoman, 1)) <|>

468 (char 'I' >> return (UpperRoman, 1))

469

470-- | Parses an ordered list marker and returns list attributes.

471−anyOrderedListMarker :: Parsec [Char] ParserState ListAttributes

471+anyOrderedListMarker :: Parser [Char] ParserState ListAttributes

472anyOrderedListMarker = choice $

473 [delimParser numParser | delimParser <- [inPeriod, inOneParen, inTwoParens],

474 numParser <- [decimal, exampleNum, defaultNum, romanOne,

475 lowerAlpha, lowerRoman, upperAlpha, upperRoman]]

476

477-- | Parses a list number (num) followed by a period, returns list attributes.

478−inPeriod :: Parsec [Char] st (ListNumberStyle, Int)

478+inPeriod :: Parser [Char] st (ListNumberStyle, Int)

479− -> Parsec [Char] st ListAttributes

479+ -> Parser [Char] st ListAttributes

480inPeriod num = try $ do

481 (style, start) <- num

482 char '.'

486 return (start, style, delim)

487

488-- | Parses a list number (num) followed by a paren, returns list attributes.

489−inOneParen :: Parsec [Char] st (ListNumberStyle, Int)

489+inOneParen :: Parser [Char] st (ListNumberStyle, Int)

490− -> Parsec [Char] st ListAttributes

490+ -> Parser [Char] st ListAttributes

491inOneParen num = try $ do

492 (style, start) <- num

493 char ')'

494 return (start, style, OneParen)

495

496-- | Parses a list number (num) enclosed in parens, returns list attributes.

497−inTwoParens :: Parsec [Char] st (ListNumberStyle, Int)

497+inTwoParens :: Parser [Char] st (ListNumberStyle, Int)

498− -> Parsec [Char] st ListAttributes

498+ -> Parser [Char] st ListAttributes

499inTwoParens num = try $ do

500 char '('

501 (style, start) <- num

506-- returns number.

507orderedListMarker :: ListNumberStyle

508 -> ListNumberDelim

509− -> Parsec [Char] ParserState Int

509+ -> Parser [Char] ParserState Int

510orderedListMarker style delim = do

511 let num = defaultNum <|> -- # can continue any kind of list

512 case style of

526 return start

527

528-- | Parses a character reference and returns a Str element.

529−charRef :: Parsec [Char] st Inline

529+charRef :: Parser [Char] st Inline

530charRef = do

531 c <- characterReference

532 return $ Str [c]

533

534-- | Parse a table using 'headerParser', 'rowParser',

535-- 'lineParser', and 'footerParser'.

536−tableWith :: Parsec [Char] ParserState ([[Block]], [Alignment], [Int])

536+tableWith :: Parser [Char] ParserState ([[Block]], [Alignment], [Int])

537− -> ([Int] -> Parsec [Char] ParserState [[Block]])

537+ -> ([Int] -> Parser [Char] ParserState [[Block]])

538− -> Parsec [Char] ParserState sep

538+ -> Parser [Char] ParserState sep

539− -> Parsec [Char] ParserState end

539+ -> Parser [Char] ParserState end

540− -> Parsec [Char] ParserState Block

540+ -> Parser [Char] ParserState Block

541tableWith headerParser rowParser lineParser footerParser = try $ do

542 (heads, aligns, indices) <- headerParser

543 lines' <- rowParser indices `sepEndBy1` lineParser

579-- (which may be grid), then the rows,

580-- which may be grid, separated by blank lines, and

581-- ending with a footer (dashed line followed by blank line).

582−gridTableWith :: Parsec [Char] ParserState Block -- ^ Block parser

582+gridTableWith :: Parser [Char] ParserState Block -- ^ Block parser

583 -> Bool -- ^ Headerless table

584− -> Parsec [Char] ParserState Block

584+ -> Parser [Char] ParserState Block

585gridTableWith block headless =

586 tableWith (gridTableHeader headless block) (gridTableRow block) (gridTableSep '-') gridTableFooter

587

589gridTableSplitLine indices line = map removeFinalBar $ tail $

590 splitStringByIndices (init indices) $ removeTrailingSpace line

591

592−gridPart :: Char -> Parsec [Char] st (Int, Int)

592+gridPart :: Char -> Parser [Char] st (Int, Int)

593gridPart ch = do

594 dashes <- many1 (char ch)

595 char '+'

596 return (length dashes, length dashes + 1)

597

598−gridDashedLines :: Char -> Parsec [Char] st [(Int,Int)]

598+gridDashedLines :: Char -> Parser [Char] st [(Int,Int)]

599gridDashedLines ch = try $ char '+' >> many1 (gridPart ch) >>~ blankline

600

601removeFinalBar :: String -> String

603 reverse . dropWhile (`elem` " \t") . dropWhile (=='|') . reverse

604

605-- | Separator between rows of grid table.

606−gridTableSep :: Char -> Parsec [Char] ParserState Char

606+gridTableSep :: Char -> Parser [Char] ParserState Char

607gridTableSep ch = try $ gridDashedLines ch >> return '\n'

608

609-- | Parse header for a grid table.

610gridTableHeader :: Bool -- ^ Headerless table

611− -> Parsec [Char] ParserState Block

611+ -> Parser [Char] ParserState Block

612− -> Parsec [Char] ParserState ([[Block]], [Alignment], [Int])

612+ -> Parser [Char] ParserState ([[Block]], [Alignment], [Int])

613gridTableHeader headless block = try $ do

614 optional blanklines

615 dashes <- gridDashedLines '-'

633 map removeLeadingTrailingSpace rawHeads

634 return (heads, aligns, indices)

635

636−gridTableRawLine :: [Int] -> Parsec [Char] ParserState [String]

636+gridTableRawLine :: [Int] -> Parser [Char] ParserState [String]

637gridTableRawLine indices = do

638 char '|'

639 line <- many1Till anyChar newline

640 return (gridTableSplitLine indices line)

641

642-- | Parse row of grid table.

643−gridTableRow :: Parsec [Char] ParserState Block

643+gridTableRow :: Parser [Char] ParserState Block

644 -> [Int]

645− -> Parsec [Char] ParserState [[Block]]

645+ -> Parser [Char] ParserState [[Block]]

646gridTableRow block indices = do

647 colLines <- many1 (gridTableRawLine indices)

648 let cols = map ((++ "\n") . unlines . removeOneLeadingSpace) $

661compactifyCell bs = head $ compactify [bs]

662

663-- | Parse footer for a grid table.

664−gridTableFooter :: Parsec [Char] ParserState [Char]

664+gridTableFooter :: Parser [Char] ParserState [Char]

665gridTableFooter = blanklines

666

667---

668

669-- | Parse a string with a given parser and state.

670−readWith :: Parsec [t] ParserState a -- ^ parser

670+readWith :: Parser [t] ParserState a -- ^ parser

671 -> ParserState -- ^ initial state

672 -> [t] -- ^ input

673 -> a

677 Right result -> result

678

679-- | Parse a string with @parser@ (for testing).

680−testStringWith :: (Show a) => Parsec [Char] ParserState a

680+testStringWith :: (Show a) => Parser [Char] ParserState a

681 -> String

682 -> IO ()

683testStringWith parser str = UTF8.putStrLn $ show $

781 Just src -> Just src

782

783-- | Fail unless we're in "smart typography" mode.

784−failUnlessSmart :: Parsec [tok] ParserState ()

784+failUnlessSmart :: Parser [tok] ParserState ()

785failUnlessSmart = getOption readerSmart >>= guard

786

787−smartPunctuation :: Parsec [Char] ParserState Inline

787+smartPunctuation :: Parser [Char] ParserState Inline

788− -> Parsec [Char] ParserState Inline

788+ -> Parser [Char] ParserState Inline

789smartPunctuation inlineParser = do

790 failUnlessSmart

791 choice [ quoted inlineParser, apostrophe, dash, ellipses ]

792

793−apostrophe :: Parsec [Char] ParserState Inline

793+apostrophe :: Parser [Char] ParserState Inline

794apostrophe = (char '\'' <|> char '\8217') >> return (Str "\x2019")

795

796−quoted :: Parsec [Char] ParserState Inline

796+quoted :: Parser [Char] ParserState Inline

797− -> Parsec [Char] ParserState Inline

797+ -> Parser [Char] ParserState Inline

798quoted inlineParser = doubleQuoted inlineParser <|> singleQuoted inlineParser

799

800withQuoteContext :: QuoteContext

801− -> (Parsec [Char] ParserState Inline)

801+ -> (Parser [Char] ParserState Inline)

802− -> Parsec [Char] ParserState Inline

802+ -> Parser [Char] ParserState Inline

803withQuoteContext context parser = do

804 oldState <- getState

805 let oldQuoteContext = stateQuoteContext oldState

809 setState newState { stateQuoteContext = oldQuoteContext }

810 return result

811

812−singleQuoted :: Parsec [Char] ParserState Inline

812+singleQuoted :: Parser [Char] ParserState Inline

813− -> Parsec [Char] ParserState Inline

813+ -> Parser [Char] ParserState Inline

814singleQuoted inlineParser = try $ do

815 singleQuoteStart

816 withQuoteContext InSingleQuote $ many1Till inlineParser singleQuoteEnd >>=

817 return . Quoted SingleQuote . normalizeSpaces

818

819−doubleQuoted :: Parsec [Char] ParserState Inline

819+doubleQuoted :: Parser [Char] ParserState Inline

820− -> Parsec [Char] ParserState Inline

820+ -> Parser [Char] ParserState Inline

821doubleQuoted inlineParser = try $ do

822 doubleQuoteStart

823 withQuoteContext InDoubleQuote $ do

824 contents <- manyTill inlineParser doubleQuoteEnd

825 return . Quoted DoubleQuote . normalizeSpaces $ contents

826

827−failIfInQuoteContext :: QuoteContext -> Parsec [tok] ParserState ()

827+failIfInQuoteContext :: QuoteContext -> Parser [tok] ParserState ()

828failIfInQuoteContext context = do

829 st <- getState

830 if stateQuoteContext st == context

831 then fail "already inside quotes"

832 else return ()

833

834−charOrRef :: [Char] -> Parsec [Char] st Char

834+charOrRef :: [Char] -> Parser [Char] st Char

835charOrRef cs =

836 oneOf cs <|> try (do c <- characterReference

837 guard (c `elem` cs)

838 return c)

839

840−updateLastStrPos :: Parsec [Char] ParserState ()

840+updateLastStrPos :: Parser [Char] ParserState ()

841updateLastStrPos = getPosition >>= \p ->

842 updateState $ \s -> s{ stateLastStrPos = Just p }

843

844−singleQuoteStart :: Parsec [Char] ParserState ()

844+singleQuoteStart :: Parser [Char] ParserState ()

845singleQuoteStart = do

846 failIfInQuoteContext InSingleQuote

847 pos <- getPosition

856 -- possess/contraction

857 return ()

858

859−singleQuoteEnd :: Parsec [Char] st ()

859+singleQuoteEnd :: Parser [Char] st ()

860singleQuoteEnd = try $ do

861 charOrRef "'\8217\146"

862 notFollowedBy alphaNum

863

864−doubleQuoteStart :: Parsec [Char] ParserState ()

864+doubleQuoteStart :: Parser [Char] ParserState ()

865doubleQuoteStart = do

866 failIfInQuoteContext InDoubleQuote

867 try $ do charOrRef "\"\8220\147"

868 notFollowedBy (satisfy (\c -> c == ' ' || c == '\t' || c == '\n'))

869

870−doubleQuoteEnd :: Parsec [Char] st ()

870+doubleQuoteEnd :: Parser [Char] st ()

871doubleQuoteEnd = do

872 charOrRef "\"\8221\148"

873 return ()

874

875−ellipses :: Parsec [Char] st Inline

875+ellipses :: Parser [Char] st Inline

876ellipses = do

877 try (charOrRef "\8230\133") <|> try (string "..." >> return '…')

878 return (Str "\8230")

879

880−dash :: Parsec [Char] ParserState Inline

880+dash :: Parser [Char] ParserState Inline

881dash = do

882 oldDashes <- getOption readerOldDashes

883 if oldDashes

885 else Str `fmap` (hyphenDash <|> emDash <|> enDash)

886

887-- Two hyphens = en-dash, three = em-dash

888−hyphenDash :: Parsec [Char] st String

888+hyphenDash :: Parser [Char] st String

889hyphenDash = do

890 try $ string "--"

891 option "\8211" (char '-' >> return "\8212")

892

893−emDash :: Parsec [Char] st String

893+emDash :: Parser [Char] st String

894emDash = do

895 try (charOrRef "\8212\151")

896 return "\8212"

897

898−enDash :: Parsec [Char] st String

898+enDash :: Parser [Char] st String

899enDash = do

900 try (charOrRef "\8212\151")

901 return "\8211"

902

903−enDashOld :: Parsec [Char] st Inline

903+enDashOld :: Parser [Char] st Inline

904enDashOld = do

905 try (charOrRef "\8211\150") <|>

906 try (char '-' >> lookAhead (satisfy isDigit) >> return '–')

907 return (Str "\8211")

908

909−emDashOld :: Parsec [Char] st Inline

909+emDashOld :: Parser [Char] st Inline

910emDashOld = do

911 try (charOrRef "\8212\151") <|> (try $ string "--" >> optional (char '-') >> return '-')

912 return (Str "\8212")

916--

917

918-- | Parse a \newcommand or \renewcommand macro definition.

919−macro :: Parsec [Char] ParserState Block

919+macro :: Parser [Char] ParserState Block

920macro = do

921 apply <- getOption readerApplyMacros

922 inp <- getInput

931 else return $ RawBlock "latex" def'

932

933-- | Apply current macros to string.

934−applyMacros' :: String -> Parsec [Char] ParserState String

934+applyMacros' :: String -> Parser [Char] ParserState String

935applyMacros' target = do

936 apply <- getOption readerApplyMacros

937 if apply

939 return $ applyMacros macros target

940 else return target

941

942+---- pandoc2 block sep/line end parsers

943+{-

944+

945+-- | Push parser onto stack of endline parsers.

946+-- These are applied after a newline within a block.

947+pushEndline :: PMonad m => P t m () -> P t m ()

948+pushEndline p = modifyState $ \st -> st{ sEndline = sEndline st |> p }

949+

950+-- | Pop parser off stack of endline parsers.

951+popEndline :: PMonad m => P t m ()

952+popEndline = do

953+ st <- getState

954+ case viewr (sEndline st) of

955+ EmptyR -> logM ERROR "Tried to pop empty pEndline stack"

956+ ps :> _ -> setState st{ sEndline = ps }

957+

958+-- | Apply a parser in a context with a specified endline parser.

959+withEndline :: PMonad m => P t m a -> P t m b -> P t m b

960+withEndline sep p = pushEndline (() <$ sep) *> p <* popEndline

961+

962+-- | Push parser onto stack of block separator parsers.

963+-- These are applied after a newline following a block.

964+pushBlockSep :: PMonad m => P t m () -> P t m ()

965+pushBlockSep p = modifyState $ \st -> st{ sBlockSep = sBlockSep st |> p }

966+

967+-- | Pop parser off of stack of block separator parsers.

968+popBlockSep :: PMonad m => P t m ()

969+popBlockSep = do

970+ st <- getState

971+ case viewr (sBlockSep st) of

972+ EmptyR -> logM ERROR "Tried to pop empty pBlockSep stack"

973+ ps :> _ -> setState st{ sBlockSep = ps }

974+

975+-- | Apply a parser in a context with specified block separator parser.

976+withBlockSep :: PMonad m => P t m a -> P t m b -> P t m b

977+withBlockSep sep p = pushBlockSep (() <$ sep) *> p <* popBlockSep

978+

979+-- | Parse a block separator.

980+pBlockSep :: PMonad m => P t m ()

981+pBlockSep = try (getState >>= sequenceA . sBlockSep) >> return ()

982+-}