FilesExpand file tree

 main

/

exceptions.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

86 lines (66 loc) · 2.85 KB

 main

/

exceptions.py

Copy path

Top

File metadata and controls

• Code
• Blame

86 lines (66 loc) · 2.85 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

from .utils import STRING_TYPE

class LarkError(Exception):

pass

class GrammarError(LarkError):

pass

class ParseError(LarkError):

pass

class LexError(LarkError):

pass

class UnexpectedInput(LarkError):

pos_in_stream = None

def get_context(self, text, span=40):

pos = self.pos_in_stream

start = max(pos - span, 0)

end = pos + span

before = text[start:pos].rsplit('\n', 1)[-1]

after = text[pos:end].split('\n', 1)[0]

return before + after + '\n' + ' ' * len(before) + '^\n'

def match_examples(self, parse_fn, examples):

""" Given a parser instance and a dictionary mapping some label with

some malformed syntax examples, it'll return the label for the

example that bests matches the current error.

"""

assert self.state is not None, "Not supported for this exception"

candidate = None

for label, example in examples.items():

assert not isinstance(example, STRING_TYPE)

for malformed in example:

try:

parse_fn(malformed)

except UnexpectedInput as ut:

if ut.state == self.state:

try:

if ut.token == self.token: # Try exact match first

return label

except AttributeError:

pass

if not candidate:

candidate = label

return candidate

class UnexpectedCharacters(LexError, UnexpectedInput):

def __init__(self, seq, lex_pos, line, column, allowed=None, considered_tokens=None, state=None):

message = "No terminal defined for '%s' at line %d col %d" % (seq[lex_pos], line, column)

self.line = line

self.column = column

self.allowed = allowed

self.considered_tokens = considered_tokens

self.pos_in_stream = lex_pos

self.state = state

message += '\n\n' + self.get_context(seq)

if allowed:

message += '\nExpecting: %s\n' % allowed

super(UnexpectedCharacters, self).__init__(message)

class UnexpectedToken(ParseError, UnexpectedInput):

def __init__(self, token, expected, considered_rules=None, state=None):

self.token = token

self.expected = expected # XXX str shouldn't necessary

self.line = getattr(token, 'line', '?')

self.column = getattr(token, 'column', '?')

self.considered_rules = considered_rules

self.state = state

self.pos_in_stream = getattr(token, 'pos_in_stream', None)

message = ("Unexpected token %r at line %s, column %s.\n"

"Expected: %s\n"

% (token, self.line, self.column, ', '.join(self.expected)))

super(UnexpectedToken, self).__init__(message)