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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
-- -----------------------------------------------------------------------------
-- ALEX TEMPLATE
--
-- This code is in the PUBLIC DOMAIN; you may copy it freely and use
-- it for any purpose whatsoever.
-- -----------------------------------------------------------------------------
-- INTERNALS and main scanner engine
#ifdef ALEX_GHC
# define ILIT(n) n#
# define IBOX(n) (I# (n))
# define FAST_INT Int#
-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
# if __GLASGOW_HASKELL__ > 706
# define CMP_GEQ(n,m) (((n) >=# (m)) :: Int#)
# define CMP_EQ(n,m) (((n) ==# (m)) :: Int#)
# define CMP_MKBOOL(x) ((GHC.Exts.tagToEnum# (x)) :: Bool)
# else
# define CMP_GEQ(n,m) (((n) >= (m)) :: Bool)
# define CMP_EQ(n,m) (((n) == (m)) :: Bool)
# define CMP_MKBOOL(x) ((x) :: Bool)
# endif
# define GTE(n,m) CMP_MKBOOL(CMP_GEQ(n,m))
# define EQ(n,m) CMP_MKBOOL(CMP_EQ(n,m))
# define PLUS(n,m) (n +# m)
# define MINUS(n,m) (n -# m)
# define TIMES(n,m) (n *# m)
# define NEGATE(n) (negateInt# (n))
# define IF_GHC(x) (x)
#else
# define ILIT(n) (n)
# define IBOX(n) (n)
# define FAST_INT Int
# define GTE(n,m) (n >= m)
# define EQ(n,m) (n == m)
# define PLUS(n,m) (n + m)
# define MINUS(n,m) (n - m)
# define TIMES(n,m) (n * m)
# define NEGATE(n) (negate (n))
# define IF_GHC(x)
#endif
#ifdef ALEX_GHC
data AlexAddr = AlexA# Addr#
-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
{-# INLINE alexIndexInt16OffAddr #-}
alexIndexInt16OffAddr :: AlexAddr -> Int# -> Int#
alexIndexInt16OffAddr (AlexA# arr) off =
#if __GLASGOW_HASKELL__ >= 901
GHC.Exts.int16ToInt# -- qualified import because it doesn't exist on older GHC's
#endif
#ifdef WORDS_BIGENDIAN
(GHC.Exts.word16ToInt16# (GHC.Exts.wordToWord16# (GHC.Exts.byteSwap16# (GHC.Exts.word16ToWord# (GHC.Exts.int16ToWord16#
#endif
(indexInt16OffAddr# arr off)
#ifdef WORDS_BIGENDIAN
)))))
#endif
#else
alexIndexInt16OffAddr = (Data.Array.!)
#endif
#ifdef ALEX_GHC
{-# INLINE alexIndexInt32OffAddr #-}
alexIndexInt32OffAddr :: AlexAddr -> Int# -> Int#
alexIndexInt32OffAddr (AlexA# arr) off =
#if __GLASGOW_HASKELL__ >= 901
GHC.Exts.int32ToInt# -- qualified import because it doesn't exist on older GHC's
#endif
#ifdef WORDS_BIGENDIAN
(GHC.Exts.word32ToInt32# (GHC.Exts.wordToWord32# (GHC.Exts.byteSwap32# (GHC.Exts.word32ToWord# (GHC.Exts.int32ToWord32#
#endif
(indexInt32OffAddr# arr off)
#ifdef WORDS_BIGENDIAN
)))))
#endif
#else
alexIndexInt32OffAddr = (Data.Array.!)
#endif
#ifdef ALEX_GHC
-- GHC >= 503, unsafeAt is available from Data.Array.Base.
quickIndex = unsafeAt
#else
quickIndex = (Data.Array.!)
#endif
-- -----------------------------------------------------------------------------
-- Main lexing routines
data AlexReturn a
= AlexEOF
| AlexError !AlexInput
| AlexSkip !AlexInput !Int
| AlexToken !AlexInput !Int a
-- alexScan :: AlexInput -> StartCode -> AlexReturn a
alexScan input__ IBOX(sc)
= alexScanUser (error "alex rule requiring context was invoked by alexScan; use alexScanUser instead?") input__ IBOX(sc)
-- If the generated alexScan/alexScanUser functions are called multiple times
-- in the same file, alexScanUser gets broken out into a separate function and
-- increases memory usage. Make sure GHC inlines this function and optimizes it.
{-# INLINE alexScanUser #-}
alexScanUser user__ input__ IBOX(sc)
= case alex_scan_tkn user__ input__ ILIT(0) input__ sc AlexNone of
(AlexNone, input__') ->
case alexGetByte input__ of
Nothing ->
#ifdef ALEX_DEBUG
Debug.Trace.trace ("End of input.") $
#endif
AlexEOF
Just _ ->
#ifdef ALEX_DEBUG
Debug.Trace.trace ("Error.") $
#endif
AlexError input__'
(AlexLastSkip input__'' len, _) ->
#ifdef ALEX_DEBUG
Debug.Trace.trace ("Skipping.") $
#endif
AlexSkip input__'' len
(AlexLastAcc k input__''' len, _) ->
#ifdef ALEX_DEBUG
Debug.Trace.trace ("Accept.") $
#endif
AlexToken input__''' len ((Data.Array.!) alex_actions k)
-- Push the input through the DFA, remembering the most recent accepting
-- state it encountered.
alex_scan_tkn user__ orig_input len input__ s last_acc =
input__ `seq` -- strict in the input
let
new_acc = (check_accs (alex_accept `quickIndex` IBOX(s)))
in
new_acc `seq`
case alexGetByte input__ of
Nothing -> (new_acc, input__)
Just (c, new_input) ->
#ifdef ALEX_DEBUG
Debug.Trace.trace ("State: " ++ show IBOX(s) ++ ", char: " ++ show c ++ " " ++ (show . Data.Char.chr . fromIntegral) c) $
#endif
case fromIntegral c of { IBOX(ord_c) ->
let
base = alexIndexInt32OffAddr alex_base s
offset = PLUS(base,ord_c)
new_s = if GTE(offset,ILIT(0))
&& let check = alexIndexInt16OffAddr alex_check offset
in EQ(check,ord_c)
then alexIndexInt16OffAddr alex_table offset
else alexIndexInt16OffAddr alex_deflt s
in
case new_s of
ILIT(-1) -> (new_acc, input__)
-- on an error, we want to keep the input *before* the
-- character that failed, not after.
_ -> alex_scan_tkn user__ orig_input
#ifdef ALEX_LATIN1
PLUS(len,ILIT(1))
-- issue 119: in the latin1 encoding, *each* byte is one character
#else
(if c < 0x80 || c >= 0xC0 then PLUS(len,ILIT(1)) else len)
-- note that the length is increased ONLY if this is the 1st byte in a char encoding)
#endif
new_input new_s new_acc
}
where
check_accs (AlexAccNone) = last_acc
check_accs (AlexAcc a ) = AlexLastAcc a input__ IBOX(len)
check_accs (AlexAccSkip) = AlexLastSkip input__ IBOX(len)
#ifndef ALEX_NOPRED
check_accs (AlexAccPred a predx rest)
| predx user__ orig_input IBOX(len) input__
= AlexLastAcc a input__ IBOX(len)
| otherwise
= check_accs rest
check_accs (AlexAccSkipPred predx rest)
| predx user__ orig_input IBOX(len) input__
= AlexLastSkip input__ IBOX(len)
| otherwise
= check_accs rest
#endif
data AlexLastAcc
= AlexNone
| AlexLastAcc !Int !AlexInput !Int
| AlexLastSkip !AlexInput !Int
data AlexAcc user
= AlexAccNone
| AlexAcc Int
| AlexAccSkip
#ifndef ALEX_NOPRED
| AlexAccPred Int (AlexAccPred user) (AlexAcc user)
| AlexAccSkipPred (AlexAccPred user) (AlexAcc user)
type AlexAccPred user = user -> AlexInput -> Int -> AlexInput -> Bool
-- -----------------------------------------------------------------------------
-- Predicates on a rule
alexAndPred p1 p2 user__ in1 len in2
= p1 user__ in1 len in2 && p2 user__ in1 len in2
--alexPrevCharIsPred :: Char -> AlexAccPred _
alexPrevCharIs c _ input__ _ _ = c == alexInputPrevChar input__
alexPrevCharMatches f _ input__ _ _ = f (alexInputPrevChar input__)
--alexPrevCharIsOneOfPred :: Array Char Bool -> AlexAccPred _
alexPrevCharIsOneOf arr _ input__ _ _ = arr Data.Array.! alexInputPrevChar input__
--alexRightContext :: Int -> AlexAccPred _
alexRightContext IBOX(sc) user__ _ _ input__ =
case alex_scan_tkn user__ input__ ILIT(0) input__ sc AlexNone of
(AlexNone, _) -> False
_ -> True
-- TODO: there's no need to find the longest
-- match when checking the right context, just
-- the first match will do.
#endif
|
