Mercurial > vim
annotate runtime/autoload/ada.vim @ 11993:92a86fe8adc0 v8.0.0877
patch 8.0.0877: using CTRL- CTRL-N in terminal is inconsistent
commit https://github.com/vim/vim/commit/6d8197485dc84532e37aced2c39292bff374200d
Author: Bram Moolenaar <Bram@vim.org>
Date: Sun Aug 6 14:57:49 2017 +0200
patch 8.0.0877: using CTRL-\ CTRL-N in terminal is inconsistent
Problem: Using CTRL-\ CTRL-N in terminal is inconsistent.
Solution: Stay in Normal mode.
| author | Christian Brabandt <cb@256bit.org> |
|---|---|
| date | Sun, 06 Aug 2017 15:00:04 +0200 |
| parents | c391bfbdb452 |
| children | 3b26420fc639 |
| rev | line source |
|---|---|
| 1125 | 1 "------------------------------------------------------------------------------ |
| 2 " Description: Perform Ada specific completion & tagging. | |
| 3 " Language: Ada (2005) | |
| 2034 | 4 " $Id: ada.vim 887 2008-07-08 14:29:01Z krischik $ |
| 10895 | 5 " Maintainer: Mathias Brousset <mathiasb17@gmail.com> |
| 6 " Martin Krischik <krischik@users.sourceforge.net> | |
| 1668 | 7 " Taylor Venable <taylor@metasyntax.net> |
| 1125 | 8 " Neil Bird <neil@fnxweb.com> |
| 1668 | 9 " Ned Okie <nokie@radford.edu> |
| 2034 | 10 " $Author: krischik $ |
| 10895 | 11 " $Date: 2017-01-31 20:20:05 +0200 (Mon, 01 Jan 2017) $ |
| 1668 | 12 " Version: 4.6 |
| 2034 | 13 " $Revision: 887 $ |
| 1668 | 14 " $HeadURL: https://gnuada.svn.sourceforge.net/svnroot/gnuada/trunk/tools/vim/autoload/ada.vim $ |
| 1125 | 15 " History: 24.05.2006 MK Unified Headers |
| 16 " 26.05.2006 MK ' should not be in iskeyword. | |
| 17 " 16.07.2006 MK Ada-Mode as vim-ball | |
| 18 " 02.10.2006 MK Better folding. | |
| 19 " 15.10.2006 MK Bram's suggestion for runtime integration | |
| 20 " 05.11.2006 MK Bram suggested not to use include protection for | |
| 21 " autoload | |
| 22 " 05.11.2006 MK Bram suggested to save on spaces | |
| 1668 | 23 " 08.07.2007 TV fix mapleader problems. |
| 24 " 09.05.2007 MK Session just won't work no matter how much | |
| 25 " tweaking is done | |
| 26 " 19.09.2007 NO still some mapleader problems | |
| 10895 | 27 " 31.01.2017 MB fix more mapleader problems |
| 1125 | 28 " Help Page: ft-ada-functions |
| 29 "------------------------------------------------------------------------------ | |
| 30 | |
| 31 if version < 700 | |
| 32 finish | |
| 33 endif | |
|
3496
d1e4abe8342c
Fixed compatible mode in most runtime files.
Bram Moolenaar <bram@vim.org>
parents:
2034
diff
changeset
|
34 let s:keepcpo= &cpo |
|
d1e4abe8342c
Fixed compatible mode in most runtime files.
Bram Moolenaar <bram@vim.org>
parents:
2034
diff
changeset
|
35 set cpo&vim |
| 1125 | 36 |
| 37 " Section: Constants {{{1 | |
| 38 " | |
| 39 let g:ada#DotWordRegex = '\a\w*\(\_s*\.\_s*\a\w*\)*' | |
| 40 let g:ada#WordRegex = '\a\w*' | |
| 41 let g:ada#Comment = "\\v^(\"[^\"]*\"|'.'|[^\"']){-}\\zs\\s*--.*" | |
| 42 let g:ada#Keywords = [] | |
| 43 | |
| 44 " Section: g:ada#Keywords {{{1 | |
| 45 " | |
| 46 " Section: add Ada keywords {{{2 | |
| 47 " | |
| 48 for Item in ['abort', 'else', 'new', 'return', 'abs', 'elsif', 'not', 'reverse', 'abstract', 'end', 'null', 'accept', 'entry', 'select', 'access', 'exception', 'of', 'separate', 'aliased', 'exit', 'or', 'subtype', 'all', 'others', 'synchronized', 'and', 'for', 'out', 'array', 'function', 'overriding', 'tagged', 'at', 'task', 'generic', 'package', 'terminate', 'begin', 'goto', 'pragma', 'then', 'body', 'private', 'type', 'if', 'procedure', 'case', 'in', 'protected', 'until', 'constant', 'interface', 'use', 'is', 'raise', 'declare', 'range', 'when', 'delay', 'limited', 'record', 'while', 'delta', 'loop', 'rem', 'with', 'digits', 'renames', 'do', 'mod', 'requeue', 'xor'] | |
| 49 let g:ada#Keywords += [{ | |
| 50 \ 'word': Item, | |
| 51 \ 'menu': 'keyword', | |
| 52 \ 'info': 'Ada keyword.', | |
| 53 \ 'kind': 'k', | |
| 54 \ 'icase': 1}] | |
| 55 endfor | |
| 56 | |
| 57 " Section: GNAT Project Files {{{3 | |
| 58 " | |
| 59 if exists ('g:ada_with_gnat_project_files') | |
| 60 for Item in ['project'] | |
| 61 let g:ada#Keywords += [{ | |
| 62 \ 'word': Item, | |
| 63 \ 'menu': 'keyword', | |
| 64 \ 'info': 'GNAT projectfile keyword.', | |
| 65 \ 'kind': 'k', | |
| 66 \ 'icase': 1}] | |
| 67 endfor | |
| 68 endif | |
| 69 | |
| 70 " Section: add standart exception {{{2 | |
| 71 " | |
| 72 for Item in ['Constraint_Error', 'Program_Error', 'Storage_Error', 'Tasking_Error', 'Status_Error', 'Mode_Error', 'Name_Error', 'Use_Error', 'Device_Error', 'End_Error', 'Data_Error', 'Layout_Error', 'Length_Error', 'Pattern_Error', 'Index_Error', 'Translation_Error', 'Time_Error', 'Argument_Error', 'Tag_Error', 'Picture_Error', 'Terminator_Error', 'Conversion_Error', 'Pointer_Error', 'Dereference_Error', 'Update_Error'] | |
| 73 let g:ada#Keywords += [{ | |
| 74 \ 'word': Item, | |
| 75 \ 'menu': 'exception', | |
| 76 \ 'info': 'Ada standart exception.', | |
| 77 \ 'kind': 'x', | |
| 78 \ 'icase': 1}] | |
| 79 endfor | |
| 80 | |
| 81 " Section: add GNAT exception {{{3 | |
| 82 " | |
| 83 if exists ('g:ada_gnat_extensions') | |
| 84 for Item in ['Assert_Failure'] | |
| 85 let g:ada#Keywords += [{ | |
| 86 \ 'word': Item, | |
| 87 \ 'menu': 'exception', | |
| 88 \ 'info': 'GNAT exception.', | |
| 89 \ 'kind': 'x', | |
| 90 \ 'icase': 1}] | |
| 91 endfor | |
| 92 endif | |
| 93 | |
| 94 " Section: add Ada buildin types {{{2 | |
| 95 " | |
| 96 for Item in ['Boolean', 'Integer', 'Natural', 'Positive', 'Float', 'Character', 'Wide_Character', 'Wide_Wide_Character', 'String', 'Wide_String', 'Wide_Wide_String', 'Duration'] | |
| 97 let g:ada#Keywords += [{ | |
| 98 \ 'word': Item, | |
| 99 \ 'menu': 'type', | |
| 100 \ 'info': 'Ada buildin type.', | |
| 101 \ 'kind': 't', | |
| 102 \ 'icase': 1}] | |
| 103 endfor | |
| 104 | |
| 105 " Section: add GNAT buildin types {{{3 | |
| 106 " | |
| 107 if exists ('g:ada_gnat_extensions') | |
| 108 for Item in ['Short_Integer', 'Short_Short_Integer', 'Long_Integer', 'Long_Long_Integer', 'Short_Float', 'Short_Short_Float', 'Long_Float', 'Long_Long_Float'] | |
| 109 let g:ada#Keywords += [{ | |
| 110 \ 'word': Item, | |
| 111 \ 'menu': 'type', | |
| 112 \ 'info': 'GNAT buildin type.', | |
| 113 \ 'kind': 't', | |
| 114 \ 'icase': 1}] | |
| 115 endfor | |
| 116 endif | |
| 117 | |
| 118 " Section: add Ada Attributes {{{2 | |
| 119 " | |
| 120 for Item in ['''Access', '''Address', '''Adjacent', '''Aft', '''Alignment', '''Base', '''Bit_Order', '''Body_Version', '''Callable', '''Caller', '''Ceiling', '''Class', '''Component_Size', '''Compose', '''Constrained', '''Copy_Sign', '''Count', '''Definite', '''Delta', '''Denorm', '''Digits', '''Emax', '''Exponent', '''External_Tag', '''Epsilon', '''First', '''First_Bit', '''Floor', '''Fore', '''Fraction', '''Identity', '''Image', '''Input', '''Large', '''Last', '''Last_Bit', '''Leading_Part', '''Length', '''Machine', '''Machine_Emax', '''Machine_Emin', '''Machine_Mantissa', '''Machine_Overflows', '''Machine_Radix', '''Machine_Rounding', '''Machine_Rounds', '''Mantissa', '''Max', '''Max_Size_In_Storage_Elements', '''Min', '''Mod', '''Model', '''Model_Emin', '''Model_Epsilon', '''Model_Mantissa', '''Model_Small', '''Modulus', '''Output', '''Partition_ID', '''Pos', '''Position', '''Pred', '''Priority', '''Range', '''Read', '''Remainder', '''Round', '''Rounding', '''Safe_Emax', '''Safe_First', '''Safe_Large', '''Safe_Last', '''Safe_Small', '''Scale', '''Scaling', '''Signed_Zeros', '''Size', '''Small', '''Storage_Pool', '''Storage_Size', '''Stream_Size', '''Succ', '''Tag', '''Terminated', '''Truncation', '''Unbiased_Rounding', '''Unchecked_Access', '''Val', '''Valid', '''Value', '''Version', '''Wide_Image', '''Wide_Value', '''Wide_Wide_Image', '''Wide_Wide_Value', '''Wide_Wide_Width', '''Wide_Width', '''Width', '''Write'] | |
| 121 let g:ada#Keywords += [{ | |
| 122 \ 'word': Item, | |
| 123 \ 'menu': 'attribute', | |
| 124 \ 'info': 'Ada attribute.', | |
| 125 \ 'kind': 'a', | |
| 126 \ 'icase': 1}] | |
| 127 endfor | |
| 128 | |
| 129 " Section: add GNAT Attributes {{{3 | |
| 130 " | |
| 131 if exists ('g:ada_gnat_extensions') | |
| 132 for Item in ['''Abort_Signal', '''Address_Size', '''Asm_Input', '''Asm_Output', '''AST_Entry', '''Bit', '''Bit_Position', '''Code_Address', '''Default_Bit_Order', '''Elaborated', '''Elab_Body', '''Elab_Spec', '''Emax', '''Enum_Rep', '''Epsilon', '''Fixed_Value', '''Has_Access_Values', '''Has_Discriminants', '''Img', '''Integer_Value', '''Machine_Size', '''Max_Interrupt_Priority', '''Max_Priority', '''Maximum_Alignment', '''Mechanism_Code', '''Null_Parameter', '''Object_Size', '''Passed_By_Reference', '''Range_Length', '''Storage_Unit', '''Target_Name', '''Tick', '''To_Address', '''Type_Class', '''UET_Address', '''Unconstrained_Array', '''Universal_Literal_String', '''Unrestricted_Access', '''VADS_Size', '''Value_Size', '''Wchar_T_Size', '''Word_Size'] | |
| 133 let g:ada#Keywords += [{ | |
| 134 \ 'word': Item, | |
| 135 \ 'menu': 'attribute', | |
| 136 \ 'info': 'GNAT attribute.', | |
| 137 \ 'kind': 'a', | |
| 138 \ 'icase': 1}] | |
| 139 endfor | |
| 140 endif | |
| 141 | |
| 142 " Section: add Ada Pragmas {{{2 | |
| 143 " | |
| 144 for Item in ['All_Calls_Remote', 'Assert', 'Assertion_Policy', 'Asynchronous', 'Atomic', 'Atomic_Components', 'Attach_Handler', 'Controlled', 'Convention', 'Detect_Blocking', 'Discard_Names', 'Elaborate', 'Elaborate_All', 'Elaborate_Body', 'Export', 'Import', 'Inline', 'Inspection_Point', 'Interface (Obsolescent)', 'Interrupt_Handler', 'Interrupt_Priority', 'Linker_Options', 'List', 'Locking_Policy', 'Memory_Size (Obsolescent)', 'No_Return', 'Normalize_Scalars', 'Optimize', 'Pack', 'Page', 'Partition_Elaboration_Policy', 'Preelaborable_Initialization', 'Preelaborate', 'Priority', 'Priority_Specific_Dispatching', 'Profile', 'Pure', 'Queueing_Policy', 'Relative_Deadline', 'Remote_Call_Interface', 'Remote_Types', 'Restrictions', 'Reviewable', 'Shared (Obsolescent)', 'Shared_Passive', 'Storage_Size', 'Storage_Unit (Obsolescent)', 'Suppress', 'System_Name (Obsolescent)', 'Task_Dispatching_Policy', 'Unchecked_Union', 'Unsuppress', 'Volatile', 'Volatile_Components'] | |
| 145 let g:ada#Keywords += [{ | |
| 146 \ 'word': Item, | |
| 147 \ 'menu': 'pragma', | |
| 148 \ 'info': 'Ada pragma.', | |
| 149 \ 'kind': 'p', | |
| 150 \ 'icase': 1}] | |
| 151 endfor | |
| 152 | |
| 153 " Section: add GNAT Pragmas {{{3 | |
| 154 " | |
| 155 if exists ('g:ada_gnat_extensions') | |
| 156 for Item in ['Abort_Defer', 'Ada_83', 'Ada_95', 'Ada_05', 'Annotate', 'Ast_Entry', 'C_Pass_By_Copy', 'Comment', 'Common_Object', 'Compile_Time_Warning', 'Complex_Representation', 'Component_Alignment', 'Convention_Identifier', 'CPP_Class', 'CPP_Constructor', 'CPP_Virtual', 'CPP_Vtable', 'Debug', 'Elaboration_Checks', 'Eliminate', 'Export_Exception', 'Export_Function', 'Export_Object', 'Export_Procedure', 'Export_Value', 'Export_Valued_Procedure', 'Extend_System', 'External', 'External_Name_Casing', 'Finalize_Storage_Only', 'Float_Representation', 'Ident', 'Import_Exception', 'Import_Function', 'Import_Object', 'Import_Procedure', 'Import_Valued_Procedure', 'Initialize_Scalars', 'Inline_Always', 'Inline_Generic', 'Interface_Name', 'Interrupt_State', 'Keep_Names', 'License', 'Link_With', 'Linker_Alias', 'Linker_Section', 'Long_Float', 'Machine_Attribute', 'Main_Storage', 'Obsolescent', 'Passive', 'Polling', 'Profile_Warnings', 'Propagate_Exceptions', 'Psect_Object', 'Pure_Function', 'Restriction_Warnings', 'Source_File_Name', 'Source_File_Name_Project', 'Source_Reference', 'Stream_Convert', 'Style_Checks', 'Subtitle', 'Suppress_All', 'Suppress_Exception_Locations', 'Suppress_Initialization', 'Task_Info', 'Task_Name', 'Task_Storage', 'Thread_Body', 'Time_Slice', 'Title', 'Unimplemented_Unit', 'Universal_Data', 'Unreferenced', 'Unreserve_All_Interrupts', 'Use_VADS_Size', 'Validity_Checks', 'Warnings', 'Weak_External'] | |
| 157 let g:ada#Keywords += [{ | |
| 158 \ 'word': Item, | |
| 159 \ 'menu': 'pragma', | |
| 160 \ 'info': 'GNAT pragma.', | |
| 161 \ 'kind': 'p', | |
| 162 \ 'icase': 1}] | |
| 163 endfor | |
| 164 endif | |
| 165 " 1}}} | |
| 166 | |
| 167 " Section: g:ada#Ctags_Kinds {{{1 | |
| 168 " | |
| 169 let g:ada#Ctags_Kinds = { | |
| 170 \ 'P': ["packspec", "package specifications"], | |
| 171 \ 'p': ["package", "packages"], | |
| 172 \ 'T': ["typespec", "type specifications"], | |
| 173 \ 't': ["type", "types"], | |
| 174 \ 'U': ["subspec", "subtype specifications"], | |
| 175 \ 'u': ["subtype", "subtypes"], | |
| 176 \ 'c': ["component", "record type components"], | |
| 177 \ 'l': ["literal", "enum type literals"], | |
| 178 \ 'V': ["varspec", "variable specifications"], | |
| 179 \ 'v': ["variable", "variables"], | |
| 180 \ 'f': ["formal", "generic formal parameters"], | |
| 181 \ 'n': ["constant", "constants"], | |
| 182 \ 'x': ["exception", "user defined exceptions"], | |
| 183 \ 'R': ["subprogspec", "subprogram specifications"], | |
| 184 \ 'r': ["subprogram", "subprograms"], | |
| 185 \ 'K': ["taskspec", "task specifications"], | |
| 186 \ 'k': ["task", "tasks"], | |
| 187 \ 'O': ["protectspec", "protected data specifications"], | |
| 188 \ 'o': ["protected", "protected data"], | |
| 189 \ 'E': ["entryspec", "task/protected data entry specifications"], | |
| 190 \ 'e': ["entry", "task/protected data entries"], | |
| 191 \ 'b': ["label", "labels"], | |
| 192 \ 'i': ["identifier", "loop/declare identifiers"], | |
| 193 \ 'a': ["autovar", "automatic variables"], | |
| 194 \ 'y': ["annon", "loops and blocks with no identifier"]} | |
| 195 | |
| 196 " Section: ada#Word (...) {{{1 | |
| 197 " | |
| 198 " Extract current Ada word across multiple lines | |
| 199 " AdaWord ([line, column])\ | |
| 200 " | |
| 201 function ada#Word (...) | |
| 202 if a:0 > 1 | |
| 203 let l:Line_Nr = a:1 | |
| 204 let l:Column_Nr = a:2 - 1 | |
| 205 else | |
| 206 let l:Line_Nr = line('.') | |
| 207 let l:Column_Nr = col('.') - 1 | |
| 208 endif | |
| 209 | |
| 210 let l:Line = substitute (getline (l:Line_Nr), g:ada#Comment, '', '' ) | |
| 211 | |
| 212 " Cope with tag searching for items in comments; if we are, don't loop | |
| 213 " backards looking for previous lines | |
| 214 if l:Column_Nr > strlen(l:Line) | |
| 215 " We were in a comment | |
| 216 let l:Line = getline(l:Line_Nr) | |
| 217 let l:Search_Prev_Lines = 0 | |
| 218 else | |
| 219 let l:Search_Prev_Lines = 1 | |
| 220 endif | |
| 221 | |
| 222 " Go backwards until we find a match (Ada ID) that *doesn't* include our | |
| 223 " location - i.e., the previous ID. This is because the current 'correct' | |
| 224 " match will toggle matching/not matching as we traverse characters | |
| 225 " backwards. Thus, we have to find the previous unrelated match, exclude | |
| 226 " it, then use the next full match (ours). | |
| 227 " Remember to convert vim column 'l:Column_Nr' [1..n] to string offset [0..(n-1)] | |
| 228 " ... but start, here, one after the required char. | |
| 229 let l:New_Column = l:Column_Nr + 1 | |
| 230 while 1 | |
| 231 let l:New_Column = l:New_Column - 1 | |
| 232 if l:New_Column < 0 | |
| 233 " Have to include previous l:Line from file | |
| 234 let l:Line_Nr = l:Line_Nr - 1 | |
| 235 if l:Line_Nr < 1 || !l:Search_Prev_Lines | |
| 236 " Start of file or matching in a comment | |
| 237 let l:Line_Nr = 1 | |
| 238 let l:New_Column = 0 | |
| 239 let l:Our_Match = match (l:Line, g:ada#WordRegex ) | |
| 240 break | |
| 241 endif | |
| 242 " Get previous l:Line, and prepend it to our search string | |
| 243 let l:New_Line = substitute (getline (l:Line_Nr), g:ada#Comment, '', '' ) | |
| 244 let l:New_Column = strlen (l:New_Line) - 1 | |
| 245 let l:Column_Nr = l:Column_Nr + l:New_Column | |
| 246 let l:Line = l:New_Line . l:Line | |
| 247 endif | |
| 248 " Check to see if this is a match excluding 'us' | |
| 249 let l:Match_End = l:New_Column + | |
| 250 \ matchend (strpart (l:Line,l:New_Column), g:ada#WordRegex ) - 1 | |
| 251 if l:Match_End >= l:New_Column && | |
| 252 \ l:Match_End < l:Column_Nr | |
| 253 " Yes | |
| 254 let l:Our_Match = l:Match_End+1 + | |
| 255 \ match (strpart (l:Line,l:Match_End+1), g:ada#WordRegex ) | |
| 256 break | |
| 257 endif | |
| 258 endwhile | |
| 259 | |
| 260 " Got anything? | |
| 261 if l:Our_Match < 0 | |
| 262 return '' | |
| 263 else | |
| 264 let l:Line = strpart (l:Line, l:Our_Match) | |
| 265 endif | |
| 266 | |
| 267 " Now simply add further lines until the match gets no bigger | |
| 268 let l:Match_String = matchstr (l:Line, g:ada#WordRegex) | |
| 269 let l:Last_Line = line ('$') | |
| 270 let l:Line_Nr = line ('.') + 1 | |
| 271 while l:Line_Nr <= l:Last_Line | |
| 272 let l:Last_Match = l:Match_String | |
| 273 let l:Line = l:Line . | |
| 274 \ substitute (getline (l:Line_Nr), g:ada#Comment, '', '') | |
| 275 let l:Match_String = matchstr (l:Line, g:ada#WordRegex) | |
| 276 if l:Match_String == l:Last_Match | |
| 277 break | |
| 278 endif | |
| 279 endwhile | |
| 280 | |
| 281 " Strip whitespace & return | |
| 282 return substitute (l:Match_String, '\s\+', '', 'g') | |
| 283 endfunction ada#Word | |
| 284 | |
| 285 " Section: ada#List_Tag (...) {{{1 | |
| 286 " | |
| 287 " List tags in quickfix window | |
| 288 " | |
| 289 function ada#List_Tag (...) | |
| 290 if a:0 > 1 | |
| 291 let l:Tag_Word = ada#Word (a:1, a:2) | |
| 292 elseif a:0 > 0 | |
| 293 let l:Tag_Word = a:1 | |
| 294 else | |
| 295 let l:Tag_Word = ada#Word () | |
| 296 endif | |
| 297 | |
| 298 echo "Searching for" l:Tag_Word | |
| 299 | |
| 300 let l:Pattern = '^' . l:Tag_Word . '$' | |
| 301 let l:Tag_List = taglist (l:Pattern) | |
| 302 let l:Error_List = [] | |
| 303 " | |
| 304 " add symbols | |
| 305 " | |
| 306 for Tag_Item in l:Tag_List | |
| 307 if l:Tag_Item['kind'] == '' | |
| 308 let l:Tag_Item['kind'] = 's' | |
| 309 endif | |
| 310 | |
| 311 let l:Error_List += [ | |
| 312 \ l:Tag_Item['filename'] . '|' . | |
| 313 \ l:Tag_Item['cmd'] . '|' . | |
| 314 \ l:Tag_Item['kind'] . "\t" . | |
| 315 \ l:Tag_Item['name'] ] | |
| 316 endfor | |
| 317 set errorformat=%f\|%l\|%m | |
| 318 cexpr l:Error_List | |
| 319 cwindow | |
| 320 endfunction ada#List_Tag | |
| 321 | |
| 322 " Section: ada#Jump_Tag (Word, Mode) {{{1 | |
| 323 " | |
| 324 " Word tag - include '.' and if Ada make uppercase | |
| 325 " | |
| 326 function ada#Jump_Tag (Word, Mode) | |
| 327 if a:Word == '' | |
| 328 " Get current word | |
| 329 let l:Word = ada#Word() | |
| 330 if l:Word == '' | |
| 331 throw "NOT_FOUND: no identifier found." | |
| 332 endif | |
| 333 else | |
| 334 let l:Word = a:Word | |
| 335 endif | |
| 336 | |
| 337 echo "Searching for " . l:Word | |
| 338 | |
| 339 try | |
| 340 execute a:Mode l:Word | |
| 341 catch /.*:E426:.*/ | |
| 342 let ignorecase = &ignorecase | |
| 343 set ignorecase | |
| 344 execute a:Mode l:Word | |
| 345 let &ignorecase = ignorecase | |
| 346 endtry | |
| 347 | |
| 348 return | |
| 349 endfunction ada#Jump_Tag | |
| 350 | |
| 351 " Section: ada#Insert_Backspace () {{{1 | |
| 352 " | |
| 353 " Backspace at end of line after auto-inserted commentstring '-- ' wipes it | |
| 354 " | |
| 355 function ada#Insert_Backspace () | |
| 356 let l:Line = getline ('.') | |
| 357 if col ('.') > strlen (l:Line) && | |
| 358 \ match (l:Line, '-- $') != -1 && | |
| 359 \ match (&comments,'--') != -1 | |
| 360 return "\<bs>\<bs>\<bs>" | |
| 361 else | |
| 362 return "\<bs>" | |
| 363 endif | |
| 364 | |
| 365 return | |
| 366 endfunction ada#InsertBackspace | |
| 367 | |
| 368 " Section: Insert Completions {{{1 | |
| 369 " | |
| 370 " Section: ada#User_Complete(findstart, base) {{{2 | |
| 371 " | |
| 372 " This function is used for the 'complete' option. | |
| 373 " | |
| 374 function! ada#User_Complete(findstart, base) | |
| 375 if a:findstart == 1 | |
| 376 " | |
| 377 " locate the start of the word | |
| 378 " | |
| 379 let line = getline ('.') | |
| 380 let start = col ('.') - 1 | |
| 381 while start > 0 && line[start - 1] =~ '\i\|''' | |
| 382 let start -= 1 | |
| 383 endwhile | |
| 384 return start | |
| 385 else | |
| 386 " | |
| 387 " look up matches | |
| 388 " | |
| 389 let l:Pattern = '^' . a:base . '.*$' | |
| 390 " | |
| 391 " add keywords | |
| 392 " | |
| 393 for Tag_Item in g:ada#Keywords | |
| 394 if l:Tag_Item['word'] =~? l:Pattern | |
| 395 if complete_add (l:Tag_Item) == 0 | |
| 396 return [] | |
| 397 endif | |
| 398 if complete_check () | |
| 399 return [] | |
| 400 endif | |
| 401 endif | |
| 402 endfor | |
| 403 return [] | |
| 404 endif | |
| 405 endfunction ada#User_Complete | |
| 406 | |
| 407 " Section: ada#Completion (cmd) {{{2 | |
| 408 " | |
| 409 " Word completion (^N/^R/^X^]) - force '.' inclusion | |
| 410 function ada#Completion (cmd) | |
| 411 set iskeyword+=46 | |
| 412 return a:cmd . "\<C-R>=ada#Completion_End ()\<CR>" | |
| 413 endfunction ada#Completion | |
| 414 | |
| 415 " Section: ada#Completion_End () {{{2 | |
| 416 " | |
| 417 function ada#Completion_End () | |
| 418 set iskeyword-=46 | |
| 419 return '' | |
| 420 endfunction ada#Completion_End | |
| 421 | |
| 422 " Section: ada#Create_Tags {{{1 | |
| 423 " | |
| 424 function ada#Create_Tags (option) | |
| 425 if a:option == 'file' | |
| 426 let l:Filename = fnamemodify (bufname ('%'), ':p') | |
| 427 elseif a:option == 'dir' | |
| 428 let l:Filename = | |
| 429 \ fnamemodify (bufname ('%'), ':p:h') . "*.ada " . | |
| 430 \ fnamemodify (bufname ('%'), ':p:h') . "*.adb " . | |
| 431 \ fnamemodify (bufname ('%'), ':p:h') . "*.ads" | |
| 432 else | |
| 433 let l:Filename = a:option | |
| 434 endif | |
| 435 execute '!ctags --excmd=number ' . l:Filename | |
| 436 endfunction ada#Create_Tags | |
| 437 | |
| 1668 | 438 " Section: ada#Switch_Session {{{1 |
| 439 " | |
| 440 function ada#Switch_Session (New_Session) | |
| 441 " | |
| 442 " you should not save to much date into the seession since they will | |
| 443 " be sourced | |
| 444 " | |
| 445 let l:sessionoptions=&sessionoptions | |
| 446 | |
| 447 try | |
| 448 set sessionoptions=buffers,curdir,folds,globals,resize,slash,tabpages,tabpages,unix,winpos,winsize | |
| 1125 | 449 |
| 1668 | 450 if a:New_Session != v:this_session |
| 451 " | |
| 10895 | 452 " We actually got a new session - otherwise there |
| 1668 | 453 " is nothing to do. |
| 454 " | |
| 455 if strlen (v:this_session) > 0 | |
| 456 execute 'mksession! ' . v:this_session | |
| 457 endif | |
| 1125 | 458 |
| 1668 | 459 let v:this_session = a:New_Session |
| 1125 | 460 |
| 1668 | 461 "if filereadable (v:this_session) |
| 462 "execute 'source ' . v:this_session | |
| 463 "endif | |
| 464 | |
| 465 augroup ada_session | |
| 466 autocmd! | |
| 467 autocmd VimLeavePre * execute 'mksession! ' . v:this_session | |
| 468 augroup END | |
| 469 | |
| 470 "if exists ("g:Tlist_Auto_Open") && g:Tlist_Auto_Open | |
| 471 "TlistOpen | |
| 472 "endif | |
| 473 | |
| 474 endif | |
| 475 finally | |
| 476 let &sessionoptions=l:sessionoptions | |
| 477 endtry | |
| 1125 | 478 |
| 479 return | |
| 1668 | 480 endfunction ada#Switch_Session |
| 1125 | 481 |
| 482 " Section: GNAT Pretty Printer folding {{{1 | |
| 483 " | |
| 484 if exists('g:ada_folding') && g:ada_folding[0] == 'g' | |
| 485 " | |
| 486 " Lines consisting only of ')' ';' are due to a gnat pretty bug and | |
| 487 " have the same level as the line above (can't happen in the first | |
| 488 " line). | |
| 489 " | |
| 490 let s:Fold_Collate = '^\([;)]*$\|' | |
| 491 | |
| 492 " | |
| 493 " some lone statements are folded with the line above | |
| 494 " | |
| 495 if stridx (g:ada_folding, 'i') >= 0 | |
| 496 let s:Fold_Collate .= '\s\+\<is\>$\|' | |
| 497 endif | |
| 498 if stridx (g:ada_folding, 'b') >= 0 | |
| 499 let s:Fold_Collate .= '\s\+\<begin\>$\|' | |
| 500 endif | |
| 501 if stridx (g:ada_folding, 'p') >= 0 | |
| 502 let s:Fold_Collate .= '\s\+\<private\>$\|' | |
| 503 endif | |
| 504 if stridx (g:ada_folding, 'x') >= 0 | |
| 505 let s:Fold_Collate .= '\s\+\<exception\>$\|' | |
| 506 endif | |
| 507 | |
| 508 " We also handle empty lines and | |
| 509 " comments here. | |
| 510 let s:Fold_Collate .= '--\)' | |
| 511 | |
| 512 function ada#Pretty_Print_Folding (Line) " {{{2 | |
| 513 let l:Text = getline (a:Line) | |
| 514 | |
| 515 if l:Text =~ s:Fold_Collate | |
| 516 " | |
| 517 " fold with line above | |
| 518 " | |
| 519 let l:Level = "=" | |
| 520 elseif l:Text =~ '^\s\+(' | |
| 521 " | |
| 522 " gnat outdents a line which stards with a ( by one characters so | |
| 523 " that parameters which follow are aligned. | |
| 524 " | |
| 525 let l:Level = (indent (a:Line) + 1) / &shiftwidth | |
| 526 else | |
| 527 let l:Level = indent (a:Line) / &shiftwidth | |
| 528 endif | |
| 529 | |
| 530 return l:Level | |
| 531 endfunction ada#Pretty_Print_Folding " }}}2 | |
| 532 endif | |
| 533 | |
| 534 " Section: Options and Menus {{{1 | |
| 535 " | |
| 536 " Section: ada#Switch_Syntax_Options {{{2 | |
| 537 " | |
| 538 function ada#Switch_Syntax_Option (option) | |
| 539 syntax off | |
| 540 if exists ('g:ada_' . a:option) | |
| 541 unlet g:ada_{a:option} | |
| 542 echo a:option . 'now off' | |
| 543 else | |
| 544 let g:ada_{a:option}=1 | |
| 545 echo a:option . 'now on' | |
| 546 endif | |
| 547 syntax on | |
| 548 endfunction ada#Switch_Syntax_Option | |
| 549 | |
| 550 " Section: ada#Map_Menu {{{2 | |
| 551 " | |
| 552 function ada#Map_Menu (Text, Keys, Command) | |
| 553 if a:Keys[0] == ':' | |
| 554 execute | |
| 555 \ "50amenu " . | |
| 556 \ "Ada." . escape(a:Text, ' ') . | |
| 557 \ "<Tab>" . a:Keys . | |
| 558 \ " :" . a:Command . "<CR>" | |
| 559 execute | |
| 560 \ "command -buffer " . | |
| 561 \ a:Keys[1:] . | |
| 562 \" :" . a:Command . "<CR>" | |
| 563 elseif a:Keys[0] == '<' | |
| 564 execute | |
| 565 \ "50amenu " . | |
| 566 \ "Ada." . escape(a:Text, ' ') . | |
| 567 \ "<Tab>" . a:Keys . | |
| 568 \ " :" . a:Command . "<CR>" | |
| 569 execute | |
| 570 \ "nnoremap <buffer> " . | |
| 571 \ a:Keys . | |
| 572 \" :" . a:Command . "<CR>" | |
| 573 execute | |
| 574 \ "inoremap <buffer> " . | |
| 575 \ a:Keys . | |
| 576 \" <C-O>:" . a:Command . "<CR>" | |
| 577 else | |
| 1668 | 578 if exists("g:mapleader") |
| 579 let l:leader = g:mapleader | |
| 580 else | |
| 581 let l:leader = '\' | |
| 582 endif | |
| 1125 | 583 execute |
| 584 \ "50amenu " . | |
| 585 \ "Ada." . escape(a:Text, ' ') . | |
| 1668 | 586 \ "<Tab>" . escape(l:leader . "a" . a:Keys , '\') . |
| 1125 | 587 \ " :" . a:Command . "<CR>" |
| 588 execute | |
| 589 \ "nnoremap <buffer>" . | |
| 10895 | 590 \ " <Leader>a" . a:Keys . |
| 1125 | 591 \" :" . a:Command |
| 592 execute | |
| 593 \ "inoremap <buffer>" . | |
| 10895 | 594 \ " <Learder>a" . a:Keys . |
| 1125 | 595 \" <C-O>:" . a:Command |
| 596 endif | |
| 597 return | |
| 598 endfunction | |
| 599 | |
| 600 " Section: ada#Map_Popup {{{2 | |
| 601 " | |
| 602 function ada#Map_Popup (Text, Keys, Command) | |
| 1668 | 603 if exists("g:mapleader") |
| 604 let l:leader = g:mapleader | |
| 605 else | |
| 606 let l:leader = '\' | |
| 607 endif | |
| 1125 | 608 execute |
| 609 \ "50amenu " . | |
| 610 \ "PopUp." . escape(a:Text, ' ') . | |
| 1668 | 611 \ "<Tab>" . escape(l:leader . "a" . a:Keys , '\') . |
| 1125 | 612 \ " :" . a:Command . "<CR>" |
| 613 | |
| 614 call ada#Map_Menu (a:Text, a:Keys, a:Command) | |
| 615 return | |
| 616 endfunction ada#Map_Popup | |
| 617 | |
| 618 " }}}1 | |
| 619 | |
| 620 lockvar g:ada#WordRegex | |
| 621 lockvar g:ada#DotWordRegex | |
| 622 lockvar g:ada#Comment | |
| 623 lockvar! g:ada#Keywords | |
| 624 lockvar! g:ada#Ctags_Kinds | |
| 625 | |
|
3496
d1e4abe8342c
Fixed compatible mode in most runtime files.
Bram Moolenaar <bram@vim.org>
parents:
2034
diff
changeset
|
626 let &cpo = s:keepcpo |
|
d1e4abe8342c
Fixed compatible mode in most runtime files.
Bram Moolenaar <bram@vim.org>
parents:
2034
diff
changeset
|
627 unlet s:keepcpo |
|
d1e4abe8342c
Fixed compatible mode in most runtime files.
Bram Moolenaar <bram@vim.org>
parents:
2034
diff
changeset
|
628 |
| 1125 | 629 finish " 1}}} |
| 630 | |
| 631 "------------------------------------------------------------------------------ | |
| 632 " Copyright (C) 2006 Martin Krischik | |
| 633 " | |
| 634 " Vim is Charityware - see ":help license" or uganda.txt for licence details. | |
| 635 "------------------------------------------------------------------------------ | |
| 636 " vim: textwidth=78 wrap tabstop=8 shiftwidth=3 softtabstop=3 noexpandtab | |
| 637 " vim: foldmethod=marker |