Source file reserved_words.ml

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
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
open Base

let keywords s = String.split_lines s |> List.map ~f:String.strip

let verilog =
  (* Taken from latest Verilog spec IEEE Std 1364-2005 (page 364, reserved keywords) *)
  keywords
    {| always
       and
       assign
       automatic
       begin
       buf
       bufif0
       bufif1
       case
       casex
       casez
       cell
       cmos
       config
       deassign
       default
       defparam
       design
       disable
       edge
       else
       end
       endcase
       endconfig
       endfunction
       endgenerate
       endmodule
       endprimitive
       endspecify
       endtable
       endtask
       event
       for
       force
       forever
       fork
       function
       generate
       genvar
       highz0
       highz1
       if
       ifnone
       incdir
       include
       initial
       inout
       input
       instance
       integer
       join
       large
       liblist
       library
       localparam
       macromodule
       medium
       module
       nand
       negedge
       nmos
       nor
       noshowcancelled
       not
       notif0
       notif1
       or
       output
       parameter
       pmos
       posedge
       primitive
       pull0
       pull1
       pulldown
       pullup
       pulsestyle_onevent
       pulsestyle_ondetect
       rcmos
       real
       realtime
       reg
       release
       repeat
       rnmos
       rpmos
       rtran
       rtranif0
       rtranif1
       scalared
       showcancelled
       signed
       small
       specify
       specparam
       strong0
       strong1
       supply0
       supply1
       table
       task
       time
       tran
       tranif0
       tranif1
       tri
       tri0
       tri1
       triand
       trior
       trireg
       unsigned
       use
       uwire
       vectored
       wait
       wand
       weak0
       weak1
       while
       wire
       wor
       xnor
       xor |}
;;

let vhdl =
  keywords
    {| abs
       access
       after
       alias
       all
       and
       architecture
       array
       assert
       attribute
       begin
       block
       body
       buffer
       bus
       case
       component
       configuration
       constant
       disconnect
       downto
       else
       elsif
       end
       entity
       exit
       file
       for
       function
       generate
       generic
       group
       guarded
       if
       impure
       in
       inertial
       inout
       is
       label
       library
       linkage
       literal
       loop
       map
       mod
       nand
       new
       next
       nor
       not
       null
       of
       on
       open
       or
       others
       out
       package
       port
       postponed
       procedure
       process
       pure
       range
       record
       register
       reject
       return
       rol
       ror
       select
       severity
       signal
       shared
       sla
       sli
       sra
       srl
       subtype
       then
       to
       transport
       type
       unaffected
       units
       until
       use
       variable
       wait
       when
       while
       with
       xnor
       xor |}
;;

(* From the OCaml source code: src/parsing/lexer.mll:38 *)
let ocaml =
  keywords
    {| and
       as
       assert
       begin
       class
       constraint
       do
       done
       downto
       else
       end
       exception
       external
       false
       for
       fun
       function
       functor
       if
       in
       include
       inherit
       initializer
       lazy
       let
       match
       method
       module
       mutable
       new
       nonrec
       object
       of
       open
       or
       private
       rec
       sig
       struct
       then
       to
       true
       try
       type
       val
       virtual
       when
       while
       with
       lor
       lxor
       mod
       land
       lsl
       lsr
       asr |}
;;