|
0
|
1 "----------------------------------------------------------------------------
|
|
|
2 " Description: Vim Ada syntax file
|
|
|
3 " Language: Ada (2005)
|
|
39
|
4 " $Id: ada.vim 887 2008-07-08 14:29:01Z krischik $
|
|
0
|
5 " Copyright: Copyright (C) 2006 Martin Krischik
|
|
|
6 " Maintainer: Martin Krischik
|
|
|
7 " David A. Wheeler <dwheeler@dwheeler.com>
|
|
|
8 " Simon Bradley <simon.bradley@pitechnology.com>
|
|
|
9 " Contributors: Preben Randhol.
|
|
39
|
10 " $Author: krischik $
|
|
|
11 " $Date: 2008-07-08 16:29:01 +0200 (Di, 08 Jul 2008) $
|
|
9
|
12 " Version: 4.6
|
|
39
|
13 " $Revision: 887 $
|
|
9
|
14 " $HeadURL: https://gnuada.svn.sourceforge.net/svnroot/gnuada/trunk/tools/vim/syntax/ada.vim $
|
|
0
|
15 " http://www.dwheeler.com/vim
|
|
|
16 " History: 24.05.2006 MK Unified Headers
|
|
|
17 " 26.05.2006 MK ' should not be in iskeyword.
|
|
|
18 " 16.07.2006 MK Ada-Mode as vim-ball
|
|
|
19 " 02.10.2006 MK Better folding.
|
|
|
20 " 15.10.2006 MK Bram's suggestion for runtime integration
|
|
|
21 " 05.11.2006 MK Spell check for comments and strings only
|
|
|
22 " 05.11.2006 MK Bram suggested to save on spaces
|
|
|
23 " Help Page: help ft-ada-syntax
|
|
|
24 "------------------------------------------------------------------------------
|
|
|
25 " The formal spec of Ada 2005 (ARM) is the "Ada 2005 Reference Manual".
|
|
|
26 " For more Ada 2005 info, see http://www.gnuada.org and http://www.adapower.com.
|
|
|
27 "
|
|
|
28 " This vim syntax file works on vim 7.0 only and makes use of most of Voim 7.0
|
|
|
29 " advanced features.
|
|
|
30 "------------------------------------------------------------------------------
|
|
|
31
|
|
|
32 if exists("b:current_syntax") || version < 700
|
|
|
33 finish
|
|
|
34 endif
|
|
48
|
35 let s:keepcpo= &cpo
|
|
|
36 set cpo&vim
|
|
0
|
37
|
|
|
38 let b:current_syntax = "ada"
|
|
|
39
|
|
|
40 " Section: Ada is entirely case-insensitive. {{{1
|
|
|
41 "
|
|
|
42 syntax case ignore
|
|
|
43
|
|
|
44 " Section: Highlighting commands {{{1
|
|
|
45 "
|
|
|
46 " There are 72 reserved words in total in Ada2005. Some keywords are
|
|
|
47 " used in more than one way. For example:
|
|
|
48 " 1. "end" is a general keyword, but "end if" ends a Conditional.
|
|
|
49 " 2. "then" is a conditional, but "and then" is an operator.
|
|
|
50 "
|
|
|
51 for b:Item in g:ada#Keywords
|
|
|
52 " Standard Exceptions (including I/O).
|
|
|
53 " We'll highlight the standard exceptions, similar to vim's Python mode.
|
|
|
54 " It's possible to redefine the standard exceptions as something else,
|
|
|
55 " but doing so is very bad practice, so simply highlighting them makes sense.
|
|
|
56 if b:Item['kind'] == "x"
|
|
|
57 execute "syntax keyword adaException " . b:Item['word']
|
|
|
58 endif
|
|
|
59 if b:Item['kind'] == "a"
|
|
|
60 execute 'syntax match adaAttribute "\V' . b:Item['word'] . '"'
|
|
|
61 endif
|
|
|
62 " We don't normally highlight types in package Standard
|
|
|
63 " (Integer, Character, Float, etc.). I don't think it looks good
|
|
|
64 " with the other type keywords, and many Ada programs define
|
|
|
65 " so many of their own types that it looks inconsistent.
|
|
|
66 " However, if you want this highlighting, turn on "ada_standard_types".
|
|
|
67 " For package Standard's definition, see ARM section A.1.
|
|
|
68 if b:Item['kind'] == "t" && exists ("g:ada_standard_types")
|
|
|
69 execute "syntax keyword adaBuiltinType " . b:Item['word']
|
|
|
70 endif
|
|
|
71 endfor
|
|
|
72
|
|
|
73 " Section: others {{{1
|
|
|
74 "
|
|
|
75 syntax keyword adaLabel others
|
|
|
76
|
|
|
77 " Section: Operatoren {{{1
|
|
|
78 "
|
|
|
79 syntax keyword adaOperator abs mod not rem xor
|
|
|
80 syntax match adaOperator "\<and\>"
|
|
|
81 syntax match adaOperator "\<and\s\+then\>"
|
|
|
82 syntax match adaOperator "\<or\>"
|
|
|
83 syntax match adaOperator "\<or\s\+else\>"
|
|
|
84 syntax match adaOperator "[-+*/<>&]"
|
|
|
85 syntax keyword adaOperator **
|
|
|
86 syntax match adaOperator "[/<>]="
|
|
|
87 syntax keyword adaOperator =>
|
|
|
88 syntax match adaOperator "\.\."
|
|
|
89 syntax match adaOperator "="
|
|
|
90
|
|
|
91 " Section: <> {{{1
|
|
|
92 "
|
|
|
93 " Handle the box, <>, specially:
|
|
|
94 "
|
|
|
95 syntax keyword adaSpecial <>
|
|
|
96
|
|
|
97 " Section: rainbow color {{{1
|
|
|
98 "
|
|
|
99 if exists("g:ada_rainbow_color")
|
|
|
100 syntax match adaSpecial "[:;.,]"
|
|
9
|
101 call rainbow_parenthsis#LoadRound ()
|
|
|
102 call rainbow_parenthsis#Activate ()
|
|
0
|
103 else
|
|
|
104 syntax match adaSpecial "[:;().,]"
|
|
|
105 endif
|
|
|
106
|
|
|
107 " Section: := {{{1
|
|
|
108 "
|
|
|
109 " We won't map "adaAssignment" by default, but we need to map ":=" to
|
|
|
110 " something or the "=" inside it will be mislabelled as an operator.
|
|
|
111 " Note that in Ada, assignment (:=) is not considered an operator.
|
|
|
112 "
|
|
|
113 syntax match adaAssignment ":="
|
|
|
114
|
|
|
115 " Section: Numbers, including floating point, exponents, and alternate bases. {{{1
|
|
|
116 "
|
|
|
117 syntax match adaNumber "\<\d[0-9_]*\(\.\d[0-9_]*\)\=\([Ee][+-]\=\d[0-9_]*\)\=\>"
|
|
|
118 syntax match adaNumber "\<\d\d\=#\x[0-9A-Fa-f_]*\(\.\x[0-9A-Fa-f_]*\)\=#\([Ee][+-]\=\d[0-9_]*\)\="
|
|
|
119
|
|
|
120 " Section: Identify leading numeric signs {{{1
|
|
|
121 "
|
|
|
122 " In "A-5" the "-" is an operator, " but in "A:=-5" the "-" is a sign. This
|
|
|
123 " handles "A3+-5" (etc.) correctly. " This assumes that if you put a
|
|
|
124 " don't put a space after +/- when it's used " as an operator, you won't
|
|
|
125 " put a space before it either -- which is true " in code I've seen.
|
|
|
126 "
|
|
|
127 syntax match adaSign "[[:space:]<>=(,|:;&*/+-][+-]\d"lc=1,hs=s+1,he=e-1,me=e-1
|
|
|
128
|
|
|
129 " Section: Labels for the goto statement. {{{1
|
|
|
130 "
|
|
|
131 syntax region adaLabel start="<<" end=">>"
|
|
|
132
|
|
|
133 " Section: Boolean Constants {{{1
|
|
|
134 " Boolean Constants.
|
|
|
135 syntax keyword adaBoolean true false
|
|
|
136
|
|
|
137 " Section: Warn C/C++ {{{1
|
|
|
138 "
|
|
|
139 " Warn people who try to use C/C++ notation erroneously:
|
|
|
140 "
|
|
|
141 syntax match adaError "//"
|
|
|
142 syntax match adaError "/\*"
|
|
|
143 syntax match adaError "=="
|
|
|
144
|
|
|
145
|
|
|
146 " Section: Space Errors {{{1
|
|
|
147 "
|
|
|
148 if exists("g:ada_space_errors")
|
|
|
149 if !exists("g:ada_no_trail_space_error")
|
|
|
150 syntax match adaSpaceError excludenl "\s\+$"
|
|
|
151 endif
|
|
|
152 if !exists("g:ada_no_tab_space_error")
|
|
|
153 syntax match adaSpaceError " \+\t"me=e-1
|
|
|
154 endif
|
|
|
155 if !exists("g:ada_all_tab_usage")
|
|
|
156 syntax match adaSpecial "\t"
|
|
|
157 endif
|
|
|
158 endif
|
|
|
159
|
|
|
160 " Section: end {{{1
|
|
|
161 " Unless special ("end loop", "end if", etc.), "end" marks the end of a
|
|
|
162 " begin, package, task etc. Assiging it to adaEnd.
|
|
9
|
163 syntax match adaEnd /\<end\>/
|
|
0
|
164
|
|
|
165 syntax keyword adaPreproc pragma
|
|
|
166
|
|
|
167 syntax keyword adaRepeat exit for loop reverse while
|
|
|
168 syntax match adaRepeat "\<end\s\+loop\>"
|
|
|
169
|
|
|
170 syntax keyword adaStatement accept delay goto raise requeue return
|
|
|
171 syntax keyword adaStatement terminate
|
|
|
172 syntax match adaStatement "\<abort\>"
|
|
|
173
|
|
|
174 " Section: Handle Ada's record keywords. {{{1
|
|
|
175 "
|
|
|
176 " 'record' usually starts a structure, but "with null record;" does not,
|
|
|
177 " and 'end record;' ends a structure. The ordering here is critical -
|
|
|
178 " 'record;' matches a "with null record", so make it a keyword (this can
|
|
|
179 " match when the 'with' or 'null' is on a previous line).
|
|
|
180 " We see the "end" in "end record" before the word record, so we match that
|
|
|
181 " pattern as adaStructure (and it won't match the "record;" pattern).
|
|
|
182 "
|
|
|
183 syntax match adaStructure "\<record\>" contains=adaRecord
|
|
|
184 syntax match adaStructure "\<end\s\+record\>" contains=adaRecord
|
|
|
185 syntax match adaKeyword "\<record;"me=e-1
|
|
|
186
|
|
|
187 " Section: type classes {{{1
|
|
|
188 "
|
|
|
189 syntax keyword adaStorageClass abstract access aliased array at constant delta
|
|
|
190 syntax keyword adaStorageClass digits limited of private range tagged
|
|
|
191 syntax keyword adaStorageClass interface synchronized
|
|
|
192 syntax keyword adaTypedef subtype type
|
|
|
193
|
|
|
194 " Section: Conditionals {{{1
|
|
|
195 "
|
|
|
196 " "abort" after "then" is a conditional of its own.
|
|
|
197 "
|
|
|
198 syntax match adaConditional "\<then\>"
|
|
|
199 syntax match adaConditional "\<then\s\+abort\>"
|
|
|
200 syntax match adaConditional "\<else\>"
|
|
|
201 syntax match adaConditional "\<end\s\+if\>"
|
|
|
202 syntax match adaConditional "\<end\s\+case\>"
|
|
|
203 syntax match adaConditional "\<end\s\+select\>"
|
|
|
204 syntax keyword adaConditional if case select
|
|
|
205 syntax keyword adaConditional elsif when
|
|
|
206
|
|
|
207 " Section: other keywords {{{1
|
|
|
208 syntax match adaKeyword "\<is\>" contains=adaRecord
|
|
|
209 syntax keyword adaKeyword all do exception in new null out
|
|
|
210 syntax keyword adaKeyword separate until overriding
|
|
|
211
|
|
|
212 " Section: begin keywords {{{1
|
|
|
213 "
|
|
|
214 " These keywords begin various constructs, and you _might_ want to
|
|
|
215 " highlight them differently.
|
|
|
216 "
|
|
|
217 syntax keyword adaBegin begin body declare entry generic
|
|
|
218 syntax keyword adaBegin protected renames task
|
|
|
219
|
|
|
220 syntax match adaBegin "\<function\>" contains=adaFunction
|
|
|
221 syntax match adaBegin "\<procedure\>" contains=adaProcedure
|
|
|
222 syntax match adaBegin "\<package\>" contains=adaPackage
|
|
|
223
|
|
|
224 if exists("ada_with_gnat_project_files")
|
|
|
225 syntax keyword adaBegin project
|
|
|
226 endif
|
|
|
227
|
|
|
228 " Section: with, use {{{1
|
|
|
229 "
|
|
|
230 if exists("ada_withuse_ordinary")
|
|
|
231 " Don't be fancy. Display "with" and "use" as ordinary keywords in all cases.
|
|
|
232 syntax keyword adaKeyword with use
|
|
|
233 else
|
|
|
234 " Highlight "with" and "use" clauses like C's "#include" when they're used
|
|
|
235 " to reference other compilation units; otherwise they're ordinary keywords.
|
|
|
236 " If we have vim 6.0 or later, we'll use its advanced pattern-matching
|
|
|
237 " capabilities so that we won't match leading spaces.
|
|
|
238 syntax match adaKeyword "\<with\>"
|
|
|
239 syntax match adaKeyword "\<use\>"
|
|
|
240 syntax match adaBeginWith "^\s*\zs\(\(with\(\s\+type\)\=\)\|\(use\)\)\>" contains=adaInc
|
|
|
241 syntax match adaSemiWith ";\s*\zs\(\(with\(\s\+type\)\=\)\|\(use\)\)\>" contains=adaInc
|
|
|
242 syntax match adaInc "\<with\>" contained contains=NONE
|
|
|
243 syntax match adaInc "\<with\s\+type\>" contained contains=NONE
|
|
|
244 syntax match adaInc "\<use\>" contained contains=NONE
|
|
|
245 " Recognize "with null record" as a keyword (even the "record").
|
|
|
246 syntax match adaKeyword "\<with\s\+null\s\+record\>"
|
|
|
247 " Consider generic formal parameters of subprograms and packages as keywords.
|
|
|
248 syntax match adaKeyword ";\s*\zswith\s\+\(function\|procedure\|package\)\>"
|
|
|
249 syntax match adaKeyword "^\s*\zswith\s\+\(function\|procedure\|package\)\>"
|
|
|
250 endif
|
|
|
251
|
|
|
252 " Section: String and character constants. {{{1
|
|
|
253 "
|
|
|
254 syntax region adaString contains=@Spell start=+"+ skip=+""+ end=+"+
|
|
|
255 syntax match adaCharacter "'.'"
|
|
|
256
|
|
|
257 " Section: Todo (only highlighted in comments) {{{1
|
|
|
258 "
|
|
|
259 syntax keyword adaTodo contained TODO FIXME XXX NOTE
|
|
|
260
|
|
|
261 " Section: Comments. {{{1
|
|
|
262 "
|
|
|
263 syntax region adaComment
|
|
|
264 \ oneline
|
|
|
265 \ contains=adaTodo,adaLineError,@Spell
|
|
|
266 \ start="--"
|
|
|
267 \ end="$"
|
|
|
268
|
|
|
269 " Section: line errors {{{1
|
|
|
270 "
|
|
|
271 " Note: Line errors have become quite slow with Vim 7.0
|
|
|
272 "
|
|
|
273 if exists("g:ada_line_errors")
|
|
|
274 syntax match adaLineError "\(^.\{79}\)\@<=." contains=ALL containedin=ALL
|
|
|
275 endif
|
|
|
276
|
|
|
277 " Section: syntax folding {{{1
|
|
|
278 "
|
|
|
279 " Syntax folding is very tricky - for now I still suggest to use
|
|
|
280 " indent folding
|
|
|
281 "
|
|
|
282 if exists("g:ada_folding") && g:ada_folding[0] == 's'
|
|
|
283 if stridx (g:ada_folding, 'p') >= 0
|
|
|
284 syntax region adaPackage
|
|
|
285 \ start="\(\<package\s\+body\>\|\<package\>\)\s*\z(\k*\)"
|
|
|
286 \ end="end\s\+\z1\s*;"
|
|
|
287 \ keepend extend transparent fold contains=ALL
|
|
|
288 endif
|
|
|
289 if stridx (g:ada_folding, 'f') >= 0
|
|
|
290 syntax region adaProcedure
|
|
|
291 \ start="\<procedure\>\s*\z(\k*\)"
|
|
|
292 \ end="\<end\>\s\+\z1\s*;"
|
|
|
293 \ keepend extend transparent fold contains=ALL
|
|
|
294 syntax region adaFunction
|
|
|
295 \ start="\<procedure\>\s*\z(\k*\)"
|
|
|
296 \ end="end\s\+\z1\s*;"
|
|
|
297 \ keepend extend transparent fold contains=ALL
|
|
|
298 endif
|
|
|
299 if stridx (g:ada_folding, 'f') >= 0
|
|
|
300 syntax region adaRecord
|
|
|
301 \ start="\<is\s\+record\>"
|
|
|
302 \ end="\<end\s\+record\>"
|
|
|
303 \ keepend extend transparent fold contains=ALL
|
|
|
304 endif
|
|
|
305 endif
|
|
|
306
|
|
|
307 " Section: The default methods for highlighting. Can be overridden later. {{{1
|
|
|
308 "
|
|
|
309 highlight def link adaCharacter Character
|
|
|
310 highlight def link adaComment Comment
|
|
|
311 highlight def link adaConditional Conditional
|
|
|
312 highlight def link adaKeyword Keyword
|
|
|
313 highlight def link adaLabel Label
|
|
|
314 highlight def link adaNumber Number
|
|
|
315 highlight def link adaSign Number
|
|
|
316 highlight def link adaOperator Operator
|
|
|
317 highlight def link adaPreproc PreProc
|
|
|
318 highlight def link adaRepeat Repeat
|
|
|
319 highlight def link adaSpecial Special
|
|
|
320 highlight def link adaStatement Statement
|
|
|
321 highlight def link adaString String
|
|
|
322 highlight def link adaStructure Structure
|
|
|
323 highlight def link adaTodo Todo
|
|
|
324 highlight def link adaType Type
|
|
|
325 highlight def link adaTypedef Typedef
|
|
|
326 highlight def link adaStorageClass StorageClass
|
|
|
327 highlight def link adaBoolean Boolean
|
|
|
328 highlight def link adaException Exception
|
|
|
329 highlight def link adaAttribute Tag
|
|
|
330 highlight def link adaInc Include
|
|
|
331 highlight def link adaError Error
|
|
|
332 highlight def link adaSpaceError Error
|
|
|
333 highlight def link adaLineError Error
|
|
|
334 highlight def link adaBuiltinType Type
|
|
|
335 highlight def link adaAssignment Special
|
|
|
336
|
|
|
337 " Subsection: Begin, End {{{2
|
|
|
338 "
|
|
|
339 if exists ("ada_begin_preproc")
|
|
|
340 " This is the old default display:
|
|
|
341 highlight def link adaBegin PreProc
|
|
|
342 highlight def link adaEnd PreProc
|
|
|
343 else
|
|
|
344 " This is the new default display:
|
|
|
345 highlight def link adaBegin Keyword
|
|
|
346 highlight def link adaEnd Keyword
|
|
|
347 endif
|
|
|
348
|
|
|
349
|
|
|
350
|
|
|
351 " Section: sync {{{1
|
|
|
352 "
|
|
|
353 " We don't need to look backwards to highlight correctly;
|
|
|
354 " this speeds things up greatly.
|
|
|
355 syntax sync minlines=1 maxlines=1
|
|
|
356
|
|
48
|
357 let &cpo = s:keepcpo
|
|
|
358 unlet s:keepcpo
|
|
|
359
|
|
0
|
360 finish " 1}}}
|
|
|
361
|
|
|
362 "------------------------------------------------------------------------------
|
|
|
363 " Copyright (C) 2006 Martin Krischik
|
|
|
364 "
|
|
|
365 " Vim is Charityware - see ":help license" or uganda.txt for licence details.
|
|
|
366 "------------------------------------------------------------------------------
|
|
|
367 "vim: textwidth=78 nowrap tabstop=8 shiftwidth=3 softtabstop=3 noexpandtab
|
|
|
368 "vim: foldmethod=marker
|
