|
7267
|
1 # -----------------------------------------------------------------------------
|
|
|
2 # ply: lex.py
|
|
|
3 #
|
|
|
4 # Copyright (C) 2001-2015,
|
|
|
5 # David M. Beazley (Dabeaz LLC)
|
|
|
6 # All rights reserved.
|
|
|
7 #
|
|
|
8 # Redistribution and use in source and binary forms, with or without
|
|
|
9 # modification, are permitted provided that the following conditions are
|
|
|
10 # met:
|
|
|
11 #
|
|
|
12 # * Redistributions of source code must retain the above copyright notice,
|
|
|
13 # this list of conditions and the following disclaimer.
|
|
|
14 # * Redistributions in binary form must reproduce the above copyright notice,
|
|
|
15 # this list of conditions and the following disclaimer in the documentation
|
|
|
16 # and/or other materials provided with the distribution.
|
|
|
17 # * Neither the name of the David Beazley or Dabeaz LLC may be used to
|
|
|
18 # endorse or promote products derived from this software without
|
|
|
19 # specific prior written permission.
|
|
|
20 #
|
|
|
21 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
22 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
23 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
24 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
25 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
26 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
27 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
28 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
29 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
30 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
31 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
32 # -----------------------------------------------------------------------------
|
|
|
33
|
|
|
34 __version__ = '3.8'
|
|
|
35 __tabversion__ = '3.8'
|
|
|
36
|
|
|
37 import re
|
|
|
38 import sys
|
|
|
39 import types
|
|
|
40 import copy
|
|
|
41 import os
|
|
|
42 import inspect
|
|
|
43
|
|
|
44 # This tuple contains known string types
|
|
|
45 try:
|
|
|
46 # Python 2.6
|
|
|
47 StringTypes = (types.StringType, types.UnicodeType)
|
|
|
48 except AttributeError:
|
|
|
49 # Python 3.0
|
|
|
50 StringTypes = (str, bytes)
|
|
|
51
|
|
|
52 # This regular expression is used to match valid token names
|
|
|
53 _is_identifier = re.compile(r'^[a-zA-Z0-9_]+$')
|
|
|
54
|
|
|
55 # Exception thrown when invalid token encountered and no default error
|
|
|
56 # handler is defined.
|
|
|
57 class LexError(Exception):
|
|
|
58 def __init__(self, message, s):
|
|
|
59 self.args = (message,)
|
|
|
60 self.text = s
|
|
|
61
|
|
|
62
|
|
|
63 # Token class. This class is used to represent the tokens produced.
|
|
|
64 class LexToken(object):
|
|
|
65 def __str__(self):
|
|
|
66 return 'LexToken(%s,%r,%d,%d)' % (self.type, self.value, self.lineno, self.lexpos)
|
|
|
67
|
|
|
68 def __repr__(self):
|
|
|
69 return str(self)
|
|
|
70
|
|
|
71
|
|
|
72 # This object is a stand-in for a logging object created by the
|
|
|
73 # logging module.
|
|
|
74
|
|
|
75 class PlyLogger(object):
|
|
|
76 def __init__(self, f):
|
|
|
77 self.f = f
|
|
|
78
|
|
|
79 def critical(self, msg, *args, **kwargs):
|
|
|
80 self.f.write((msg % args) + '\n')
|
|
|
81
|
|
|
82 def warning(self, msg, *args, **kwargs):
|
|
|
83 self.f.write('WARNING: ' + (msg % args) + '\n')
|
|
|
84
|
|
|
85 def error(self, msg, *args, **kwargs):
|
|
|
86 self.f.write('ERROR: ' + (msg % args) + '\n')
|
|
|
87
|
|
|
88 info = critical
|
|
|
89 debug = critical
|
|
|
90
|
|
|
91
|
|
|
92 # Null logger is used when no output is generated. Does nothing.
|
|
|
93 class NullLogger(object):
|
|
|
94 def __getattribute__(self, name):
|
|
|
95 return self
|
|
|
96
|
|
|
97 def __call__(self, *args, **kwargs):
|
|
|
98 return self
|
|
|
99
|
|
|
100
|
|
|
101 # -----------------------------------------------------------------------------
|
|
|
102 # === Lexing Engine ===
|
|
|
103 #
|
|
|
104 # The following Lexer class implements the lexer runtime. There are only
|
|
|
105 # a few public methods and attributes:
|
|
|
106 #
|
|
|
107 # input() - Store a new string in the lexer
|
|
|
108 # token() - Get the next token
|
|
|
109 # clone() - Clone the lexer
|
|
|
110 #
|
|
|
111 # lineno - Current line number
|
|
|
112 # lexpos - Current position in the input string
|
|
|
113 # -----------------------------------------------------------------------------
|
|
|
114
|
|
|
115 class Lexer:
|
|
|
116 def __init__(self):
|
|
|
117 self.lexre = None # Master regular expression. This is a list of
|
|
|
118 # tuples (re, findex) where re is a compiled
|
|
|
119 # regular expression and findex is a list
|
|
|
120 # mapping regex group numbers to rules
|
|
|
121 self.lexretext = None # Current regular expression strings
|
|
|
122 self.lexstatere = {} # Dictionary mapping lexer states to master regexs
|
|
|
123 self.lexstateretext = {} # Dictionary mapping lexer states to regex strings
|
|
|
124 self.lexstaterenames = {} # Dictionary mapping lexer states to symbol names
|
|
|
125 self.lexstate = 'INITIAL' # Current lexer state
|
|
|
126 self.lexstatestack = [] # Stack of lexer states
|
|
|
127 self.lexstateinfo = None # State information
|
|
|
128 self.lexstateignore = {} # Dictionary of ignored characters for each state
|
|
|
129 self.lexstateerrorf = {} # Dictionary of error functions for each state
|
|
|
130 self.lexstateeoff = {} # Dictionary of eof functions for each state
|
|
|
131 self.lexreflags = 0 # Optional re compile flags
|
|
|
132 self.lexdata = None # Actual input data (as a string)
|
|
|
133 self.lexpos = 0 # Current position in input text
|
|
|
134 self.lexlen = 0 # Length of the input text
|
|
|
135 self.lexerrorf = None # Error rule (if any)
|
|
|
136 self.lexeoff = None # EOF rule (if any)
|
|
|
137 self.lextokens = None # List of valid tokens
|
|
|
138 self.lexignore = '' # Ignored characters
|
|
|
139 self.lexliterals = '' # Literal characters that can be passed through
|
|
|
140 self.lexmodule = None # Module
|
|
|
141 self.lineno = 1 # Current line number
|
|
|
142 self.lexoptimize = False # Optimized mode
|
|
|
143
|
|
|
144 def clone(self, object=None):
|
|
|
145 c = copy.copy(self)
|
|
|
146
|
|
|
147 # If the object parameter has been supplied, it means we are attaching the
|
|
|
148 # lexer to a new object. In this case, we have to rebind all methods in
|
|
|
149 # the lexstatere and lexstateerrorf tables.
|
|
|
150
|
|
|
151 if object:
|
|
|
152 newtab = {}
|
|
|
153 for key, ritem in self.lexstatere.items():
|
|
|
154 newre = []
|
|
|
155 for cre, findex in ritem:
|
|
|
156 newfindex = []
|
|
|
157 for f in findex:
|
|
|
158 if not f or not f[0]:
|
|
|
159 newfindex.append(f)
|
|
|
160 continue
|
|
|
161 newfindex.append((getattr(object, f[0].__name__), f[1]))
|
|
|
162 newre.append((cre, newfindex))
|
|
|
163 newtab[key] = newre
|
|
|
164 c.lexstatere = newtab
|
|
|
165 c.lexstateerrorf = {}
|
|
|
166 for key, ef in self.lexstateerrorf.items():
|
|
|
167 c.lexstateerrorf[key] = getattr(object, ef.__name__)
|
|
|
168 c.lexmodule = object
|
|
|
169 return c
|
|
|
170
|
|
|
171 # ------------------------------------------------------------
|
|
|
172 # writetab() - Write lexer information to a table file
|
|
|
173 # ------------------------------------------------------------
|
|
|
174 def writetab(self, lextab, outputdir=''):
|
|
|
175 if isinstance(lextab, types.ModuleType):
|
|
|
176 raise IOError("Won't overwrite existing lextab module")
|
|
|
177 basetabmodule = lextab.split('.')[-1]
|
|
|
178 filename = os.path.join(outputdir, basetabmodule) + '.py'
|
|
|
179 with open(filename, 'w') as tf:
|
|
|
180 tf.write('# %s.py. This file automatically created by PLY (version %s). Don\'t edit!\n' % (basetabmodule, __version__))
|
|
|
181 tf.write('_tabversion = %s\n' % repr(__tabversion__))
|
|
|
182 tf.write('_lextokens = %s\n' % repr(self.lextokens))
|
|
|
183 tf.write('_lexreflags = %s\n' % repr(self.lexreflags))
|
|
|
184 tf.write('_lexliterals = %s\n' % repr(self.lexliterals))
|
|
|
185 tf.write('_lexstateinfo = %s\n' % repr(self.lexstateinfo))
|
|
|
186
|
|
|
187 # Rewrite the lexstatere table, replacing function objects with function names
|
|
|
188 tabre = {}
|
|
|
189 for statename, lre in self.lexstatere.items():
|
|
|
190 titem = []
|
|
|
191 for (pat, func), retext, renames in zip(lre, self.lexstateretext[statename], self.lexstaterenames[statename]):
|
|
|
192 titem.append((retext, _funcs_to_names(func, renames)))
|
|
|
193 tabre[statename] = titem
|
|
|
194
|
|
|
195 tf.write('_lexstatere = %s\n' % repr(tabre))
|
|
|
196 tf.write('_lexstateignore = %s\n' % repr(self.lexstateignore))
|
|
|
197
|
|
|
198 taberr = {}
|
|
|
199 for statename, ef in self.lexstateerrorf.items():
|
|
|
200 taberr[statename] = ef.__name__ if ef else None
|
|
|
201 tf.write('_lexstateerrorf = %s\n' % repr(taberr))
|
|
|
202
|
|
|
203 tabeof = {}
|
|
|
204 for statename, ef in self.lexstateeoff.items():
|
|
|
205 tabeof[statename] = ef.__name__ if ef else None
|
|
|
206 tf.write('_lexstateeoff = %s\n' % repr(tabeof))
|
|
|
207
|
|
|
208 # ------------------------------------------------------------
|
|
|
209 # readtab() - Read lexer information from a tab file
|
|
|
210 # ------------------------------------------------------------
|
|
|
211 def readtab(self, tabfile, fdict):
|
|
|
212 if isinstance(tabfile, types.ModuleType):
|
|
|
213 lextab = tabfile
|
|
|
214 else:
|
|
|
215 exec('import %s' % tabfile)
|
|
|
216 lextab = sys.modules[tabfile]
|
|
|
217
|
|
|
218 if getattr(lextab, '_tabversion', '0.0') != __tabversion__:
|
|
|
219 raise ImportError('Inconsistent PLY version')
|
|
|
220
|
|
|
221 self.lextokens = lextab._lextokens
|
|
|
222 self.lexreflags = lextab._lexreflags
|
|
|
223 self.lexliterals = lextab._lexliterals
|
|
|
224 self.lextokens_all = self.lextokens | set(self.lexliterals)
|
|
|
225 self.lexstateinfo = lextab._lexstateinfo
|
|
|
226 self.lexstateignore = lextab._lexstateignore
|
|
|
227 self.lexstatere = {}
|
|
|
228 self.lexstateretext = {}
|
|
|
229 for statename, lre in lextab._lexstatere.items():
|
|
|
230 titem = []
|
|
|
231 txtitem = []
|
|
|
232 for pat, func_name in lre:
|
|
|
233 titem.append((re.compile(pat, lextab._lexreflags | re.VERBOSE), _names_to_funcs(func_name, fdict)))
|
|
|
234
|
|
|
235 self.lexstatere[statename] = titem
|
|
|
236 self.lexstateretext[statename] = txtitem
|
|
|
237
|
|
|
238 self.lexstateerrorf = {}
|
|
|
239 for statename, ef in lextab._lexstateerrorf.items():
|
|
|
240 self.lexstateerrorf[statename] = fdict[ef]
|
|
|
241
|
|
|
242 self.lexstateeoff = {}
|
|
|
243 for statename, ef in lextab._lexstateeoff.items():
|
|
|
244 self.lexstateeoff[statename] = fdict[ef]
|
|
|
245
|
|
|
246 self.begin('INITIAL')
|
|
|
247
|
|
|
248 # ------------------------------------------------------------
|
|
|
249 # input() - Push a new string into the lexer
|
|
|
250 # ------------------------------------------------------------
|
|
|
251 def input(self, s):
|
|
|
252 # Pull off the first character to see if s looks like a string
|
|
|
253 c = s[:1]
|
|
|
254 if not isinstance(c, StringTypes):
|
|
|
255 raise ValueError('Expected a string')
|
|
|
256 self.lexdata = s
|
|
|
257 self.lexpos = 0
|
|
|
258 self.lexlen = len(s)
|
|
|
259
|
|
|
260 # ------------------------------------------------------------
|
|
|
261 # begin() - Changes the lexing state
|
|
|
262 # ------------------------------------------------------------
|
|
|
263 def begin(self, state):
|
|
|
264 if state not in self.lexstatere:
|
|
|
265 raise ValueError('Undefined state')
|
|
|
266 self.lexre = self.lexstatere[state]
|
|
|
267 self.lexretext = self.lexstateretext[state]
|
|
|
268 self.lexignore = self.lexstateignore.get(state, '')
|
|
|
269 self.lexerrorf = self.lexstateerrorf.get(state, None)
|
|
|
270 self.lexeoff = self.lexstateeoff.get(state, None)
|
|
|
271 self.lexstate = state
|
|
|
272
|
|
|
273 # ------------------------------------------------------------
|
|
|
274 # push_state() - Changes the lexing state and saves old on stack
|
|
|
275 # ------------------------------------------------------------
|
|
|
276 def push_state(self, state):
|
|
|
277 self.lexstatestack.append(self.lexstate)
|
|
|
278 self.begin(state)
|
|
|
279
|
|
|
280 # ------------------------------------------------------------
|
|
|
281 # pop_state() - Restores the previous state
|
|
|
282 # ------------------------------------------------------------
|
|
|
283 def pop_state(self):
|
|
|
284 self.begin(self.lexstatestack.pop())
|
|
|
285
|
|
|
286 # ------------------------------------------------------------
|
|
|
287 # current_state() - Returns the current lexing state
|
|
|
288 # ------------------------------------------------------------
|
|
|
289 def current_state(self):
|
|
|
290 return self.lexstate
|
|
|
291
|
|
|
292 # ------------------------------------------------------------
|
|
|
293 # skip() - Skip ahead n characters
|
|
|
294 # ------------------------------------------------------------
|
|
|
295 def skip(self, n):
|
|
|
296 self.lexpos += n
|
|
|
297
|
|
|
298 # ------------------------------------------------------------
|
|
|
299 # opttoken() - Return the next token from the Lexer
|
|
|
300 #
|
|
|
301 # Note: This function has been carefully implemented to be as fast
|
|
|
302 # as possible. Don't make changes unless you really know what
|
|
|
303 # you are doing
|
|
|
304 # ------------------------------------------------------------
|
|
|
305 def token(self):
|
|
|
306 # Make local copies of frequently referenced attributes
|
|
|
307 lexpos = self.lexpos
|
|
|
308 lexlen = self.lexlen
|
|
|
309 lexignore = self.lexignore
|
|
|
310 lexdata = self.lexdata
|
|
|
311
|
|
|
312 while lexpos < lexlen:
|
|
|
313 # This code provides some short-circuit code for whitespace, tabs, and other ignored characters
|
|
|
314 if lexdata[lexpos] in lexignore:
|
|
|
315 lexpos += 1
|
|
|
316 continue
|
|
|
317
|
|
|
318 # Look for a regular expression match
|
|
|
319 for lexre, lexindexfunc in self.lexre:
|
|
|
320 m = lexre.match(lexdata, lexpos)
|
|
|
321 if not m:
|
|
|
322 continue
|
|
|
323
|
|
|
324 # Create a token for return
|
|
|
325 tok = LexToken()
|
|
|
326 tok.value = m.group()
|
|
|
327 tok.lineno = self.lineno
|
|
|
328 tok.lexpos = lexpos
|
|
|
329
|
|
|
330 i = m.lastindex
|
|
|
331 func, tok.type = lexindexfunc[i]
|
|
|
332
|
|
|
333 if not func:
|
|
|
334 # If no token type was set, it's an ignored token
|
|
|
335 if tok.type:
|
|
|
336 self.lexpos = m.end()
|
|
|
337 return tok
|
|
|
338 else:
|
|
|
339 lexpos = m.end()
|
|
|
340 break
|
|
|
341
|
|
|
342 lexpos = m.end()
|
|
|
343
|
|
|
344 # If token is processed by a function, call it
|
|
|
345
|
|
|
346 tok.lexer = self # Set additional attributes useful in token rules
|
|
|
347 self.lexmatch = m
|
|
|
348 self.lexpos = lexpos
|
|
|
349
|
|
|
350 newtok = func(tok)
|
|
|
351
|
|
|
352 # Every function must return a token, if nothing, we just move to next token
|
|
|
353 if not newtok:
|
|
|
354 lexpos = self.lexpos # This is here in case user has updated lexpos.
|
|
|
355 lexignore = self.lexignore # This is here in case there was a state change
|
|
|
356 break
|
|
|
357
|
|
|
358 # Verify type of the token. If not in the token map, raise an error
|
|
|
359 if not self.lexoptimize:
|
|
|
360 if newtok.type not in self.lextokens_all:
|
|
|
361 raise LexError("%s:%d: Rule '%s' returned an unknown token type '%s'" % (
|
|
|
362 func.__code__.co_filename, func.__code__.co_firstlineno,
|
|
|
363 func.__name__, newtok.type), lexdata[lexpos:])
|
|
|
364
|
|
|
365 return newtok
|
|
|
366 else:
|
|
|
367 # No match, see if in literals
|
|
|
368 if lexdata[lexpos] in self.lexliterals:
|
|
|
369 tok = LexToken()
|
|
|
370 tok.value = lexdata[lexpos]
|
|
|
371 tok.lineno = self.lineno
|
|
|
372 tok.type = tok.value
|
|
|
373 tok.lexpos = lexpos
|
|
|
374 self.lexpos = lexpos + 1
|
|
|
375 return tok
|
|
|
376
|
|
|
377 # No match. Call t_error() if defined.
|
|
|
378 if self.lexerrorf:
|
|
|
379 tok = LexToken()
|
|
|
380 tok.value = self.lexdata[lexpos:]
|
|
|
381 tok.lineno = self.lineno
|
|
|
382 tok.type = 'error'
|
|
|
383 tok.lexer = self
|
|
|
384 tok.lexpos = lexpos
|
|
|
385 self.lexpos = lexpos
|
|
|
386 newtok = self.lexerrorf(tok)
|
|
|
387 if lexpos == self.lexpos:
|
|
|
388 # Error method didn't change text position at all. This is an error.
|
|
|
389 raise LexError("Scanning error. Illegal character '%s'" % (lexdata[lexpos]), lexdata[lexpos:])
|
|
|
390 lexpos = self.lexpos
|
|
|
391 if not newtok:
|
|
|
392 continue
|
|
|
393 return newtok
|
|
|
394
|
|
|
395 self.lexpos = lexpos
|
|
|
396 raise LexError("Illegal character '%s' at index %d" % (lexdata[lexpos], lexpos), lexdata[lexpos:])
|
|
|
397
|
|
|
398 if self.lexeoff:
|
|
|
399 tok = LexToken()
|
|
|
400 tok.type = 'eof'
|
|
|
401 tok.value = ''
|
|
|
402 tok.lineno = self.lineno
|
|
|
403 tok.lexpos = lexpos
|
|
|
404 tok.lexer = self
|
|
|
405 self.lexpos = lexpos
|
|
|
406 newtok = self.lexeoff(tok)
|
|
|
407 return newtok
|
|
|
408
|
|
|
409 self.lexpos = lexpos + 1
|
|
|
410 if self.lexdata is None:
|
|
|
411 raise RuntimeError('No input string given with input()')
|
|
|
412 return None
|
|
|
413
|
|
|
414 # Iterator interface
|
|
|
415 def __iter__(self):
|
|
|
416 return self
|
|
|
417
|
|
|
418 def next(self):
|
|
|
419 t = self.token()
|
|
|
420 if t is None:
|
|
|
421 raise StopIteration
|
|
|
422 return t
|
|
|
423
|
|
|
424 __next__ = next
|
|
|
425
|
|
|
426 # -----------------------------------------------------------------------------
|
|
|
427 # ==== Lex Builder ===
|
|
|
428 #
|
|
|
429 # The functions and classes below are used to collect lexing information
|
|
|
430 # and build a Lexer object from it.
|
|
|
431 # -----------------------------------------------------------------------------
|
|
|
432
|
|
|
433 # -----------------------------------------------------------------------------
|
|
|
434 # _get_regex(func)
|
|
|
435 #
|
|
|
436 # Returns the regular expression assigned to a function either as a doc string
|
|
|
437 # or as a .regex attribute attached by the @TOKEN decorator.
|
|
|
438 # -----------------------------------------------------------------------------
|
|
|
439 def _get_regex(func):
|
|
|
440 return getattr(func, 'regex', func.__doc__)
|
|
|
441
|
|
|
442 # -----------------------------------------------------------------------------
|
|
|
443 # get_caller_module_dict()
|
|
|
444 #
|
|
|
445 # This function returns a dictionary containing all of the symbols defined within
|
|
|
446 # a caller further down the call stack. This is used to get the environment
|
|
|
447 # associated with the yacc() call if none was provided.
|
|
|
448 # -----------------------------------------------------------------------------
|
|
|
449 def get_caller_module_dict(levels):
|
|
|
450 f = sys._getframe(levels)
|
|
|
451 ldict = f.f_globals.copy()
|
|
|
452 if f.f_globals != f.f_locals:
|
|
|
453 ldict.update(f.f_locals)
|
|
|
454 return ldict
|
|
|
455
|
|
|
456 # -----------------------------------------------------------------------------
|
|
|
457 # _funcs_to_names()
|
|
|
458 #
|
|
|
459 # Given a list of regular expression functions, this converts it to a list
|
|
|
460 # suitable for output to a table file
|
|
|
461 # -----------------------------------------------------------------------------
|
|
|
462 def _funcs_to_names(funclist, namelist):
|
|
|
463 result = []
|
|
|
464 for f, name in zip(funclist, namelist):
|
|
|
465 if f and f[0]:
|
|
|
466 result.append((name, f[1]))
|
|
|
467 else:
|
|
|
468 result.append(f)
|
|
|
469 return result
|
|
|
470
|
|
|
471 # -----------------------------------------------------------------------------
|
|
|
472 # _names_to_funcs()
|
|
|
473 #
|
|
|
474 # Given a list of regular expression function names, this converts it back to
|
|
|
475 # functions.
|
|
|
476 # -----------------------------------------------------------------------------
|
|
|
477 def _names_to_funcs(namelist, fdict):
|
|
|
478 result = []
|
|
|
479 for n in namelist:
|
|
|
480 if n and n[0]:
|
|
|
481 result.append((fdict[n[0]], n[1]))
|
|
|
482 else:
|
|
|
483 result.append(n)
|
|
|
484 return result
|
|
|
485
|
|
|
486 # -----------------------------------------------------------------------------
|
|
|
487 # _form_master_re()
|
|
|
488 #
|
|
|
489 # This function takes a list of all of the regex components and attempts to
|
|
|
490 # form the master regular expression. Given limitations in the Python re
|
|
|
491 # module, it may be necessary to break the master regex into separate expressions.
|
|
|
492 # -----------------------------------------------------------------------------
|
|
|
493 def _form_master_re(relist, reflags, ldict, toknames):
|
|
|
494 if not relist:
|
|
|
495 return []
|
|
|
496 regex = '|'.join(relist)
|
|
|
497 try:
|
|
|
498 lexre = re.compile(regex, re.VERBOSE | reflags)
|
|
|
499
|
|
|
500 # Build the index to function map for the matching engine
|
|
|
501 lexindexfunc = [None] * (max(lexre.groupindex.values()) + 1)
|
|
|
502 lexindexnames = lexindexfunc[:]
|
|
|
503
|
|
|
504 for f, i in lexre.groupindex.items():
|
|
|
505 handle = ldict.get(f, None)
|
|
|
506 if type(handle) in (types.FunctionType, types.MethodType):
|
|
|
507 lexindexfunc[i] = (handle, toknames[f])
|
|
|
508 lexindexnames[i] = f
|
|
|
509 elif handle is not None:
|
|
|
510 lexindexnames[i] = f
|
|
|
511 if f.find('ignore_') > 0:
|
|
|
512 lexindexfunc[i] = (None, None)
|
|
|
513 else:
|
|
|
514 lexindexfunc[i] = (None, toknames[f])
|
|
|
515
|
|
|
516 return [(lexre, lexindexfunc)], [regex], [lexindexnames]
|
|
|
517 except Exception:
|
|
|
518 m = int(len(relist)/2)
|
|
|
519 if m == 0:
|
|
|
520 m = 1
|
|
|
521 llist, lre, lnames = _form_master_re(relist[:m], reflags, ldict, toknames)
|
|
|
522 rlist, rre, rnames = _form_master_re(relist[m:], reflags, ldict, toknames)
|
|
|
523 return (llist+rlist), (lre+rre), (lnames+rnames)
|
|
|
524
|
|
|
525 # -----------------------------------------------------------------------------
|
|
|
526 # def _statetoken(s,names)
|
|
|
527 #
|
|
|
528 # Given a declaration name s of the form "t_" and a dictionary whose keys are
|
|
|
529 # state names, this function returns a tuple (states,tokenname) where states
|
|
|
530 # is a tuple of state names and tokenname is the name of the token. For example,
|
|
|
531 # calling this with s = "t_foo_bar_SPAM" might return (('foo','bar'),'SPAM')
|
|
|
532 # -----------------------------------------------------------------------------
|
|
|
533 def _statetoken(s, names):
|
|
|
534 nonstate = 1
|
|
|
535 parts = s.split('_')
|
|
|
536 for i, part in enumerate(parts[1:], 1):
|
|
|
537 if part not in names and part != 'ANY':
|
|
|
538 break
|
|
|
539
|
|
|
540 if i > 1:
|
|
|
541 states = tuple(parts[1:i])
|
|
|
542 else:
|
|
|
543 states = ('INITIAL',)
|
|
|
544
|
|
|
545 if 'ANY' in states:
|
|
|
546 states = tuple(names)
|
|
|
547
|
|
|
548 tokenname = '_'.join(parts[i:])
|
|
|
549 return (states, tokenname)
|
|
|
550
|
|
|
551
|
|
|
552 # -----------------------------------------------------------------------------
|
|
|
553 # LexerReflect()
|
|
|
554 #
|
|
|
555 # This class represents information needed to build a lexer as extracted from a
|
|
|
556 # user's input file.
|
|
|
557 # -----------------------------------------------------------------------------
|
|
|
558 class LexerReflect(object):
|
|
|
559 def __init__(self, ldict, log=None, reflags=0):
|
|
|
560 self.ldict = ldict
|
|
|
561 self.error_func = None
|
|
|
562 self.tokens = []
|
|
|
563 self.reflags = reflags
|
|
|
564 self.stateinfo = {'INITIAL': 'inclusive'}
|
|
|
565 self.modules = set()
|
|
|
566 self.error = False
|
|
|
567 self.log = PlyLogger(sys.stderr) if log is None else log
|
|
|
568
|
|
|
569 # Get all of the basic information
|
|
|
570 def get_all(self):
|
|
|
571 self.get_tokens()
|
|
|
572 self.get_literals()
|
|
|
573 self.get_states()
|
|
|
574 self.get_rules()
|
|
|
575
|
|
|
576 # Validate all of the information
|
|
|
577 def validate_all(self):
|
|
|
578 self.validate_tokens()
|
|
|
579 self.validate_literals()
|
|
|
580 self.validate_rules()
|
|
|
581 return self.error
|
|
|
582
|
|
|
583 # Get the tokens map
|
|
|
584 def get_tokens(self):
|
|
|
585 tokens = self.ldict.get('tokens', None)
|
|
|
586 if not tokens:
|
|
|
587 self.log.error('No token list is defined')
|
|
|
588 self.error = True
|
|
|
589 return
|
|
|
590
|
|
|
591 if not isinstance(tokens, (list, tuple)):
|
|
|
592 self.log.error('tokens must be a list or tuple')
|
|
|
593 self.error = True
|
|
|
594 return
|
|
|
595
|
|
|
596 if not tokens:
|
|
|
597 self.log.error('tokens is empty')
|
|
|
598 self.error = True
|
|
|
599 return
|
|
|
600
|
|
|
601 self.tokens = tokens
|
|
|
602
|
|
|
603 # Validate the tokens
|
|
|
604 def validate_tokens(self):
|
|
|
605 terminals = {}
|
|
|
606 for n in self.tokens:
|
|
|
607 if not _is_identifier.match(n):
|
|
|
608 self.log.error("Bad token name '%s'", n)
|
|
|
609 self.error = True
|
|
|
610 if n in terminals:
|
|
|
611 self.log.warning("Token '%s' multiply defined", n)
|
|
|
612 terminals[n] = 1
|
|
|
613
|
|
|
614 # Get the literals specifier
|
|
|
615 def get_literals(self):
|
|
|
616 self.literals = self.ldict.get('literals', '')
|
|
|
617 if not self.literals:
|
|
|
618 self.literals = ''
|
|
|
619
|
|
|
620 # Validate literals
|
|
|
621 def validate_literals(self):
|
|
|
622 try:
|
|
|
623 for c in self.literals:
|
|
|
624 if not isinstance(c, StringTypes) or len(c) > 1:
|
|
|
625 self.log.error('Invalid literal %s. Must be a single character', repr(c))
|
|
|
626 self.error = True
|
|
|
627
|
|
|
628 except TypeError:
|
|
|
629 self.log.error('Invalid literals specification. literals must be a sequence of characters')
|
|
|
630 self.error = True
|
|
|
631
|
|
|
632 def get_states(self):
|
|
|
633 self.states = self.ldict.get('states', None)
|
|
|
634 # Build statemap
|
|
|
635 if self.states:
|
|
|
636 if not isinstance(self.states, (tuple, list)):
|
|
|
637 self.log.error('states must be defined as a tuple or list')
|
|
|
638 self.error = True
|
|
|
639 else:
|
|
|
640 for s in self.states:
|
|
|
641 if not isinstance(s, tuple) or len(s) != 2:
|
|
|
642 self.log.error("Invalid state specifier %s. Must be a tuple (statename,'exclusive|inclusive')", repr(s))
|
|
|
643 self.error = True
|
|
|
644 continue
|
|
|
645 name, statetype = s
|
|
|
646 if not isinstance(name, StringTypes):
|
|
|
647 self.log.error('State name %s must be a string', repr(name))
|
|
|
648 self.error = True
|
|
|
649 continue
|
|
|
650 if not (statetype == 'inclusive' or statetype == 'exclusive'):
|
|
|
651 self.log.error("State type for state %s must be 'inclusive' or 'exclusive'", name)
|
|
|
652 self.error = True
|
|
|
653 continue
|
|
|
654 if name in self.stateinfo:
|
|
|
655 self.log.error("State '%s' already defined", name)
|
|
|
656 self.error = True
|
|
|
657 continue
|
|
|
658 self.stateinfo[name] = statetype
|
|
|
659
|
|
|
660 # Get all of the symbols with a t_ prefix and sort them into various
|
|
|
661 # categories (functions, strings, error functions, and ignore characters)
|
|
|
662
|
|
|
663 def get_rules(self):
|
|
|
664 tsymbols = [f for f in self.ldict if f[:2] == 't_']
|
|
|
665
|
|
|
666 # Now build up a list of functions and a list of strings
|
|
|
667 self.toknames = {} # Mapping of symbols to token names
|
|
|
668 self.funcsym = {} # Symbols defined as functions
|
|
|
669 self.strsym = {} # Symbols defined as strings
|
|
|
670 self.ignore = {} # Ignore strings by state
|
|
|
671 self.errorf = {} # Error functions by state
|
|
|
672 self.eoff = {} # EOF functions by state
|
|
|
673
|
|
|
674 for s in self.stateinfo:
|
|
|
675 self.funcsym[s] = []
|
|
|
676 self.strsym[s] = []
|
|
|
677
|
|
|
678 if len(tsymbols) == 0:
|
|
|
679 self.log.error('No rules of the form t_rulename are defined')
|
|
|
680 self.error = True
|
|
|
681 return
|
|
|
682
|
|
|
683 for f in tsymbols:
|
|
|
684 t = self.ldict[f]
|
|
|
685 states, tokname = _statetoken(f, self.stateinfo)
|
|
|
686 self.toknames[f] = tokname
|
|
|
687
|
|
|
688 if hasattr(t, '__call__'):
|
|
|
689 if tokname == 'error':
|
|
|
690 for s in states:
|
|
|
691 self.errorf[s] = t
|
|
|
692 elif tokname == 'eof':
|
|
|
693 for s in states:
|
|
|
694 self.eoff[s] = t
|
|
|
695 elif tokname == 'ignore':
|
|
|
696 line = t.__code__.co_firstlineno
|
|
|
697 file = t.__code__.co_filename
|
|
|
698 self.log.error("%s:%d: Rule '%s' must be defined as a string", file, line, t.__name__)
|
|
|
699 self.error = True
|
|
|
700 else:
|
|
|
701 for s in states:
|
|
|
702 self.funcsym[s].append((f, t))
|
|
|
703 elif isinstance(t, StringTypes):
|
|
|
704 if tokname == 'ignore':
|
|
|
705 for s in states:
|
|
|
706 self.ignore[s] = t
|
|
|
707 if '\\' in t:
|
|
|
708 self.log.warning("%s contains a literal backslash '\\'", f)
|
|
|
709
|
|
|
710 elif tokname == 'error':
|
|
|
711 self.log.error("Rule '%s' must be defined as a function", f)
|
|
|
712 self.error = True
|
|
|
713 else:
|
|
|
714 for s in states:
|
|
|
715 self.strsym[s].append((f, t))
|
|
|
716 else:
|
|
|
717 self.log.error('%s not defined as a function or string', f)
|
|
|
718 self.error = True
|
|
|
719
|
|
|
720 # Sort the functions by line number
|
|
|
721 for f in self.funcsym.values():
|
|
|
722 f.sort(key=lambda x: x[1].__code__.co_firstlineno)
|
|
|
723
|
|
|
724 # Sort the strings by regular expression length
|
|
|
725 for s in self.strsym.values():
|
|
|
726 s.sort(key=lambda x: len(x[1]), reverse=True)
|
|
|
727
|
|
|
728 # Validate all of the t_rules collected
|
|
|
729 def validate_rules(self):
|
|
|
730 for state in self.stateinfo:
|
|
|
731 # Validate all rules defined by functions
|
|
|
732
|
|
|
733 for fname, f in self.funcsym[state]:
|
|
|
734 line = f.__code__.co_firstlineno
|
|
|
735 file = f.__code__.co_filename
|
|
|
736 module = inspect.getmodule(f)
|
|
|
737 self.modules.add(module)
|
|
|
738
|
|
|
739 tokname = self.toknames[fname]
|
|
|
740 if isinstance(f, types.MethodType):
|
|
|
741 reqargs = 2
|
|
|
742 else:
|
|
|
743 reqargs = 1
|
|
|
744 nargs = f.__code__.co_argcount
|
|
|
745 if nargs > reqargs:
|
|
|
746 self.log.error("%s:%d: Rule '%s' has too many arguments", file, line, f.__name__)
|
|
|
747 self.error = True
|
|
|
748 continue
|
|
|
749
|
|
|
750 if nargs < reqargs:
|
|
|
751 self.log.error("%s:%d: Rule '%s' requires an argument", file, line, f.__name__)
|
|
|
752 self.error = True
|
|
|
753 continue
|
|
|
754
|
|
|
755 if not _get_regex(f):
|
|
|
756 self.log.error("%s:%d: No regular expression defined for rule '%s'", file, line, f.__name__)
|
|
|
757 self.error = True
|
|
|
758 continue
|
|
|
759
|
|
|
760 try:
|
|
|
761 c = re.compile('(?P<%s>%s)' % (fname, _get_regex(f)), re.VERBOSE | self.reflags)
|
|
|
762 if c.match(''):
|
|
|
763 self.log.error("%s:%d: Regular expression for rule '%s' matches empty string", file, line, f.__name__)
|
|
|
764 self.error = True
|
|
|
765 except re.error as e:
|
|
|
766 self.log.error("%s:%d: Invalid regular expression for rule '%s'. %s", file, line, f.__name__, e)
|
|
|
767 if '#' in _get_regex(f):
|
|
|
768 self.log.error("%s:%d. Make sure '#' in rule '%s' is escaped with '\\#'", file, line, f.__name__)
|
|
|
769 self.error = True
|
|
|
770
|
|
|
771 # Validate all rules defined by strings
|
|
|
772 for name, r in self.strsym[state]:
|
|
|
773 tokname = self.toknames[name]
|
|
|
774 if tokname == 'error':
|
|
|
775 self.log.error("Rule '%s' must be defined as a function", name)
|
|
|
776 self.error = True
|
|
|
777 continue
|
|
|
778
|
|
|
779 if tokname not in self.tokens and tokname.find('ignore_') < 0:
|
|
|
780 self.log.error("Rule '%s' defined for an unspecified token %s", name, tokname)
|
|
|
781 self.error = True
|
|
|
782 continue
|
|
|
783
|
|
|
784 try:
|
|
|
785 c = re.compile('(?P<%s>%s)' % (name, r), re.VERBOSE | self.reflags)
|
|
|
786 if (c.match('')):
|
|
|
787 self.log.error("Regular expression for rule '%s' matches empty string", name)
|
|
|
788 self.error = True
|
|
|
789 except re.error as e:
|
|
|
790 self.log.error("Invalid regular expression for rule '%s'. %s", name, e)
|
|
|
791 if '#' in r:
|
|
|
792 self.log.error("Make sure '#' in rule '%s' is escaped with '\\#'", name)
|
|
|
793 self.error = True
|
|
|
794
|
|
|
795 if not self.funcsym[state] and not self.strsym[state]:
|
|
|
796 self.log.error("No rules defined for state '%s'", state)
|
|
|
797 self.error = True
|
|
|
798
|
|
|
799 # Validate the error function
|
|
|
800 efunc = self.errorf.get(state, None)
|
|
|
801 if efunc:
|
|
|
802 f = efunc
|
|
|
803 line = f.__code__.co_firstlineno
|
|
|
804 file = f.__code__.co_filename
|
|
|
805 module = inspect.getmodule(f)
|
|
|
806 self.modules.add(module)
|
|
|
807
|
|
|
808 if isinstance(f, types.MethodType):
|
|
|
809 reqargs = 2
|
|
|
810 else:
|
|
|
811 reqargs = 1
|
|
|
812 nargs = f.__code__.co_argcount
|
|
|
813 if nargs > reqargs:
|
|
|
814 self.log.error("%s:%d: Rule '%s' has too many arguments", file, line, f.__name__)
|
|
|
815 self.error = True
|
|
|
816
|
|
|
817 if nargs < reqargs:
|
|
|
818 self.log.error("%s:%d: Rule '%s' requires an argument", file, line, f.__name__)
|
|
|
819 self.error = True
|
|
|
820
|
|
|
821 for module in self.modules:
|
|
|
822 self.validate_module(module)
|
|
|
823
|
|
|
824 # -----------------------------------------------------------------------------
|
|
|
825 # validate_module()
|
|
|
826 #
|
|
|
827 # This checks to see if there are duplicated t_rulename() functions or strings
|
|
|
828 # in the parser input file. This is done using a simple regular expression
|
|
|
829 # match on each line in the source code of the given module.
|
|
|
830 # -----------------------------------------------------------------------------
|
|
|
831
|
|
|
832 def validate_module(self, module):
|
|
|
833 lines, linen = inspect.getsourcelines(module)
|
|
|
834
|
|
|
835 fre = re.compile(r'\s*def\s+(t_[a-zA-Z_0-9]*)\(')
|
|
|
836 sre = re.compile(r'\s*(t_[a-zA-Z_0-9]*)\s*=')
|
|
|
837
|
|
|
838 counthash = {}
|
|
|
839 linen += 1
|
|
|
840 for line in lines:
|
|
|
841 m = fre.match(line)
|
|
|
842 if not m:
|
|
|
843 m = sre.match(line)
|
|
|
844 if m:
|
|
|
845 name = m.group(1)
|
|
|
846 prev = counthash.get(name)
|
|
|
847 if not prev:
|
|
|
848 counthash[name] = linen
|
|
|
849 else:
|
|
|
850 filename = inspect.getsourcefile(module)
|
|
|
851 self.log.error('%s:%d: Rule %s redefined. Previously defined on line %d', filename, linen, name, prev)
|
|
|
852 self.error = True
|
|
|
853 linen += 1
|
|
|
854
|
|
|
855 # -----------------------------------------------------------------------------
|
|
|
856 # lex(module)
|
|
|
857 #
|
|
|
858 # Build all of the regular expression rules from definitions in the supplied module
|
|
|
859 # -----------------------------------------------------------------------------
|
|
|
860 def lex(module=None, object=None, debug=False, optimize=False, lextab='lextab',
|
|
|
861 reflags=0, nowarn=False, outputdir=None, debuglog=None, errorlog=None):
|
|
|
862
|
|
|
863 if lextab is None:
|
|
|
864 lextab = 'lextab'
|
|
|
865
|
|
|
866 global lexer
|
|
|
867
|
|
|
868 ldict = None
|
|
|
869 stateinfo = {'INITIAL': 'inclusive'}
|
|
|
870 lexobj = Lexer()
|
|
|
871 lexobj.lexoptimize = optimize
|
|
|
872 global token, input
|
|
|
873
|
|
|
874 if errorlog is None:
|
|
|
875 errorlog = PlyLogger(sys.stderr)
|
|
|
876
|
|
|
877 if debug:
|
|
|
878 if debuglog is None:
|
|
|
879 debuglog = PlyLogger(sys.stderr)
|
|
|
880
|
|
|
881 # Get the module dictionary used for the lexer
|
|
|
882 if object:
|
|
|
883 module = object
|
|
|
884
|
|
|
885 # Get the module dictionary used for the parser
|
|
|
886 if module:
|
|
|
887 _items = [(k, getattr(module, k)) for k in dir(module)]
|
|
|
888 ldict = dict(_items)
|
|
|
889 # If no __file__ attribute is available, try to obtain it from the __module__ instead
|
|
|
890 if '__file__' not in ldict:
|
|
|
891 ldict['__file__'] = sys.modules[ldict['__module__']].__file__
|
|
|
892 else:
|
|
|
893 ldict = get_caller_module_dict(2)
|
|
|
894
|
|
|
895 # Determine if the module is package of a package or not.
|
|
|
896 # If so, fix the tabmodule setting so that tables load correctly
|
|
|
897 pkg = ldict.get('__package__')
|
|
|
898 if pkg and isinstance(lextab, str):
|
|
|
899 if '.' not in lextab:
|
|
|
900 lextab = pkg + '.' + lextab
|
|
|
901
|
|
|
902 # Collect parser information from the dictionary
|
|
|
903 linfo = LexerReflect(ldict, log=errorlog, reflags=reflags)
|
|
|
904 linfo.get_all()
|
|
|
905 if not optimize:
|
|
|
906 if linfo.validate_all():
|
|
|
907 raise SyntaxError("Can't build lexer")
|
|
|
908
|
|
|
909 if optimize and lextab:
|
|
|
910 try:
|
|
|
911 lexobj.readtab(lextab, ldict)
|
|
|
912 token = lexobj.token
|
|
|
913 input = lexobj.input
|
|
|
914 lexer = lexobj
|
|
|
915 return lexobj
|
|
|
916
|
|
|
917 except ImportError:
|
|
|
918 pass
|
|
|
919
|
|
|
920 # Dump some basic debugging information
|
|
|
921 if debug:
|
|
|
922 debuglog.info('lex: tokens = %r', linfo.tokens)
|
|
|
923 debuglog.info('lex: literals = %r', linfo.literals)
|
|
|
924 debuglog.info('lex: states = %r', linfo.stateinfo)
|
|
|
925
|
|
|
926 # Build a dictionary of valid token names
|
|
|
927 lexobj.lextokens = set()
|
|
|
928 for n in linfo.tokens:
|
|
|
929 lexobj.lextokens.add(n)
|
|
|
930
|
|
|
931 # Get literals specification
|
|
|
932 if isinstance(linfo.literals, (list, tuple)):
|
|
|
933 lexobj.lexliterals = type(linfo.literals[0])().join(linfo.literals)
|
|
|
934 else:
|
|
|
935 lexobj.lexliterals = linfo.literals
|
|
|
936
|
|
|
937 lexobj.lextokens_all = lexobj.lextokens | set(lexobj.lexliterals)
|
|
|
938
|
|
|
939 # Get the stateinfo dictionary
|
|
|
940 stateinfo = linfo.stateinfo
|
|
|
941
|
|
|
942 regexs = {}
|
|
|
943 # Build the master regular expressions
|
|
|
944 for state in stateinfo:
|
|
|
945 regex_list = []
|
|
|
946
|
|
|
947 # Add rules defined by functions first
|
|
|
948 for fname, f in linfo.funcsym[state]:
|
|
|
949 line = f.__code__.co_firstlineno
|
|
|
950 file = f.__code__.co_filename
|
|
|
951 regex_list.append('(?P<%s>%s)' % (fname, _get_regex(f)))
|
|
|
952 if debug:
|
|
|
953 debuglog.info("lex: Adding rule %s -> '%s' (state '%s')", fname, _get_regex(f), state)
|
|
|
954
|
|
|
955 # Now add all of the simple rules
|
|
|
956 for name, r in linfo.strsym[state]:
|
|
|
957 regex_list.append('(?P<%s>%s)' % (name, r))
|
|
|
958 if debug:
|
|
|
959 debuglog.info("lex: Adding rule %s -> '%s' (state '%s')", name, r, state)
|
|
|
960
|
|
|
961 regexs[state] = regex_list
|
|
|
962
|
|
|
963 # Build the master regular expressions
|
|
|
964
|
|
|
965 if debug:
|
|
|
966 debuglog.info('lex: ==== MASTER REGEXS FOLLOW ====')
|
|
|
967
|
|
|
968 for state in regexs:
|
|
|
969 lexre, re_text, re_names = _form_master_re(regexs[state], reflags, ldict, linfo.toknames)
|
|
|
970 lexobj.lexstatere[state] = lexre
|
|
|
971 lexobj.lexstateretext[state] = re_text
|
|
|
972 lexobj.lexstaterenames[state] = re_names
|
|
|
973 if debug:
|
|
|
974 for i, text in enumerate(re_text):
|
|
|
975 debuglog.info("lex: state '%s' : regex[%d] = '%s'", state, i, text)
|
|
|
976
|
|
|
977 # For inclusive states, we need to add the regular expressions from the INITIAL state
|
|
|
978 for state, stype in stateinfo.items():
|
|
|
979 if state != 'INITIAL' and stype == 'inclusive':
|
|
|
980 lexobj.lexstatere[state].extend(lexobj.lexstatere['INITIAL'])
|
|
|
981 lexobj.lexstateretext[state].extend(lexobj.lexstateretext['INITIAL'])
|
|
|
982 lexobj.lexstaterenames[state].extend(lexobj.lexstaterenames['INITIAL'])
|
|
|
983
|
|
|
984 lexobj.lexstateinfo = stateinfo
|
|
|
985 lexobj.lexre = lexobj.lexstatere['INITIAL']
|
|
|
986 lexobj.lexretext = lexobj.lexstateretext['INITIAL']
|
|
|
987 lexobj.lexreflags = reflags
|
|
|
988
|
|
|
989 # Set up ignore variables
|
|
|
990 lexobj.lexstateignore = linfo.ignore
|
|
|
991 lexobj.lexignore = lexobj.lexstateignore.get('INITIAL', '')
|
|
|
992
|
|
|
993 # Set up error functions
|
|
|
994 lexobj.lexstateerrorf = linfo.errorf
|
|
|
995 lexobj.lexerrorf = linfo.errorf.get('INITIAL', None)
|
|
|
996 if not lexobj.lexerrorf:
|
|
|
997 errorlog.warning('No t_error rule is defined')
|
|
|
998
|
|
|
999 # Set up eof functions
|
|
|
1000 lexobj.lexstateeoff = linfo.eoff
|
|
|
1001 lexobj.lexeoff = linfo.eoff.get('INITIAL', None)
|
|
|
1002
|
|
|
1003 # Check state information for ignore and error rules
|
|
|
1004 for s, stype in stateinfo.items():
|
|
|
1005 if stype == 'exclusive':
|
|
|
1006 if s not in linfo.errorf:
|
|
|
1007 errorlog.warning("No error rule is defined for exclusive state '%s'", s)
|
|
|
1008 if s not in linfo.ignore and lexobj.lexignore:
|
|
|
1009 errorlog.warning("No ignore rule is defined for exclusive state '%s'", s)
|
|
|
1010 elif stype == 'inclusive':
|
|
|
1011 if s not in linfo.errorf:
|
|
|
1012 linfo.errorf[s] = linfo.errorf.get('INITIAL', None)
|
|
|
1013 if s not in linfo.ignore:
|
|
|
1014 linfo.ignore[s] = linfo.ignore.get('INITIAL', '')
|
|
|
1015
|
|
|
1016 # Create global versions of the token() and input() functions
|
|
|
1017 token = lexobj.token
|
|
|
1018 input = lexobj.input
|
|
|
1019 lexer = lexobj
|
|
|
1020
|
|
|
1021 # If in optimize mode, we write the lextab
|
|
|
1022 if lextab and optimize:
|
|
|
1023 if outputdir is None:
|
|
|
1024 # If no output directory is set, the location of the output files
|
|
|
1025 # is determined according to the following rules:
|
|
|
1026 # - If lextab specifies a package, files go into that package directory
|
|
|
1027 # - Otherwise, files go in the same directory as the specifying module
|
|
|
1028 if isinstance(lextab, types.ModuleType):
|
|
|
1029 srcfile = lextab.__file__
|
|
|
1030 else:
|
|
|
1031 if '.' not in lextab:
|
|
|
1032 srcfile = ldict['__file__']
|
|
|
1033 else:
|
|
|
1034 parts = lextab.split('.')
|
|
|
1035 pkgname = '.'.join(parts[:-1])
|
|
|
1036 exec('import %s' % pkgname)
|
|
|
1037 srcfile = getattr(sys.modules[pkgname], '__file__', '')
|
|
|
1038 outputdir = os.path.dirname(srcfile)
|
|
|
1039 try:
|
|
|
1040 lexobj.writetab(lextab, outputdir)
|
|
|
1041 except IOError as e:
|
|
|
1042 errorlog.warning("Couldn't write lextab module %r. %s" % (lextab, e))
|
|
|
1043
|
|
|
1044 return lexobj
|
|
|
1045
|
|
|
1046 # -----------------------------------------------------------------------------
|
|
|
1047 # runmain()
|
|
|
1048 #
|
|
|
1049 # This runs the lexer as a main program
|
|
|
1050 # -----------------------------------------------------------------------------
|
|
|
1051
|
|
|
1052 def runmain(lexer=None, data=None):
|
|
|
1053 if not data:
|
|
|
1054 try:
|
|
|
1055 filename = sys.argv[1]
|
|
|
1056 f = open(filename)
|
|
|
1057 data = f.read()
|
|
|
1058 f.close()
|
|
|
1059 except IndexError:
|
|
|
1060 sys.stdout.write('Reading from standard input (type EOF to end):\n')
|
|
|
1061 data = sys.stdin.read()
|
|
|
1062
|
|
|
1063 if lexer:
|
|
|
1064 _input = lexer.input
|
|
|
1065 else:
|
|
|
1066 _input = input
|
|
|
1067 _input(data)
|
|
|
1068 if lexer:
|
|
|
1069 _token = lexer.token
|
|
|
1070 else:
|
|
|
1071 _token = token
|
|
|
1072
|
|
|
1073 while True:
|
|
|
1074 tok = _token()
|
|
|
1075 if not tok:
|
|
|
1076 break
|
|
|
1077 sys.stdout.write('(%s,%r,%d,%d)\n' % (tok.type, tok.value, tok.lineno, tok.lexpos))
|
|
|
1078
|
|
|
1079 # -----------------------------------------------------------------------------
|
|
|
1080 # @TOKEN(regex)
|
|
|
1081 #
|
|
|
1082 # This decorator function can be used to set the regex expression on a function
|
|
|
1083 # when its docstring might need to be set in an alternative way
|
|
|
1084 # -----------------------------------------------------------------------------
|
|
|
1085
|
|
|
1086 def TOKEN(r):
|
|
|
1087 def set_regex(f):
|
|
|
1088 if hasattr(r, '__call__'):
|
|
|
1089 f.regex = _get_regex(r)
|
|
|
1090 else:
|
|
|
1091 f.regex = r
|
|
|
1092 return f
|
|
|
1093 return set_regex
|
|
|
1094
|
|
|
1095 # Alternative spelling of the TOKEN decorator
|
|
|
1096 Token = TOKEN
|
|
|
1097
|
