1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
module Language.Haskell.Lexer.Utils
( module Language.Haskell.Lexer.Utils
, Token(..)
) where
import Language.Haskell.Lexer.Tokens
gotEOF :: [a] -> [(Token,[a])]
gotEOF [] = []
gotEOF as = [(GotEOF, reverse as)]
gotError :: [a] -> [a] -> [(Token, [a])]
gotError as is =
(ErrorToken, reverse as):
if null is then [(GotEOF,[])] else [(TheRest,is{-reverse (take 80 is)-})]
-- Inlining the call to output does not make a big difference.
--output token as cont = (token, reverse as):cont
-- Not reversing the token string seems to save about 10% of the time with HBC.
-- The difference in speed seems insignificant with ghc-6.0.1 -O.
output :: t -> [a] -> [(t, [a])] -> [(t, [a])]
output token as cont = (token,reverse as):cont
-- This avoids constructing a closure for the call to reverse.
-- This saves about 10% too.
{-
output token as cont =
rev as []
where
rev [] as' = (token,as'):cont
rev (a:as) as' = rev as (a:as')
--}
nestedComment :: [Char] -> [Char] -> (([a] -> [a] -> [(Token, [a])])
-> [Char] -> [Char] -> [(Token, [Char])]) -> [(Token, [Char])]
nestedComment as' is' next = nest (0::Int) as' is'
where
nest n as is =
case is of
'-' : '}' : is1 -> if n == 0
then next gotError ('}':'-':as) is1
else nest (n-1) ('}':'-':as) is1
'{' : '-' : is1 -> nest (n+1) ('-':'{':as) is1
c : is1 -> nest n (c:as) is1
[] -> gotError as is -- EOF inside comment
|
