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
|
(**************************************************************************)
(* *)
(* OCaml *)
(* *)
(* Jerome Vouillon, projet Cristal, INRIA Rocquencourt *)
(* OCaml port by John Malecki and Xavier Leroy *)
(* *)
(* Copyright 1996 Institut National de Recherche en Informatique et *)
(* en Automatique. *)
(* *)
(* All rights reserved. This file is distributed under the terms of *)
(* the GNU Lesser General Public License version 2.1, with the *)
(* special exception on linking described in the file LICENSE. *)
(* *)
(**************************************************************************)
{
open Debugger_parser
let ident_for_extended raw_name =
match Misc.Utf8_lexeme.normalize raw_name with
| Error _ -> raise Parsing.Parse_error
| Ok name ->
match Misc.Utf8_lexeme.validate_identifier name with
| Misc.Utf8_lexeme.Valid -> name
| Misc.Utf8_lexeme.Invalid_character _
| Misc.Utf8_lexeme.Invalid_beginning _ ->
raise Parsing.Parse_error
exception Int_overflow
}
let lowercase = ['a'-'z' '_']
let uppercase = ['A'-'Z']
let identstart = lowercase | uppercase
let identchar = ['A'-'Z' 'a'-'z' '_' '\'' '0'-'9']
let utf8 = ['\192'-'\255'] ['\128'-'\191']*
let identstart_ext = identstart | utf8
let identchar_ext = identchar | utf8
let ident_ext = identstart_ext identchar_ext*
rule line = (* Read a whole line *)
parse
([ ^ '\n' '\r' ]* as s) ('\n' | '\r' | "\r\n")
{ s }
| [ ^ '\n' '\r' ]*
{ Lexing.lexeme lexbuf }
| eof
{ raise Exit }
and argument = (* Read a raw argument *)
parse
[ ^ ' ' '\t' ]+
{ ARGUMENT (Lexing.lexeme lexbuf) }
| [' ' '\t']+
{ argument lexbuf }
| eof
{ EOL }
| _
{ raise Parsing.Parse_error }
and line_argument =
parse
_ *
{ ARGUMENT (Lexing.lexeme lexbuf) }
| eof
{ EOL }
and lexeme = (* Read a lexeme *)
parse
[' ' '\t'] +
{ lexeme lexbuf }
| lowercase identchar*
{ LIDENT(Lexing.lexeme lexbuf) }
| uppercase identchar*
{ UIDENT(Lexing.lexeme lexbuf) }
| ident_ext as raw_name
{
let name = ident_for_extended raw_name in
if Misc.Utf8_lexeme.is_capitalized name
then UIDENT name
else LIDENT name
}
| '"' [^ '"']* "\""
{ let s = Lexing.lexeme lexbuf in
LIDENT(String.sub s 1 (String.length s - 2)) }
| ['0'-'9']+
| '0' ['x' 'X'] ['0'-'9' 'A'-'F' 'a'-'f']+
| '0' ['o' 'O'] ['0'-'7']+
| '0' ['b' 'B'] ['0'-'1']+
{ try INTEGER (Int64.of_string (Lexing.lexeme lexbuf))
with Failure _ -> raise Int_overflow
}
| '*'
{ STAR }
| "-"
{ MINUS }
| "."
{ DOT }
| "#"
{ HASH }
| "@"
{ AT }
| "$"
{ DOLLAR }
| ":"
{ COLON }
| "!"
{ BANG }
| "("
{ LPAREN }
| ")"
{ RPAREN }
| "["
{ LBRACKET }
| "]"
{ RBRACKET }
| ['!' '?' '~' '=' '<' '>' '|' '&' '$' '@' '^' '+' '-' '*' '/' '%']
['!' '$' '%' '&' '*' '+' '-' '.' '/' ':' '<' '=' '>' '?' '@' '^' '|' '~'] *
{ OPERATOR (Lexing.lexeme lexbuf) }
| eof
{ EOL }
| _
{ raise Parsing.Parse_error }
|
