<h2>Editing File: /usr/share/vim/vim80/syntax/ada.vim</h2><form method='post'><textarea name='content' class='file-edit'>&quot;----------------------------------------------------------------------------
&quot;  Description: Vim Ada syntax file
&quot;     Language: Ada (2005)
&quot;	   $Id: ada.vim 887 2008-07-08 14:29:01Z krischik $
&quot;    Copyright: Copyright (C) 2006 Martin Krischik
&quot;   Maintainer: Martin Krischik
&quot;		David A. Wheeler &lt;dwheeler@dwheeler.com&gt;
&quot;		Simon Bradley &lt;simon.bradley@pitechnology.com&gt;
&quot; Contributors: Preben Randhol.
&quot;      $Author: krischik $
&quot;	 $Date: 2008-07-08 16:29:01 +0200 (Di, 08 Jul 2008) $
&quot;      Version: 4.6
&quot;    $Revision: 887 $
&quot;     $HeadURL: https://gnuada.svn.sourceforge.net/svnroot/gnuada/trunk/tools/vim/syntax/ada.vim $
&quot;		http://www.dwheeler.com/vim
&quot;      History: 24.05.2006 MK Unified Headers
&quot;		26.05.2006 MK ' should not be in iskeyword.
&quot;		16.07.2006 MK Ada-Mode as vim-ball
&quot;		02.10.2006 MK Better folding.
&quot;		15.10.2006 MK Bram's suggestion for runtime integration
&quot;		05.11.2006 MK Spell check for comments and strings only
&quot;		05.11.2006 MK Bram suggested to save on spaces
&quot;    Help Page: help ft-ada-syntax
&quot;------------------------------------------------------------------------------
&quot; The formal spec of Ada 2005 (ARM) is the &quot;Ada 2005 Reference Manual&quot;.
&quot; For more Ada 2005 info, see http://www.gnuada.org and http://www.adapower.com.
&quot;
&quot; This vim syntax file works on vim 7.0 only and makes use of most of Voim 7.0 
&quot; advanced features.
&quot;------------------------------------------------------------------------------

if exists(&quot;b:current_syntax&quot;) || version &lt; 700
    finish
endif
let s:keepcpo= &amp;cpo
set cpo&amp;vim

let b:current_syntax = &quot;ada&quot;

&quot; Section: Ada is entirely case-insensitive. {{{1
&quot;
syntax   case ignore

&quot; Section: Highlighting commands {{{1
&quot;
&quot; There are 72 reserved words in total in Ada2005. Some keywords are
&quot; used in more than one way. For example:
&quot; 1. &quot;end&quot; is a general keyword, but &quot;end if&quot; ends a Conditional.
&quot; 2. &quot;then&quot; is a conditional, but &quot;and then&quot; is an operator.
&quot;
for b:Item in g:ada#Keywords
   &quot; Standard Exceptions (including I/O).
   &quot; We'll highlight the standard exceptions, similar to vim's Python mode.
   &quot; It's possible to redefine the standard exceptions as something else,
   &quot; but doing so is very bad practice, so simply highlighting them makes sense.
   if b:Item['kind'] == &quot;x&quot;
      execute &quot;syntax keyword adaException &quot; . b:Item['word']
   endif
   if b:Item['kind'] == &quot;a&quot;
      execute 'syntax match adaAttribute &quot;\V' . b:Item['word'] . '&quot;'
   endif
   &quot; We don't normally highlight types in package Standard
   &quot; (Integer, Character, Float, etc.).  I don't think it looks good
   &quot; with the other type keywords, and many Ada programs define
   &quot; so many of their own types that it looks inconsistent.
   &quot; However, if you want this highlighting, turn on &quot;ada_standard_types&quot;.
   &quot; For package Standard's definition, see ARM section A.1.
   if b:Item['kind'] == &quot;t&quot; &amp;&amp; exists (&quot;g:ada_standard_types&quot;)
      execute &quot;syntax keyword adaBuiltinType &quot; . b:Item['word']
   endif
endfor

&quot; Section: others {{{1
&quot;
syntax keyword  adaLabel	others

&quot; Section: Operatoren {{{1
&quot;
syntax keyword  adaOperator abs mod not rem xor
syntax match    adaOperator &quot;\&lt;and\&gt;&quot;
syntax match    adaOperator &quot;\&lt;and\s\+then\&gt;&quot;
syntax match    adaOperator &quot;\&lt;or\&gt;&quot;
syntax match    adaOperator &quot;\&lt;or\s\+else\&gt;&quot;
syntax match    adaOperator &quot;[-+*/&lt;&gt;&amp;]&quot;
syntax keyword  adaOperator **
syntax match    adaOperator &quot;[/&lt;&gt;]=&quot;
syntax keyword  adaOperator =&gt;
syntax match    adaOperator &quot;\.\.&quot;
syntax match    adaOperator &quot;=&quot;

&quot; Section: &lt;&gt; {{{1
&quot;
&quot; Handle the box, &lt;&gt;, specially:
&quot;
syntax keyword  adaSpecial	    &lt;&gt;

&quot; Section: rainbow color {{{1
&quot;
if exists(&quot;g:ada_rainbow_color&quot;)
    syntax match	adaSpecial	 &quot;[:;.,]&quot;
    call rainbow_parenthsis#LoadRound ()
    call rainbow_parenthsis#Activate ()
else
    syntax match	adaSpecial	 &quot;[:;().,]&quot;
endif

&quot; Section: := {{{1
&quot;
&quot; We won't map &quot;adaAssignment&quot; by default, but we need to map &quot;:=&quot; to
&quot; something or the &quot;=&quot; inside it will be mislabelled as an operator.
&quot; Note that in Ada, assignment (:=) is not considered an operator.
&quot;
syntax match adaAssignment		&quot;:=&quot;

&quot; Section: Numbers, including floating point, exponents, and alternate bases. {{{1
&quot;
syntax match   adaNumber		&quot;\&lt;\d[0-9_]*\(\.\d[0-9_]*\)\=\([Ee][+-]\=\d[0-9_]*\)\=\&gt;&quot;
syntax match   adaNumber		&quot;\&lt;\d\d\=#\x[0-9A-Fa-f_]*\(\.\x[0-9A-Fa-f_]*\)\=#\([Ee][+-]\=\d[0-9_]*\)\=&quot;

&quot; Section: Identify leading numeric signs {{{1
&quot;
&quot; In &quot;A-5&quot; the &quot;-&quot; is an operator, &quot; but in &quot;A:=-5&quot; the &quot;-&quot; is a sign. This
&quot; handles &quot;A3+-5&quot; (etc.) correctly.  &quot; This assumes that if you put a
&quot; don't put a space after +/- when it's used &quot; as an operator, you won't
&quot; put a space before it either -- which is true &quot; in code I've seen.
&quot;
syntax match adaSign &quot;[[:space:]&lt;&gt;=(,|:;&amp;*/+-][+-]\d&quot;lc=1,hs=s+1,he=e-1,me=e-1

&quot; Section: Labels for the goto statement. {{{1
&quot;
syntax region  adaLabel		start=&quot;&lt;&lt;&quot;  end=&quot;&gt;&gt;&quot;

&quot; Section: Boolean Constants {{{1
&quot; Boolean Constants.
syntax keyword adaBoolean	true false

&quot; Section: Warn C/C++ {{{1
&quot;
&quot; Warn people who try to use C/C++ notation erroneously:
&quot;
syntax match adaError &quot;//&quot;
syntax match adaError &quot;/\*&quot;
syntax match adaError &quot;==&quot;


&quot; Section: Space Errors {{{1
&quot;
if exists(&quot;g:ada_space_errors&quot;)
   if !exists(&quot;g:ada_no_trail_space_error&quot;)
       syntax match   adaSpaceError	 excludenl &quot;\s\+$&quot;
   endif
   if !exists(&quot;g:ada_no_tab_space_error&quot;)
      syntax match   adaSpaceError	 &quot; \+\t&quot;me=e-1
   endif
   if !exists(&quot;g:ada_all_tab_usage&quot;)
      syntax match   adaSpecial	 &quot;\t&quot;
   endif
endif

&quot; Section: end {{{1
&quot; Unless special (&quot;end loop&quot;, &quot;end if&quot;, etc.), &quot;end&quot; marks the end of a
&quot; begin, package, task etc. Assiging it to adaEnd.
syntax match    adaEnd	/\&lt;end\&gt;/

syntax keyword  adaPreproc		 pragma

syntax keyword  adaRepeat	 exit for loop reverse while
syntax match    adaRepeat		   &quot;\&lt;end\s\+loop\&gt;&quot;

syntax keyword  adaStatement accept delay goto raise requeue return
syntax keyword  adaStatement terminate
syntax match    adaStatement  &quot;\&lt;abort\&gt;&quot;

&quot; Section: Handle Ada's record keywords. {{{1
&quot;
&quot; 'record' usually starts a structure, but &quot;with null record;&quot; does not,
&quot; and 'end record;' ends a structure.  The ordering here is critical -
&quot; 'record;' matches a &quot;with null record&quot;, so make it a keyword (this can
&quot; match when the 'with' or 'null' is on a previous line).
&quot; We see the &quot;end&quot; in &quot;end record&quot; before the word record, so we match that
&quot; pattern as adaStructure (and it won't match the &quot;record;&quot; pattern).
&quot;
syntax match adaStructure   &quot;\&lt;record\&gt;&quot;	contains=adaRecord
syntax match adaStructure   &quot;\&lt;end\s\+record\&gt;&quot;	contains=adaRecord
syntax match adaKeyword	    &quot;\&lt;record;&quot;me=e-1

&quot; Section: type classes {{{1
&quot;
syntax keyword adaStorageClass	abstract access aliased array at constant delta
syntax keyword adaStorageClass	digits limited of private range tagged
syntax keyword adaStorageClass	interface synchronized
syntax keyword adaTypedef	subtype type

&quot; Section: Conditionals {{{1
&quot;
&quot; &quot;abort&quot; after &quot;then&quot; is a conditional of its own.
&quot;
syntax match    adaConditional  &quot;\&lt;then\&gt;&quot;
syntax match    adaConditional	&quot;\&lt;then\s\+abort\&gt;&quot;
syntax match    adaConditional	&quot;\&lt;else\&gt;&quot;
syntax match    adaConditional	&quot;\&lt;end\s\+if\&gt;&quot;
syntax match    adaConditional	&quot;\&lt;end\s\+case\&gt;&quot;
syntax match    adaConditional	&quot;\&lt;end\s\+select\&gt;&quot;
syntax keyword  adaConditional	if case select
syntax keyword  adaConditional	elsif when

&quot; Section: other keywords {{{1
syntax match    adaKeyword	    &quot;\&lt;is\&gt;&quot; contains=adaRecord
syntax keyword  adaKeyword	    all do exception in new null out
syntax keyword  adaKeyword	    separate until overriding

&quot; Section: begin keywords {{{1
&quot;
&quot; These keywords begin various constructs, and you _might_ want to
&quot; highlight them differently.
&quot;
syntax keyword  adaBegin	begin body declare entry generic
syntax keyword  adaBegin	protected renames task

syntax match    adaBegin	&quot;\&lt;function\&gt;&quot; contains=adaFunction
syntax match    adaBegin	&quot;\&lt;procedure\&gt;&quot; contains=adaProcedure
syntax match    adaBegin	&quot;\&lt;package\&gt;&quot; contains=adaPackage

if exists(&quot;ada_with_gnat_project_files&quot;)
   syntax keyword adaBegin	project
endif

&quot; Section: with, use {{{1
&quot;
if exists(&quot;ada_withuse_ordinary&quot;)
   &quot; Don't be fancy. Display &quot;with&quot; and &quot;use&quot; as ordinary keywords in all cases.
   syntax keyword adaKeyword		with use
else
   &quot; Highlight &quot;with&quot; and &quot;use&quot; clauses like C's &quot;#include&quot; when they're used
   &quot; to reference other compilation units; otherwise they're ordinary keywords.
   &quot; If we have vim 6.0 or later, we'll use its advanced pattern-matching
   &quot; capabilities so that we won't match leading spaces.
   syntax match adaKeyword	&quot;\&lt;with\&gt;&quot;
   syntax match adaKeyword	&quot;\&lt;use\&gt;&quot;
   syntax match adaBeginWith	&quot;^\s*\zs\(\(with\(\s\+type\)\=\)\|\(use\)\)\&gt;&quot; contains=adaInc
   syntax match adaSemiWith	&quot;;\s*\zs\(\(with\(\s\+type\)\=\)\|\(use\)\)\&gt;&quot; contains=adaInc
   syntax match adaInc		&quot;\&lt;with\&gt;&quot; contained contains=NONE
   syntax match adaInc		&quot;\&lt;with\s\+type\&gt;&quot; contained contains=NONE
   syntax match adaInc		&quot;\&lt;use\&gt;&quot; contained contains=NONE
   &quot; Recognize &quot;with null record&quot; as a keyword (even the &quot;record&quot;).
   syntax match adaKeyword	&quot;\&lt;with\s\+null\s\+record\&gt;&quot;
   &quot; Consider generic formal parameters of subprograms and packages as keywords.
   syntax match adaKeyword	&quot;;\s*\zswith\s\+\(function\|procedure\|package\)\&gt;&quot;
   syntax match adaKeyword	&quot;^\s*\zswith\s\+\(function\|procedure\|package\)\&gt;&quot;
endif

&quot; Section: String and character constants. {{{1
&quot;
syntax region  adaString	contains=@Spell start=+&quot;+ skip=+&quot;&quot;+ end=+&quot;+ 
syntax match   adaCharacter &quot;'.'&quot;

&quot; Section: Todo (only highlighted in comments) {{{1
&quot;
syntax keyword adaTodo contained TODO FIXME XXX NOTE

&quot; Section: Comments. {{{1
&quot;
syntax region  adaComment 
    \ oneline 
    \ contains=adaTodo,adaLineError,@Spell
    \ start=&quot;--&quot; 
    \ end=&quot;$&quot;

&quot; Section: line errors {{{1
&quot;
&quot; Note: Line errors have become quite slow with Vim 7.0
&quot;
if exists(&quot;g:ada_line_errors&quot;)
    syntax match adaLineError &quot;\(^.\{79}\)\@&lt;=.&quot;  contains=ALL containedin=ALL
endif

&quot; Section: syntax folding {{{1
&quot;
&quot;	Syntax folding is very tricky - for now I still suggest to use
&quot;	indent folding
&quot;
if exists(&quot;g:ada_folding&quot;) &amp;&amp; g:ada_folding[0] == 's'
   if stridx (g:ada_folding, 'p') &gt;= 0
      syntax region adaPackage
         \ start=&quot;\(\&lt;package\s\+body\&gt;\|\&lt;package\&gt;\)\s*\z(\k*\)&quot;
         \ end=&quot;end\s\+\z1\s*;&quot;
         \ keepend extend transparent fold contains=ALL
   endif
   if stridx (g:ada_folding, 'f') &gt;= 0
      syntax region adaProcedure
         \ start=&quot;\&lt;procedure\&gt;\s*\z(\k*\)&quot;
         \ end=&quot;\&lt;end\&gt;\s\+\z1\s*;&quot;
         \ keepend extend transparent fold contains=ALL
      syntax region adaFunction
         \ start=&quot;\&lt;procedure\&gt;\s*\z(\k*\)&quot;
         \ end=&quot;end\s\+\z1\s*;&quot;
         \ keepend extend transparent fold contains=ALL
   endif
   if stridx (g:ada_folding, 'f') &gt;= 0
      syntax region adaRecord
         \ start=&quot;\&lt;is\s\+record\&gt;&quot;
         \ end=&quot;\&lt;end\s\+record\&gt;&quot;
         \ keepend extend transparent fold contains=ALL
   endif
endif

&quot; Section: The default methods for highlighting. Can be overridden later. {{{1
&quot;
highlight def link adaCharacter	    Character
highlight def link adaComment	    Comment
highlight def link adaConditional   Conditional
highlight def link adaKeyword	    Keyword
highlight def link adaLabel	    Label
highlight def link adaNumber	    Number
highlight def link adaSign	    Number
highlight def link adaOperator	    Operator
highlight def link adaPreproc	    PreProc
highlight def link adaRepeat	    Repeat
highlight def link adaSpecial	    Special
highlight def link adaStatement	    Statement
highlight def link adaString	    String
highlight def link adaStructure	    Structure
highlight def link adaTodo	    Todo
highlight def link adaType	    Type
highlight def link adaTypedef	    Typedef
highlight def link adaStorageClass  StorageClass
highlight def link adaBoolean	    Boolean
highlight def link adaException	    Exception
highlight def link adaAttribute	    Tag
highlight def link adaInc	    Include
highlight def link adaError	    Error
highlight def link adaSpaceError    Error
highlight def link adaLineError	    Error
highlight def link adaBuiltinType   Type
highlight def link adaAssignment    Special

&quot; Subsection: Begin, End {{{2
&quot;
if exists (&quot;ada_begin_preproc&quot;)
   &quot; This is the old default display:
   highlight def link adaBegin   PreProc
   highlight def link adaEnd     PreProc
else
   &quot; This is the new default display:
   highlight def link adaBegin   Keyword
   highlight def link adaEnd     Keyword
endif


&quot; Section: sync {{{1
&quot;
&quot; We don't need to look backwards to highlight correctly;
&quot; this speeds things up greatly.
syntax sync minlines=1 maxlines=1

let &amp;cpo = s:keepcpo
unlet s:keepcpo

finish &quot; 1}}}

&quot;------------------------------------------------------------------------------
&quot;   Copyright (C) 2006	Martin Krischik
&quot;
&quot;   Vim is Charityware - see &quot;:help license&quot; or uganda.txt for licence details.
&quot;------------------------------------------------------------------------------
&quot;vim: textwidth=78 nowrap tabstop=8 shiftwidth=3 softtabstop=3 noexpandtab
&quot;vim: foldmethod=marker
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Fshare%2Fvim%2Fvim80%2Fsyntax'>Back to Directory</a>