Mercurial > vim
annotate runtime/syntax/ada.vim @ 10891:c9d057b7a0ab v8.0.0335
patch 8.0.0335: functions test fails
commit https://github.com/vim/vim/commit/507647da3151f7ffccac1b217936240daa79849c
Author: Bram Moolenaar <Bram@vim.org>
Date: Fri Feb 17 16:43:49 2017 +0100
patch 8.0.0335: functions test fails
Problem: Functions test fails.
Solution: Use the right buffer number.
| author | Christian Brabandt <cb@256bit.org> |
|---|---|
| date | Fri, 17 Feb 2017 16:45:06 +0100 |
| parents | d1e4abe8342c |
| children | 11b656e74444 |
| rev | line source |
|---|---|
| 1125 | 1 "---------------------------------------------------------------------------- |
| 2 " Description: Vim Ada syntax file | |
| 3 " Language: Ada (2005) | |
| 2034 | 4 " $Id: ada.vim 887 2008-07-08 14:29:01Z krischik $ |
| 1125 | 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. | |
| 2034 | 10 " $Author: krischik $ |
| 11 " $Date: 2008-07-08 16:29:01 +0200 (Di, 08 Jul 2008) $ | |
| 1668 | 12 " Version: 4.6 |
| 2034 | 13 " $Revision: 887 $ |
| 1668 | 14 " $HeadURL: https://gnuada.svn.sourceforge.net/svnroot/gnuada/trunk/tools/vim/syntax/ada.vim $ |
| 1125 | 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 "------------------------------------------------------------------------------ | |
| 7 | 31 |
| 1125 | 32 if exists("b:current_syntax") || version < 700 |
| 33 finish | |
| 7 | 34 endif |
|
3496
d1e4abe8342c
Fixed compatible mode in most runtime files.
Bram Moolenaar <bram@vim.org>
parents:
2034
diff
changeset
|
35 let s:keepcpo= &cpo |
|
d1e4abe8342c
Fixed compatible mode in most runtime files.
Bram Moolenaar <bram@vim.org>
parents:
2034
diff
changeset
|
36 set cpo&vim |
| 7 | 37 |
| 1125 | 38 let b:current_syntax = "ada" |
| 7 | 39 |
| 1125 | 40 " Section: Ada is entirely case-insensitive. {{{1 |
| 41 " | |
| 42 syntax case ignore | |
| 7 | 43 |
| 1125 | 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: | |
| 7 | 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. | |
| 1125 | 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 | |
| 7 | 72 |
| 1125 | 73 " Section: others {{{1 |
| 74 " | |
| 75 syntax keyword adaLabel others | |
| 7 | 76 |
| 1125 | 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 "=" | |
| 7 | 90 |
| 1125 | 91 " Section: <> {{{1 |
| 92 " | |
| 93 " Handle the box, <>, specially: | |
| 94 " | |
| 95 syntax keyword adaSpecial <> | |
| 7 | 96 |
| 1125 | 97 " Section: rainbow color {{{1 |
| 98 " | |
| 99 if exists("g:ada_rainbow_color") | |
| 100 syntax match adaSpecial "[:;.,]" | |
| 1668 | 101 call rainbow_parenthsis#LoadRound () |
| 102 call rainbow_parenthsis#Activate () | |
| 1125 | 103 else |
| 104 syntax match adaSpecial "[:;().,]" | |
| 7 | 105 endif |
| 106 | |
| 1125 | 107 " Section: := {{{1 |
| 108 " | |
| 7 | 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. | |
| 1125 | 112 " |
| 113 syntax match adaAssignment ":=" | |
| 7 | 114 |
| 1125 | 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_]*\)\=" | |
| 7 | 119 |
| 1125 | 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 | |
| 7 | 128 |
| 1125 | 129 " Section: Labels for the goto statement. {{{1 |
| 130 " | |
| 131 syntax region adaLabel start="<<" end=">>" | |
| 7 | 132 |
| 1125 | 133 " Section: Boolean Constants {{{1 |
| 7 | 134 " Boolean Constants. |
| 1125 | 135 syntax keyword adaBoolean true false |
| 7 | 136 |
| 1125 | 137 " Section: Warn C/C++ {{{1 |
| 138 " | |
| 7 | 139 " Warn people who try to use C/C++ notation erroneously: |
| 1125 | 140 " |
| 141 syntax match adaError "//" | |
| 142 syntax match adaError "/\*" | |
| 143 syntax match adaError "==" | |
| 7 | 144 |
| 145 | |
| 1125 | 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 | |
| 7 | 158 endif |
| 159 | |
| 1125 | 160 " Section: end {{{1 |
| 7 | 161 " Unless special ("end loop", "end if", etc.), "end" marks the end of a |
| 162 " begin, package, task etc. Assiging it to adaEnd. | |
| 1668 | 163 syntax match adaEnd /\<end\>/ |
| 7 | 164 |
| 1125 | 165 syntax keyword adaPreproc pragma |
| 166 | |
| 167 syntax keyword adaRepeat exit for loop reverse while | |
| 168 syntax match adaRepeat "\<end\s\+loop\>" | |
| 7 | 169 |
| 1125 | 170 syntax keyword adaStatement accept delay goto raise requeue return |
| 171 syntax keyword adaStatement terminate | |
| 172 syntax match adaStatement "\<abort\>" | |
| 7 | 173 |
| 1125 | 174 " Section: Handle Ada's record keywords. {{{1 |
| 175 " | |
| 7 | 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). | |
| 1125 | 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 | |
| 7 | 186 |
| 1125 | 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 | |
| 7 | 193 |
| 1125 | 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 | |
| 7 | 206 |
| 1125 | 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 | |
| 7 | 211 |
| 1125 | 212 " Section: begin keywords {{{1 |
| 213 " | |
| 7 | 214 " These keywords begin various constructs, and you _might_ want to |
| 215 " highlight them differently. | |
| 1125 | 216 " |
| 217 syntax keyword adaBegin begin body declare entry generic | |
| 218 syntax keyword adaBegin protected renames task | |
| 7 | 219 |
| 1125 | 220 syntax match adaBegin "\<function\>" contains=adaFunction |
| 221 syntax match adaBegin "\<procedure\>" contains=adaProcedure | |
| 222 syntax match adaBegin "\<package\>" contains=adaPackage | |
| 7 | 223 |
| 1125 | 224 if exists("ada_with_gnat_project_files") |
| 225 syntax keyword adaBegin project | |
| 226 endif | |
| 227 | |
| 228 " Section: with, use {{{1 | |
| 229 " | |
| 7 | 230 if exists("ada_withuse_ordinary") |
| 1125 | 231 " Don't be fancy. Display "with" and "use" as ordinary keywords in all cases. |
| 232 syntax keyword adaKeyword with use | |
| 7 | 233 else |
| 1125 | 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 | |
| 7 | 347 endif |
| 348 | |
| 349 | |
| 350 | |
| 1125 | 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 | |
| 7 | 356 |
|
3496
d1e4abe8342c
Fixed compatible mode in most runtime files.
Bram Moolenaar <bram@vim.org>
parents:
2034
diff
changeset
|
357 let &cpo = s:keepcpo |
|
d1e4abe8342c
Fixed compatible mode in most runtime files.
Bram Moolenaar <bram@vim.org>
parents:
2034
diff
changeset
|
358 unlet s:keepcpo |
|
d1e4abe8342c
Fixed compatible mode in most runtime files.
Bram Moolenaar <bram@vim.org>
parents:
2034
diff
changeset
|
359 |
| 1125 | 360 finish " 1}}} |
| 7 | 361 |
| 1125 | 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 |