summaryrefslogtreecommitdiffstats
path: root/runtime/keymap/turkish-f.vim
blob: f03c5eb3e2b5e84d68bc26a077ad43e8a47ca440 (plain)
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
" Vim keymap file for Turkish F layout
" Maintainer: Emir SARI <bitigchi@me.com>
" Last changed: 5 August 2020

scriptencoding utf-8
let b:keymap_name = "tr-f"
loadkeymap

F A LATIN CAPITAL LETTER A
< B LATIN CAPITAL LETTER B
V C LATIN CAPITAL LETTER C
B Ç LATIN CAPITAL LETTER C WITH CEDILLA
Y D LATIN CAPITAL LETTER D
D E LATIN CAPITAL LETTER E
Q F LATIN CAPITAL LETTER F
W G LATIN CAPITAL LETTER G
E Ğ LATIN CAPITAL LETTER G WITH BREVE
O H LATIN CAPITAL LETTER H
R I LATIN CAPITAL LETTER I
S İ LATIN CAPITAL LETTER I WITH DOT ABOVE
Z J LATIN CAPITAL LETTER J
J K LATIN CAPITAL LETTER K
K M LATIN CAPITAL LETTER M
I N LATIN CAPITAL LETTER N
T O LATIN CAPITAL LETTER O
X Ö LATIN CAPITAL LETTER O WITH DIAERESIS
U R LATIN CAPITAL LETTER R
M S LATIN CAPITAL LETTER S
\" Ş LATIN CAPITAL LETTER S WITH CEDILLA
H T LATIN CAPITAL LETTER T
A U LATIN CAPITAL LETTER U
G Ü LATIN CAPITAL LETTER U WITH DIAERESIS
C V LATIN CAPITAL LETTER V
: Y LATIN CAPITAL LETTER Y
N Z LATIN CAPITAL LETTER Z

{ Q LATIN CAPITAL LETTER Q
} W LATIN CAPITAL LETTER W
| X LATIN CAPITAL LETTER X

± * ASTERISK
@ " QUOTATION MARK
# ^ CIRCUMFLEX ACCENT
^ & AMPERSAND
& ' APOSTROPHE
* ( LEFT PARENTHESIS
( ) RIGHT PARENTHESIS
) = EQUALS SIGN
_ ? QUESTION MARK
+ _ LOW LINE
> : COLON
? ; SEMICOLON
~ > GREATER-THAN SIGN

Å Û LATIN CAPITAL LETTER U WITH CIRCUMFLEX
Í Î LATIN CAPITAL LETTER I WITH CIRCUMFLEX
Ï Â LATIN CAPITAL LETTER A WITH CIRCUMFLEX

f a LATIN SMALL LETTER A
, b LATIN SMALL LETTER B
v c LATIN SMALL LETTER C
b ç LATIN SMALL LETTER C WITH CEDILLA
y d LATIN SMALL LETTER D
d e LATIN SMALL LETTER E
q f LATIN SMALL LETTER F
w g LATIN SMALL LETTER G
e ğ LATIN SMALL LETTER G WITH BREVE
o h LATIN SMALL LETTER H
r ı LATIN SMALL LETTER I
s i LATIN SMALL LETTER I WITH DOT ABOVE
z j LATIN SMALL LETTER J
j k LATIN SMALL LETTER K
k m LATIN SMALL LETTER M
i n LATIN SMALL LETTER N
t o LATIN SMALL LETTER O
x ö LATIN SMALL LETTER O WITH DIAERESIS
u r LATIN SMALL LETTER R
m s LATIN SMALL LETTER S
\' ş LATIN SMALL LETTER S WITH CEDILLA
h t LATIN SMALL LETTER T
a u LATIN SMALL LETTER U
g ü LATIN SMALL LETTER U WITH DIAERESIS
c v LATIN SMALL LETTER V
; y LATIN SMALL LETTER Y
n z LATIN SMALL LETTER Z

[ q LATIN SMALL LETTER Q
] w LATIN SMALL LETTER W
\\ x LATIN SMALL LETTER X

§ + PLUS SIGN
- / SOLIDUS
= - HYPHEN-MINUS
/ , COMMA
` < LESS-THAN SIGN

£ # NUMBER SIGN
¶ { LEFT CURLY BRACKET
• [ LEFT SQUARE BRACKET
ª ] RIGHT SQUARE BRACKET
º } RIGHT CURLY BRACKET
– \\ REVERSE SOLIDUS
≠ | VERTICAL LINE
œ @ COMMERCIAL AT
‘ ~ TILDE
å û LATIN SMALL LETTER U WITH CIRCUMFLEX
ß î LATIN SMALL LETTER I WITH CIRCUMFLEX
∂ € EURO SIGN
ƒ â LATIN SMALL LETTER A WITH CIRCUMFLEX
˙ ₺ TURKISH LIRA SIGN
¬ £ POUND SIGN
… ¥ YEN SIGN
« ` GRAVE ACCENT
font-weight: bold } /* Keyword.Namespace */ .highlight .kp { color: #008800 } /* Keyword.Pseudo */ .highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */ .highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */ .highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */ .highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */ .highlight .na { color: #336699 } /* Name.Attribute */ .highlight .nb { color: #003388 } /* Name.Builtin */ .highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */ .highlight .no { color: #003366; font-weight: bold } /* Name.Constant */ .highlight .nd { color: #555555 } /* Name.Decorator */ .highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */ .highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */ .highlight .nl { color: #336699; font-style: italic } /* Name.Label */ .highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */ .highlight .py { color: #336699; font-weight: bold } /* Name.Property */ .highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */ .highlight .nv { color: #336699 } /* Name.Variable */ .highlight .ow { color: #008800 } /* Operator.Word */ .highlight .w { color: #bbbbbb } /* Text.Whitespace */ .highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */ .highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */ .highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */ .highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */ .highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */ .highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */ .highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */ .highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */ .highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */ .highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */ .highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */ .highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
" MetaPost indent file
" Language:           MetaPost
" Maintainer:         Nicola Vitacolonna <nvitacolonna@gmail.com>
" Former Maintainers: Eugene Minkovskii <emin@mccme.ru>
" Last Change:        2016 Oct 2, 4:13pm
" Version: 0.2

if exists("b:did_indent")
  finish
endif
let b:did_indent = 1

setlocal indentexpr=GetMetaPostIndent()
setlocal indentkeys+==end,=else,=fi,=fill,0),0]

let b:undo_indent = "setl indentkeys< indentexpr<"

" Only define the function once.
if exists("*GetMetaPostIndent")
  finish
endif
let s:keepcpo= &cpo
set cpo&vim

function GetMetaPostIndent()
  let ignorecase_save = &ignorecase
  try
    let &ignorecase = 0
    return GetMetaPostIndentIntern()
  finally
    let &ignorecase = ignorecase_save
  endtry
endfunc

" Regexps {{{
" Note: the next three variables are made global so that a user may add
" further keywords.
"
" Example:
"
"    Put these in ~/.vim/after/indent/mp.vim
"
"    let g:mp_open_tag .= '\|\<begintest\>'
"    let g:mp_close_tag .= '\|\<endtest\>'

" Expressions starting indented blocks
let g:mp_open_tag = ''
      \ . '\<if\>'
      \ . '\|\<else\%[if]\>'
      \ . '\|\<for\%(\|ever\|suffixes\)\>'
      \ . '\|\<begingroup\>'
      \ . '\|\<\%(\|var\|primary\|secondary\|tertiary\)def\>'
      \ . '\|^\s*\<begin\%(fig\|graph\|glyph\|char\|logochar\)\>'
      \ . '\|[([{]'

" Expressions ending indented blocks
let g:mp_close_tag = ''
      \ . '\<fi\>'
      \ . '\|\<else\%[if]\>'
      \ . '\|\<end\%(\|for\|group\|def\|fig\|char\|glyph\|graph\)\>'
      \ . '\|[)\]}]'

" Statements that may span multiple lines and are ended by a semicolon. To
" keep this list short, statements that are unlikely to be very long or are
" not very common (e.g., keywords like `interim` or `showtoken`) are not
" included.
"
" The regex for assignments and equations (the last branch) is tricky, because
" it must not match things like `for i :=`, `if a=b`, `def...=`, etc... It is
" not perfect, but it works reasonably well.
let g:mp_statement = ''
      \ . '\<\%(\|un\|cut\)draw\>'
      \ . '\|\<\%(\|un\)fill\%[draw]\>'
      \ . '\|\<draw\%(dbl\)\=arrow\>'
      \ . '\|\<clip\>'
      \ . '\|\<addto\>'
      \ . '\|\<save\>'
      \ . '\|\<setbounds\>'
      \ . '\|\<message\>'
      \ . '\|\<errmessage\>'
      \ . '\|\<errhelp\>'
      \ . '\|\<fontmapline\>'
      \ . '\|\<pickup\>'
      \ . '\|\<show\>'
      \ . '\|\<special\>'
      \ . '\|\<write\>'
      \ . '\|\%(^\|;\)\%([^;=]*\%('.g:mp_open_tag.'\)\)\@!.\{-}:\=='

" A line ends with zero or more spaces, possibly followed by a comment.
let s:eol = '\s*\%($\|%\)'
" }}}

" Auxiliary functions {{{
" Returns 1 if (0-based) position immediately preceding `pos` in `line` is
" inside a string or a comment; returns 0 otherwise.

" This is the function that is called more often when indenting, so it is
" critical that it is efficient. The method we use is significantly faster
" than using syntax attributes, and more general (it does not require
" syntax_items). It is also faster than using a single regex matching an even
" number of quotes. It helps that MetaPost strings cannot span more than one
" line and cannot contain escaped quotes.
function! s:CommentOrString(line, pos)
  let in_string = 0
  let q = stridx(a:line, '"')
  let c = stridx(a:line, '%')
  while q >= 0 && q < a:pos
    if c >= 0 && c < q
      if in_string " Find next percent symbol
        let c = stridx(a:line, '%', q + 1)
      else " Inside comment
        return 1
      endif
    endif
    let in_string = 1 - in_string
    let q = stridx(a:line, '"', q + 1) " Find next quote
  endwhile
  return in_string || (c >= 0 && c <= a:pos)
endfunction

" Find the first non-comment non-blank line before the current line.
function! s:PrevNonBlankNonComment(lnum)
  let l:lnum = prevnonblank(a:lnum - 1)
  while getline(l:lnum) =~# '^\s*%'
    let l:lnum = prevnonblank(l:lnum - 1)
  endwhile
  return l:lnum
endfunction

" Returns true if the last tag appearing in the line is an open tag; returns
" false otherwise.
function! s:LastTagIsOpen(line)
  let o = s:LastValidMatchEnd(a:line, g:mp_open_tag, 0)
  if o == - 1 | return v:false | endif
  return s:LastValidMatchEnd(a:line, g:mp_close_tag, o) < 0
endfunction

" A simple, efficient and quite effective heuristics is used to test whether
" a line should cause the next line to be indented: count the "opening tags"
" (if, for, def, ...) in the line, count the "closing tags" (endif, endfor,
" ...) in the line, and compute the difference. We call the result the
" "weight" of the line. If the weight is positive, then the next line should
" most likely be indented. Note that `else` and `elseif` are both opening and
" closing tags, so they "cancel out" in almost all cases, the only exception
" being a leading `else[if]`, which is counted as an opening tag, but not as
" a closing tag (so that, for instance, a line containing a single `else:`
" will have weight equal to one, not zero). We do not treat a trailing
" `else[if]` in any special way, because lines ending with an open tag are
" dealt with separately before this function is called (see
" GetMetaPostIndentIntern()).
"
" Example:
"
"     forsuffixes $=a,b: if x.$ = y.$ : draw else: fill fi
"       % This line will be indented because |{forsuffixes,if,else}| > |{else,fi}| (3 > 2)
"     endfor

function! s:Weight(line)
  let [o, i] = [0, s:ValidMatchEnd(a:line, g:mp_open_tag, 0)]
  while i > 0
    let o += 1
    let i = s:ValidMatchEnd(a:line, g:mp_open_tag, i)
  endwhile
  let [c, i] = [0, matchend(a:line, '^\s*\<else\%[if]\>')] " Skip a leading else[if]
  let i = s:ValidMatchEnd(a:line, g:mp_close_tag, i)
  while i > 0
    let c += 1
    let i = s:ValidMatchEnd(a:line, g:mp_close_tag, i)
  endwhile
  return o - c
endfunction

" Similar to matchend(), but skips strings and comments.
" line: a String
function! s:ValidMatchEnd(line, pat, start)
  let i = matchend(a:line, a:pat, a:start)
  while i > 0 && s:CommentOrString(a:line, i)
    let i = matchend(a:line, a:pat, i)
  endwhile
  return i
endfunction

" Like s:ValidMatchEnd(), but returns the end position of the last (i.e.,
" rightmost) match.
function! s:LastValidMatchEnd(line, pat, start)
  let last_found = -1
  let i = matchend(a:line, a:pat, a:start)
  while i > 0
    if !s:CommentOrString(a:line, i)
      let last_found = i
    endif
    let i = matchend(a:line, a:pat, i)
  endwhile
  return last_found
endfunction

function! s:DecreaseIndentOnClosingTag(curr_indent)
  let cur_text = getline(v:lnum)
  if cur_text =~# '^\s*\%('.g:mp_close_tag.'\)'
    return max([a:curr_indent - shiftwidth(), 0])
  endif
  return a:curr_indent
endfunction
" }}}

" Main function {{{
"
" Note: Every rule of indentation in MetaPost is very subjective. We might get
" creative, but things get murky very soon (there are too many corner cases).
" So, we provide a means for the user to decide what to do when this script
" doesn't get it. We use a simple idea: use '%>', '%<' and '%=' to explicitly
" control indentation. The '<' and '>' symbols may be repeated many times
" (e.g., '%>>' will cause the next line to be indented twice).
"
" By using '%>...', '%<...' and '%=', the indentation the user wants is
" preserved by commands like gg=G, even if it does not follow the rules of
" this script.
"
" Example:
"
"    def foo =
"        makepen(
"            subpath(T-n,t) of r  %>
"                shifted .5down   %>
"                    --subpath(t,T) of r shifted .5up -- cycle   %<<<
"        )
"        withcolor black
"    enddef
"
" The default indentation of the previous example would be:
"
"    def foo =
"        makepen(
"            subpath(T-n,t) of r
"            shifted .5down
"            --subpath(t,T) of r shifted .5up -- cycle
"        )
"        withcolor black
"    enddef
"
" Personally, I prefer the latter, but anyway...
function! GetMetaPostIndentIntern()
  " Do not touch indentation inside verbatimtex/btex.. etex blocks.
  if synIDattr(synID(v:lnum, 1, 1), "name") =~# '^mpTeXinsert$\|^tex\|^Delimiter'
    return -1
  endif

  " This is the reference line relative to which the current line is indented
  " (but see below).
  let lnum = s:PrevNonBlankNonComment(v:lnum)

  " At the start of the file use zero indent.
  if lnum == 0
    return 0
  endif

  let prev_text = getline(lnum)

  " User-defined overrides take precedence over anything else.
  " See above for an example.
  let j = match(prev_text, '%[<>=]')
  if j > 0
    let i = strlen(matchstr(prev_text, '%>\+', j)) - 1
    if i > 0
      return indent(lnum) + i * shiftwidth()
    endif

    let i = strlen(matchstr(prev_text, '%<\+', j)) - 1
    if i > 0
      return max([indent(lnum) - i * shiftwidth(), 0])
    endif

    if match(prev_text, '%=', j)
      return indent(lnum)
    endif
  endif

  " If the reference line ends with an open tag, indent.
  "
  " Example:
  "
  " if c:
  "     0
  " else:
  "     1
  " fi if c2: % Note that this line has weight equal to zero.
  "     ...   % This line will be indented
  if s:LastTagIsOpen(prev_text)
    return s:DecreaseIndentOnClosingTag(indent(lnum) + shiftwidth())
  endif

  " Lines with a positive weight are unbalanced and should likely be indented.
  "
  " Example:
  "
  " def f = enddef for i = 1 upto 5: if x[i] > 0: 1 else: 2 fi
  "     ... % This line will be indented (because of the unterminated `for`)
  if s:Weight(prev_text) > 0
    return s:DecreaseIndentOnClosingTag(indent(lnum) + shiftwidth())
  endif

  " Unterminated statements cause indentation to kick in.
  "
  " Example:
  "
  " draw unitsquare
  "     withcolor black; % This line is indented because of `draw`.
  " x := a + b + c
  "     + d + e;         % This line is indented because of `:=`.
  "
  let i = s:LastValidMatchEnd(prev_text, g:mp_statement, 0)
  if i >= 0 " Does the line contain a statement?
    if s:ValidMatchEnd(prev_text, ';', i) < 0 " Is the statement unterminated?
      return indent(lnum) + shiftwidth()
    else
      return s:DecreaseIndentOnClosingTag(indent(lnum))
    endif
  endif

  " Deal with the special case of a statement spanning multiple lines. If the
  " current reference line L ends with a semicolon, search backwards for
  " another semicolon or a statement keyword. If the latter is found first,
  " its line is used as the reference line for indenting the current line
  " instead of L.
  "
  "  Example:
  "
  "  if cond:
  "    draw if a: z0 else: z1 fi
  "        shifted S
  "        scaled T;      % L
  "
  "    for i = 1 upto 3:  % <-- Current line: this gets the same indent as `draw ...`
  "
  " NOTE: we get here only if L does not contain a statement (among those
  " listed in g:mp_statement).
  if s:ValidMatchEnd(prev_text, ';'.s:eol, 0) >= 0 " L ends with a semicolon
    let stm_lnum = s:PrevNonBlankNonComment(lnum)
    while stm_lnum > 0
      let prev_text = getline(stm_lnum)
      let sc_pos = s:LastValidMatchEnd(prev_text, ';', 0)
      let stm_pos = s:ValidMatchEnd(prev_text, g:mp_statement, sc_pos)
      if stm_pos > sc_pos
        let lnum = stm_lnum
        break
      elseif sc_pos > stm_pos
        break
      endif
      let stm_lnum = s:PrevNonBlankNonComment(stm_lnum)
    endwhile
  endif

  return s:DecreaseIndentOnClosingTag(indent(lnum))
endfunction
" }}}

let &cpo = s:keepcpo
unlet s:keepcpo

" vim:sw=2:fdm=marker