neovim

erlang.vim (51955B)

---

" Vim indent file
" Language:     Erlang (http://www.erlang.org)
" Author:       Csaba Hoch <csaba.hoch@gmail.com>
" Contributors: Edwin Fine <efine145_nospam01 at usa dot net>
"               Pawel 'kTT' Salata <rockplayer.pl@gmail.com>
"               Ricardo Catalinas Jiménez <jimenezrick@gmail.com>
" Last Update:  2022-Sep-06
" License:      Vim license
" URL:          https://github.com/vim-erlang/vim-erlang-runtime

" Note About Usage:
"   This indentation script works best with the Erlang syntax file created by
"   Kreąimir Marľić (Kresimir Marzic) and maintained by Csaba Hoch.

" Notes About Implementation:
"
" - LTI = Line to indent.
" - The index of the first line is 1, but the index of the first column is 0.


" Initialization {{{1
" ==============

" Only load this indent file when no other was loaded
" Vim 7 or later is needed
if exists("b:did_indent") || version < 700
 finish
else
 let b:did_indent = 1
endif

setlocal indentexpr=ErlangIndent()
setlocal indentkeys+=0=end,0=of,0=catch,0=after,0=else,0=when,0=),0=],0=},0=>>

let b:undo_indent = "setl inde< indk<"

" Only define the functions once
if exists("*ErlangIndent")
 finish
endif

let s:cpo_save = &cpo
set cpo&vim

" Logging library {{{1
" ===============

" Purpose:
"   Logs the given string using the ErlangIndentLog function if it exists.
" Parameters:
"   s: string
function! s:Log(s)
 if exists("*ErlangIndentLog")
   call ErlangIndentLog(a:s)
 endif
endfunction

" Line tokenizer library {{{1
" ======================

" Indtokens are "indentation tokens". See their exact format in the
" documentation of the s:GetTokensFromLine function.

" Purpose:
"   Calculate the new virtual column after the given segment of a line.
" Parameters:
"   line: string
"   first_index: integer -- the index of the first character of the segment
"   last_index: integer -- the index of the last character of the segment
"   vcol: integer -- the virtual column of the first character of the token
"   tabstop: integer -- the value of the 'tabstop' option to be used
" Returns:
"   vcol: integer
" Example:
"   " index:    0 12 34567
"   " vcol:     0 45 89
"   s:CalcVCol("\t'\tx', b", 1, 4, 4)  -> 10
function! s:CalcVCol(line, first_index, last_index, vcol, tabstop)

 " We copy the relevant segment of the line, otherwise if the line were
 " e.g. `"\t", term` then the else branch below would consume the `", term`
 " part at once.
 let line = a:line[a:first_index : a:last_index]

 let i = 0
 let last_index = a:last_index - a:first_index
 let vcol = a:vcol

 while 0 <= i && i <= last_index

   if line[i] ==# "\t"
     " Example (when tabstop == 4):
     "
     " vcol + tab -> next_vcol
     " 0 + tab -> 4
     " 1 + tab -> 4
     " 2 + tab -> 4
     " 3 + tab -> 4
     " 4 + tab -> 8
     "
     " next_i - i == the number of tabs
     let next_i = matchend(line, '\t*', i + 1)
     let vcol = (vcol / a:tabstop + (next_i - i)) * a:tabstop
     call s:Log('new vcol after tab: '. vcol)
   else
     let next_i = matchend(line, '[^\t]*', i + 1)
     let vcol += next_i - i
     call s:Log('new vcol after other: '. vcol)
   endif
   let i = next_i
 endwhile

 return vcol
endfunction

" Purpose:
"   Go through the whole line and return the tokens in the line.
" Parameters:
"   line: string -- the line to be examined
"   string_continuation: bool
"   atom_continuation: bool
" Returns:
"   indtokens = [indtoken]
"   indtoken = [token, vcol, col]
"   token = string (examples: 'begin', '<quoted_atom>', '}')
"   vcol = integer (the virtual column of the first character of the token;
"                   counting starts from 0)
"   col = integer (counting starts from 0)
function! s:GetTokensFromLine(line, string_continuation, atom_continuation,
                            \tabstop)

 let linelen = strlen(a:line) " The length of the line
 let i = 0 " The index of the current character in the line
 let vcol = 0 " The virtual column of the current character
 let indtokens = []

 if a:string_continuation
   let i = matchend(a:line, '^\%([^"\\]\|\\.\)*"', 0)
   if i ==# -1
     call s:Log('    Whole line is string continuation -> ignore')
     return []
   else
     let vcol = s:CalcVCol(a:line, 0, i - 1, 0, a:tabstop)
     call add(indtokens, ['<string_end>', vcol, i])
   endif
 elseif a:atom_continuation
   let i = matchend(a:line, "^\\%([^'\\\\]\\|\\\\.\\)*'", 0)
   if i ==# -1
     call s:Log('    Whole line is quoted atom continuation -> ignore')
     return []
   else
     let vcol = s:CalcVCol(a:line, 0, i - 1, 0, a:tabstop)
     call add(indtokens, ['<quoted_atom_end>', vcol, i])
   endif
 endif

 while 0 <= i && i < linelen

   let next_vcol = ''

   " Spaces
   if a:line[i] ==# ' '
     let next_i = matchend(a:line, ' *', i + 1)

   " Tabs
   elseif a:line[i] ==# "\t"
     let next_i = matchend(a:line, '\t*', i + 1)

     " See example in s:CalcVCol
     let next_vcol = (vcol / a:tabstop + (next_i - i)) * a:tabstop

   " Comment
   elseif a:line[i] ==# '%'
     let next_i = linelen

   " String token: "..."
   elseif a:line[i] ==# '"'
     let next_i = matchend(a:line, '\%([^"\\]\|\\.\)*"', i + 1)
     if next_i ==# -1
       call add(indtokens, ['<string_start>', vcol, i])
     else
       let next_vcol = s:CalcVCol(a:line, i, next_i - 1, vcol, a:tabstop)
       call add(indtokens, ['<string>', vcol, i])
     endif

   " Quoted atom token: '...'
   elseif a:line[i] ==# "'"
     let next_i = matchend(a:line, "\\%([^'\\\\]\\|\\\\.\\)*'", i + 1)
     if next_i ==# -1
       call add(indtokens, ['<quoted_atom_start>', vcol, i])
     else
       let next_vcol = s:CalcVCol(a:line, i, next_i - 1, vcol, a:tabstop)
       call add(indtokens, ['<quoted_atom>', vcol, i])
     endif

   " Keyword or atom or variable token or number
   elseif a:line[i] =~# '[a-zA-Z_@0-9]'
     let next_i = matchend(a:line,
                          \'[[:alnum:]_@:]*\%(\s*#\s*[[:alnum:]_@:]*\)\=',
                          \i + 1)
     call add(indtokens, [a:line[(i):(next_i - 1)], vcol, i])

   " Character token: $<char> (as in: $a)
   elseif a:line[i] ==# '$'
     call add(indtokens, ['$.', vcol, i])
     let next_i = i + 2

   " Dot token: .
   elseif a:line[i] ==# '.'

     let next_i = i + 1

     if i + 1 ==# linelen || a:line[i + 1] =~# '[[:blank:]%]'
       " End of clause token: . (as in: f() -> ok.)
       call add(indtokens, ['<end_of_clause>', vcol, i])

     else
       " Possibilities:
       " - Dot token in float: . (as in: 3.14)
       " - Dot token in record: . (as in: #myrec.myfield)
       call add(indtokens, ['.', vcol, i])
     endif

   " Equal sign
   elseif a:line[i] ==# '='
     " This is handled separately so that "=<<" will be parsed as
     " ['=', '<<'] instead of ['=<', '<']. Although Erlang parses it
     " currently in the latter way, that may be fixed some day.
     call add(indtokens, [a:line[i], vcol, i])
     let next_i = i + 1

   " Three-character tokens
   elseif i + 1 < linelen &&
        \ index(['=:=', '=/='], a:line[i : i + 1]) != -1
     call add(indtokens, [a:line[i : i + 1], vcol, i])
     let next_i = i + 2

   " Two-character tokens
   elseif i + 1 < linelen &&
        \ index(['->', '<<', '>>', '||', '==', '/=', '=<', '>=', '?=', '++',
        \        '--', '::'],
        \       a:line[i : i + 1]) != -1
     call add(indtokens, [a:line[i : i + 1], vcol, i])
     let next_i = i + 2

   " Other character: , ; < > ( ) [ ] { } # + - * / : ? = ! |
   else
     call add(indtokens, [a:line[i], vcol, i])
     let next_i = i + 1

   endif

   if next_vcol ==# ''
     let vcol += next_i - i
   else
     let vcol = next_vcol
   endif

   let i = next_i

 endwhile

 return indtokens

endfunction

" TODO: doc, handle "not found" case
function! s:GetIndtokenAtCol(indtokens, col)
 let i = 0
 while i < len(a:indtokens)
   if a:indtokens[i][2] ==# a:col
     return [1, i]
   elseif a:indtokens[i][2] > a:col
     return [0, s:IndentError('No token at col ' . a:col . ', ' .
                             \'indtokens = ' . string(a:indtokens),
                             \'', '')]
   endif
   let i += 1
 endwhile
 return [0, s:IndentError('No token at col ' . a:col . ', ' .
                          \'indtokens = ' . string(a:indtokens),
                          \'', '')]
endfunction

" Stack library {{{1
" =============

" Purpose:
"   Push a token onto the parser's stack.
" Parameters:
"   stack: [token]
"   token: string
function! s:Push(stack, token)
 call s:Log('    Stack Push: "' . a:token . '" into ' . string(a:stack))
 call insert(a:stack, a:token)
endfunction

" Purpose:
"   Pop a token from the parser's stack.
" Parameters:
"   stack: [token]
"   token: string
" Returns:
"   token: string -- the removed element
function! s:Pop(stack)
 let head = remove(a:stack, 0)
 call s:Log('    Stack Pop: "' . head . '" from ' . string(a:stack))
 return head
endfunction

" Library for accessing and storing tokenized lines {{{1
" =================================================

" The Erlang token cache: an `lnum -> indtokens` dictionary that stores the
" tokenized lines.
let s:all_tokens = {}
let s:file_name = ''
let s:last_changedtick = -1

" Purpose:
"   Clear the Erlang token cache if we have a different file or the file has
"   been changed since the last indentation.
function! s:ClearTokenCacheIfNeeded()
 let file_name = expand('%:p')
 if file_name != s:file_name ||
  \ b:changedtick != s:last_changedtick
   let s:file_name = file_name
   let s:last_changedtick = b:changedtick
   let s:all_tokens = {}
 endif
endfunction

" Purpose:
"   Return the tokens of line `lnum`, if that line is not empty. If it is
"   empty, find the first non-empty line in the given `direction` and return
"   the tokens of that line.
" Parameters:
"   lnum: integer
"   direction: 'up' | 'down'
" Returns:
"   result: [] -- the result is an empty list if we hit the beginning or end
"                  of the file
"           | [lnum, indtokens]
"   lnum: integer -- the index of the non-empty line that was found and
"                    tokenized
"   indtokens: [indtoken] -- the tokens of line `lnum`
function! s:TokenizeLine(lnum, direction)

 call s:Log('Tokenizing starts from line ' . a:lnum)
 if a:direction ==# 'up'
   let lnum = prevnonblank(a:lnum)
 else " a:direction ==# 'down'
   let lnum = nextnonblank(a:lnum)
 endif

 " We hit the beginning or end of the file
 if lnum ==# 0
   let indtokens = []
   call s:Log('  We hit the beginning or end of the file.')

   " The line has already been parsed
 elseif has_key(s:all_tokens, lnum)
   let indtokens = s:all_tokens[lnum]
   call s:Log('Cached line ' . lnum . ': ' . getline(lnum))
   call s:Log("  Tokens in the line:\n    - " . join(indtokens, "\n    - "))

   " The line should be parsed now
 else

   " Parse the line
   let line = getline(lnum)
   let string_continuation = s:IsLineStringContinuation(lnum)
   let atom_continuation = s:IsLineAtomContinuation(lnum)
   let indtokens = s:GetTokensFromLine(line, string_continuation,
                                      \atom_continuation, &tabstop)
   let s:all_tokens[lnum] = indtokens
   call s:Log('Tokenizing line ' . lnum . ': ' . line)
   call s:Log("  Tokens in the line:\n    - " . join(indtokens, "\n    - "))

 endif

 return [lnum, indtokens]
endfunction

" Purpose:
"   As a helper function for PrevIndToken and NextIndToken, the FindIndToken
"   function finds the first line with at least one token in the given
"   direction.
" Parameters:
"   lnum: integer
"   direction: 'up' | 'down'
" Returns:
"   result: [[], 0, 0]
"             -- the result is an empty list if we hit the beginning or end of
"             the file
"           | [indtoken, lnum, i]
"             -- the content, lnum and token index of the next (or previous)
"             indtoken
function! s:FindIndToken(lnum, dir)
 let lnum = a:lnum
 while 1
   let lnum += (a:dir ==# 'up' ? -1 : 1)
   let [lnum, indtokens] = s:TokenizeLine(lnum, a:dir)
   if lnum ==# 0
     " We hit the beginning or end of the file
     return [[], 0, 0]
   elseif !empty(indtokens)
     " We found a non-empty line. If we were moving up, we return the last
     " token of this line. Otherwise we return the first token if this line.
     let i = (a:dir ==# 'up' ? len(indtokens) - 1 : 0)
     return [indtokens[i], lnum, i]
   endif
 endwhile
endfunction

" Purpose:
"   Find the token that directly precedes the given token.
" Parameters:
"   lnum: integer -- the line of the given token
"   i: the index of the given token within line `lnum`
" Returns:
"   result = [] -- the result is an empty list if the given token is the first
"                  token of the file
"          | indtoken
function! s:PrevIndToken(lnum, i)
 call s:Log('    PrevIndToken called: lnum=' . a:lnum . ', i =' . a:i)

 " If the current line has a previous token, return that
 if a:i > 0
   return [s:all_tokens[a:lnum][a:i - 1], a:lnum, a:i - 1]
 else
   return s:FindIndToken(a:lnum, 'up')
 endif
endfunction

" Purpose:
"   Find the token that directly succeeds the given token.
" Parameters:
"   lnum: integer -- the line of the given token
"   i: the index of the given token within line `lnum`
" Returns:
"   result = [] -- the result is an empty list if the given token is the last
"                  token of the file
"          | indtoken
function! s:NextIndToken(lnum, i)
 call s:Log('    NextIndToken called: lnum=' . a:lnum . ', i =' . a:i)

 " If the current line has a next token, return that
 if len(s:all_tokens[a:lnum]) > a:i + 1
   return [s:all_tokens[a:lnum][a:i + 1], a:lnum, a:i + 1]
 else
   return s:FindIndToken(a:lnum, 'down')
 endif
endfunction

" ErlangCalcIndent helper functions {{{1
" =================================

" Purpose:
"   This function is called when the parser encounters a syntax error.
"
"   If we encounter a syntax error, we return
"   g:erlang_unexpected_token_indent, which is -1 by default. This means that
"   the indentation of the LTI will not be changed.
" Parameter:
"   msg: string
"   token: string
"   stack: [token]
" Returns:
"   indent: integer
function! s:IndentError(msg, token, stack)
 call s:Log('Indent error: ' . a:msg . ' -> return')
 call s:Log('  Token = ' . a:token . ', ' .
           \'  stack = ' . string(a:stack))
 return g:erlang_unexpected_token_indent
endfunction

" Purpose:
"   This function is called when the parser encounters an unexpected token,
"   and the parser will return the number given back by UnexpectedToken.
"
"   If we encounter an unexpected token, we return
"   g:erlang_unexpected_token_indent, which is -1 by default. This means that
"   the indentation of the LTI will not be changed.
" Parameter:
"   token: string
"   stack: [token]
" Returns:
"   indent: integer
function! s:UnexpectedToken(token, stack)
 call s:Log('    Unexpected token ' . a:token . ', stack = ' .
           \string(a:stack) . ' -> return')
 return g:erlang_unexpected_token_indent
endfunction

if !exists('g:erlang_unexpected_token_indent')
 let g:erlang_unexpected_token_indent = -1
endif

" Purpose:
"   Return whether the given line starts with a string continuation.
" Parameter:
"   lnum: integer
" Returns:
"   result: bool
" Example:
"   f() ->           % IsLineStringContinuation = false
"       "This is a   % IsLineStringContinuation = false
"       multiline    % IsLineStringContinuation = true
"       string".     % IsLineStringContinuation = true
function! s:IsLineStringContinuation(lnum)
 if has('syntax_items')
   return synIDattr(synID(a:lnum, 1, 0), 'name') =~# '^erlangString'
 else
   return 0
 endif
endfunction

" Purpose:
"   Return whether the given line starts with an atom continuation.
" Parameter:
"   lnum: integer
" Returns:
"   result: bool
" Example:
"   'function with   % IsLineAtomContinuation = true, but should be false
"   weird name'() -> % IsLineAtomContinuation = true
"       ok.          % IsLineAtomContinuation = false
function! s:IsLineAtomContinuation(lnum)
 if has('syntax_items')
   let syn_name = synIDattr(synID(a:lnum, 1, 0), 'name')
   return syn_name =~# '^erlangQuotedAtom' ||
        \ syn_name =~# '^erlangQuotedRecord'
 else
   return 0
 endif
endfunction

" Purpose:
"   Return whether the 'catch' token (which should be the `i`th token in line
"   `lnum`) is standalone or part of a try-catch block, based on the preceding
"   token.
" Parameters:
"   lnum: integer
"   i: integer
" Return:
"   is_standalone: bool
function! s:IsCatchStandalone(lnum, i)
 call s:Log('    IsCatchStandalone called: lnum=' . a:lnum . ', i=' . a:i)
 let [prev_indtoken, _, _] = s:PrevIndToken(a:lnum, a:i)

 " If we hit the beginning of the file, it is not a catch in a try block
 if prev_indtoken == []
   return 1
 endif

 let prev_token = prev_indtoken[0]

 if prev_token =~# '^[A-Z_@0-9]'
   let is_standalone = 0
 elseif prev_token =~# '[a-z]'
   if index(['after', 'and', 'andalso', 'band', 'begin', 'bnot', 'bor', 'bsl',
           \ 'bsr', 'bxor', 'case', 'catch', 'div', 'maybe', 'not', 'or',
           \ 'orelse', 'rem', 'try', 'xor'], prev_token) != -1
     " If catch is after these keywords, it is standalone
     let is_standalone = 1
   else
     " If catch is after another keyword (e.g. 'end') or an atom, it is
     " part of try-catch.
     "
     " Keywords:
     " - may precede 'catch': end
     " - may not precede 'catch': else fun if of receive when
     " - unused: cond let query
     let is_standalone = 0
   endif
 elseif index([')', ']', '}', '<string>', '<string_end>', '<quoted_atom>',
             \ '<quoted_atom_end>', '$.'], prev_token) != -1
   let is_standalone = 0
 else
   " This 'else' branch includes the following tokens:
   "   -> == /= =< < >= > ?= =:= =/= + - * / ++ -- :: < > ; ( [ { ? = ! . |
   let is_standalone = 1
 endif

 call s:Log('   "catch" preceded by "' . prev_token  . '" -> catch ' .
           \(is_standalone ? 'is standalone' : 'belongs to try-catch'))
 return is_standalone

endfunction

" Purpose:
"   This function is called when a begin-type element ('begin', 'case',
"   '[', '<<', etc.) is found. It asks the caller to return if the stack
"   if already empty.
" Parameters:
"   stack: [token]
"   token: string
"   curr_vcol: integer
"   stored_vcol: integer
"   sw: integer -- number of spaces to be used after the begin element as
"                  indentation
" Returns:
"   result: [should_return, indent]
"   should_return: bool -- if true, the caller should return `indent` to Vim
"   indent -- integer
function! s:BeginElementFoundIfEmpty(stack, token, curr_vcol, stored_vcol, sw)
 if empty(a:stack)
   if a:stored_vcol ==# -1
     call s:Log('    "' . a:token . '" directly precedes LTI -> return')
     return [1, a:curr_vcol + a:sw]
   else
     call s:Log('    "' . a:token .
               \'" token (whose expression includes LTI) found -> return')
     return [1, a:stored_vcol]
   endif
 else
   return [0, 0]
 endif
endfunction

" Purpose:
"   This function is called when a begin-type element ('begin', 'case', '[',
"   '<<', etc.) is found, and in some cases when 'after' and 'when' is found.
"   It asks the caller to return if the stack is already empty.
" Parameters:
"   stack: [token]
"   token: string
"   curr_vcol: integer
"   stored_vcol: integer
"   end_token: end token that belongs to the begin element found (e.g. if the
"              begin element is 'begin', the end token is 'end')
"   sw: integer -- number of spaces to be used after the begin element as
"                  indentation
" Returns:
"   result: [should_return, indent]
"   should_return: bool -- if true, the caller should return `indent` to Vim
"   indent -- integer
function! s:BeginElementFound(stack, token, curr_vcol, stored_vcol, end_token, sw)

 " Return 'return' if the stack is empty
 let [ret, res] = s:BeginElementFoundIfEmpty(a:stack, a:token, a:curr_vcol,
                                            \a:stored_vcol, a:sw)
 if ret | return [ret, res] | endif

 if a:stack[0] ==# a:end_token
   call s:Log('    "' . a:token . '" pops "' . a:end_token . '"')
   call s:Pop(a:stack)
   if !empty(a:stack) && a:stack[0] ==# 'align_to_begin_element'
     call s:Pop(a:stack)
     if empty(a:stack)
       return [1, a:curr_vcol]
     else
       return [1, s:UnexpectedToken(a:token, a:stack)]
     endif
   else
     return [0, 0]
   endif
 else
   return [1, s:UnexpectedToken(a:token, a:stack)]
 endif
endfunction

" Purpose:
"   This function is called when we hit the beginning of a file or an
"   end-of-clause token -- i.e. when we found the beginning of the current
"   clause.
"
"   If the stack contains an '->' or 'when', this means that we can return
"   now, since we were looking for the beginning of the clause.
" Parameters:
"   stack: [token]
"   token: string
"   stored_vcol: integer
"   lnum: the line number of the "end of clause" mark (or 0 if we hit the
"         beginning of the file)
"   i: the index of the "end of clause" token within its own line
" Returns:
"   result: [should_return, indent]
"   should_return: bool -- if true, the caller should return `indent` to Vim
"   indent -- integer
function! s:BeginningOfClauseFound(stack, token, stored_vcol, lnum, i)
 if !empty(a:stack) && a:stack[0] ==# 'when'
   call s:Log('    BeginningOfClauseFound: "when" found in stack')
   call s:Pop(a:stack)
   if empty(a:stack)
     call s:Log('    Stack is ["when"], so LTI is in a guard -> return')
     return [1, a:stored_vcol + shiftwidth() + 2]
   else
     return [1, s:UnexpectedToken(a:token, a:stack)]
   endif
 elseif !empty(a:stack) && a:stack[0] ==# '->'
   call s:Log('    BeginningOfClauseFound: "->" found in stack')
   call s:Pop(a:stack)
   if empty(a:stack)
     call s:Log('    Stack is ["->"], so LTI is in function body -> return')
     return [1, a:stored_vcol + shiftwidth()]
   elseif a:stack[0] ==# ';'
     call s:Pop(a:stack)

     if !empty(a:stack)
       return [1, s:UnexpectedToken(a:token, a:stack)]
     endif

     if a:lnum ==# 0
       " Set lnum and i to be NextIndToken-friendly
       let lnum = 1
       let i = -1 
     else
       let lnum = a:lnum
       let i = a:i
     endif

     " Are we after a "-spec func() ...;" clause?
     let [next1_indtoken, next1_lnum, next1_i] = s:NextIndToken(lnum, i)
     if !empty(next1_indtoken) && next1_indtoken[0] =~# '-'
       let [next2_indtoken, next2_lnum, next2_i] =
          \s:NextIndToken(next1_lnum, next1_i)
       if !empty(next2_indtoken) && next2_indtoken[0] =~# 'spec'
         let [next3_indtoken, next3_lnum, next3_i] =
            \s:NextIndToken(next2_lnum, next2_i)
         if !empty(next3_indtoken)
           let [next4_indtoken, next4_lnum, next4_i] =
              \s:NextIndToken(next3_lnum, next3_i)
           if !empty(next4_indtoken)
             " Yes, we are.
             call s:Log('    Stack is ["->", ";"], so LTI is in a "-spec" ' .
                       \'attribute -> return')
             return [1, next4_indtoken[1]]
           endif
         endif
       endif
     endif

     call s:Log('    Stack is ["->", ";"], so LTI is in a function head ' .
               \'-> return')
     return [1, a:stored_vcol]

   else
     return [1, s:UnexpectedToken(a:token, a:stack)]
   endif
 else
   return [0, 0]
 endif
endfunction

let g:erlang_indent_searchpair_timeout = 2000

" TODO
function! s:SearchPair(lnum, curr_col, start, middle, end)
 call cursor(a:lnum, a:curr_col + 1)
 let [lnum_new, col1_new] = 
     \searchpairpos(a:start, a:middle, a:end, 'bW',
                   \'synIDattr(synID(line("."), col("."), 0), "name") ' .
                   \'=~? "string\\|quotedatom\\|todo\\|comment\\|' . 
                   \'erlangmodifier"',
                   \0, g:erlang_indent_searchpair_timeout)
 return [lnum_new, col1_new - 1]
endfunction

function! s:SearchEndPair(lnum, curr_col)
 return s:SearchPair(
        \ a:lnum, a:curr_col,
        \ '\C\<\%(case\|try\|begin\|receive\|if\|maybe\)\>\|' .
        \ '\<fun\>\%(\s\|\n\|%.*$\|[A-Z_@][a-zA-Z_@]*\)*(',
        \ '',
        \ '\<end\>')
endfunction

" ErlangCalcIndent {{{1
" ================

" Purpose:
"   Calculate the indentation of the given line.
" Parameters:
"   lnum: integer -- index of the line for which the indentation should be
"                    calculated
"   stack: [token] -- initial stack
" Return:
"   indent: integer -- if -1, that means "don't change the indentation";
"                      otherwise it means "indent the line with `indent`
"                      number of spaces or equivalent tabs"
function! s:ErlangCalcIndent(lnum, stack)
 let res = s:ErlangCalcIndent2(a:lnum, a:stack)
 call s:Log("ErlangCalcIndent returned: " . res)
 return res
endfunction

function! s:ErlangCalcIndent2(lnum, stack)

 let lnum = a:lnum
 let stored_vcol = -1 " Virtual column of the first character of the token that
                  " we currently think we might align to.
 let mode = 'normal'
 let stack = a:stack
 let semicolon_abscol = ''

 " Walk through the lines of the buffer backwards (starting from the
 " previous line) until we can decide how to indent the current line.
 while 1

   let [lnum, indtokens] = s:TokenizeLine(lnum, 'up')

   " Hit the start of the file
   if lnum ==# 0
     let [ret, res] = s:BeginningOfClauseFound(stack, 'beginning_of_file',
                                              \stored_vcol, 0, 0)
     if ret | return res | endif

     return 0
   endif

   let i = len(indtokens) - 1
   let last_token_of_line = 1

   while i >= 0

     let [token, curr_vcol, curr_col] = indtokens[i]
     call s:Log('  Analyzing the following token: ' . string(indtokens[i]))

     if len(stack) > 256 " TODO: magic number
       return s:IndentError('Stack too long', token, stack)
     endif

     if token ==# '<end_of_clause>'
       let [ret, res] = s:BeginningOfClauseFound(stack, token, stored_vcol,
                                                \lnum, i)
       if ret | return res | endif

       if stored_vcol ==# -1
         call s:Log('    End of clause directly precedes LTI -> return')
         return 0
       else
         call s:Log('    End of clause (but not end of line) -> return')
         return stored_vcol
       endif

     elseif stack == ['prev_term_plus']
       if token =~# '[a-zA-Z_@#]' ||
        \ token ==# '<string>' || token ==# '<string_start>' ||
        \ token ==# '<quoted_atom>' || token ==# '<quoted_atom_start>'
         call s:Log('    previous token found: curr_vcol + plus = ' .
                   \curr_vcol . " + " . plus)
         return curr_vcol + plus
       endif

     elseif token ==# 'begin'
       let [ret, res] = s:BeginElementFound(stack, token, curr_vcol,
                                           \stored_vcol, 'end', shiftwidth())
       if ret | return res | endif

     " case EXPR of BRANCHES end
     " if BRANCHES end
     " try EXPR catch BRANCHES end
     " try EXPR after BODY end
     " try EXPR catch BRANCHES after BODY end
     " try EXPR of BRANCHES catch BRANCHES end
     " try EXPR of BRANCHES after BODY end
     " try EXPR of BRANCHES catch BRANCHES after BODY end
     " receive BRANCHES end
     " receive BRANCHES after BRANCHES end
     " maybe EXPR end
     " maybe EXPR else BRANCHES end

     " This branch is not Emacs-compatible
     elseif (index(['of', 'receive', 'after', 'if', 'else'], token) != -1 ||
          \  (token ==# 'catch' && !s:IsCatchStandalone(lnum, i))) &&
          \ !last_token_of_line &&
          \ (empty(stack) || stack ==# ['when'] || stack ==# ['->'] ||
          \  stack ==# ['->', ';'])

       " If we are after of/receive/etc, but these are not the last
       " tokens of the line, we want to indent like this:
       "
       "   % stack == []
       "   receive stored_vcol,
       "           LTI
       "
       "   % stack == ['->', ';']
       "   receive stored_vcol ->
       "               B;
       "           LTI
       "
       "   % stack == ['->']
       "   receive stored_vcol ->
       "               LTI
       "
       "   % stack == ['when']
       "   receive stored_vcol when
       "               LTI

       " stack = []  =>  LTI is a condition
       " stack = ['->']  =>  LTI is a branch
       " stack = ['->', ';']  =>  LTI is a condition
       " stack = ['when']  =>  LTI is a guard
       if empty(stack) || stack == ['->', ';']
         call s:Log('    LTI is in a condition after ' .
                   \'"of/receive/after/if/else/catch" -> return')
         return stored_vcol
       elseif stack == ['->']
         call s:Log('    LTI is in a branch after ' .
                   \'"of/receive/after/if/else/catch" -> return')
         return stored_vcol + shiftwidth()
       elseif stack == ['when']
         call s:Log('    LTI is in a guard after ' .
                   \'"of/receive/after/if/else/catch" -> return')
         return stored_vcol + shiftwidth()
       else
         return s:UnexpectedToken(token, stack)
       endif

     elseif index(['case', 'if', 'try', 'receive', 'maybe'], token) != -1

       " stack = []  =>  LTI is a condition
       " stack = ['->']  =>  LTI is a branch
       " stack = ['->', ';']  =>  LTI is a condition
       " stack = ['when']  =>  LTI is in a guard
       if empty(stack)
         " pass
       elseif (token ==# 'case' && stack[0] ==# 'of') ||
            \ (token ==# 'if') ||
            \ (token ==# 'maybe' && stack[0] ==# 'else') ||
            \ (token ==# 'try' && (stack[0] ==# 'of' ||
            \                     stack[0] ==# 'catch' ||
            \                     stack[0] ==# 'after')) ||
            \ (token ==# 'receive')

         " From the indentation point of view, the keyword
         " (of/catch/after/else/end) before the LTI is what counts, so
         " when we reached these tokens, and the stack already had
         " a catch/after/else/end, we didn't modify it.
         "
         " This way when we reach case/try/receive/maybe (i.e. now),
         " there is at most one of/catch/after/else/end token in the
         " stack.
         if token ==# 'case' || token ==# 'try' ||
          \ (token ==# 'receive' && stack[0] ==# 'after') ||
          \ (token ==# 'maybe' && stack[0] ==# 'else')
           call s:Pop(stack)
         endif

         if empty(stack)
           call s:Log('    LTI is in a condition; matching ' .
                     \'"case/if/try/receive/maybe" found')
           let stored_vcol = curr_vcol + shiftwidth()
         elseif stack[0] ==# 'align_to_begin_element'
           call s:Pop(stack)
           let stored_vcol = curr_vcol
         elseif len(stack) > 1 && stack[0] ==# '->' && stack[1] ==# ';'
           call s:Log('    LTI is in a condition; matching ' .
                     \'"case/if/try/receive/maybe" found')
           call s:Pop(stack)
           call s:Pop(stack)
           let stored_vcol = curr_vcol + shiftwidth()
         elseif stack[0] ==# '->'
           call s:Log('    LTI is in a branch; matching ' .
                     \'"case/if/try/receive/maybe" found')
           call s:Pop(stack)
           let stored_vcol = curr_vcol + 2 * shiftwidth()
         elseif stack[0] ==# 'when'
           call s:Log('    LTI is in a guard; matching ' .
                     \'"case/if/try/receive/maybe" found')
           call s:Pop(stack)
           let stored_vcol = curr_vcol + 2 * shiftwidth() + 2
         endif

       endif

       let [ret, res] = s:BeginElementFound(stack, token, curr_vcol,
                                           \stored_vcol, 'end', shiftwidth())
       if ret | return res | endif

     elseif token ==# 'fun'
       let [next_indtoken, next_lnum, next_i] = s:NextIndToken(lnum, i)
       call s:Log('    Next indtoken = ' . string(next_indtoken))

       if !empty(next_indtoken) && next_indtoken[0] =~# '^[A-Z_@]'
         " The "fun" is followed by a variable, so we might have a named fun:
         " "fun Fun() -> ok end". Thus we take the next token to decide
         " whether this is a function definition ("fun()") or just a function
         " reference ("fun Mod:Fun").
         let [next_indtoken, _, _] = s:NextIndToken(next_lnum, next_i)
         call s:Log('    Next indtoken = ' . string(next_indtoken))
       endif

       if !empty(next_indtoken) && next_indtoken[0] ==# '('
         " We have an anonymous function definition
         " (e.g. "fun () -> ok end")

         " stack = []  =>  LTI is a condition
         " stack = ['->']  =>  LTI is a branch
         " stack = ['->', ';']  =>  LTI is a condition
         " stack = ['when']  =>  LTI is in a guard
         if empty(stack)
           call s:Log('    LTI is in a condition; matching "fun" found')
           let stored_vcol = curr_vcol + shiftwidth()
         elseif len(stack) > 1 && stack[0] ==# '->' && stack[1] ==# ';'
           call s:Log('    LTI is in a condition; matching "fun" found')
           call s:Pop(stack)
           call s:Pop(stack)
         elseif stack[0] ==# '->'
           call s:Log('    LTI is in a branch; matching "fun" found')
           call s:Pop(stack)
           let stored_vcol = curr_vcol + 2 * shiftwidth()
         elseif stack[0] ==# 'when'
           call s:Log('    LTI is in a guard; matching "fun" found')
           call s:Pop(stack)
           let stored_vcol = curr_vcol + 2 * shiftwidth() + 2
         endif

         let [ret, res] = s:BeginElementFound(stack, token, curr_vcol,
                                             \stored_vcol, 'end', shiftwidth())
         if ret | return res | endif
       else
         " Pass: we have a function reference (e.g. "fun f/0")
       endif

     elseif token ==# '['
       " Emacs compatibility
       let [ret, res] = s:BeginElementFound(stack, token, curr_vcol,
                                           \stored_vcol, ']', 1)
       if ret | return res | endif

     elseif token ==# '<<'
       " Emacs compatibility
       let [ret, res] = s:BeginElementFound(stack, token, curr_vcol,
                                           \stored_vcol, '>>', 2)
       if ret | return res | endif

     elseif token ==# '(' || token ==# '{'

       let end_token = (token ==# '(' ? ')' :
                       \token ==# '{' ? '}' : 'error')

       if empty(stack)
         " We found the opening paren whose block contains the LTI.
         let mode = 'inside'
       elseif stack[0] ==# end_token
         call s:Log('    "' . token . '" pops "' . end_token . '"')
         call s:Pop(stack)

         if !empty(stack) && stack[0] ==# 'align_to_begin_element'
           " We found the opening paren whose closing paren
           " starts LTI
           let mode = 'align_to_begin_element'
         else
           " We found the opening pair for a closing paren that
           " was already in the stack.
           let mode = 'outside'
         endif
       else
         return s:UnexpectedToken(token, stack)
       endif

       if mode ==# 'inside' || mode ==# 'align_to_begin_element'

         if last_token_of_line && i != 0
           " Examples: {{{
           "
           " mode == 'inside':
           "
           "     my_func(
           "       LTI
           "
           "     [Variable, {
           "        LTI
           "
           " mode == 'align_to_begin_element':
           "
           "     my_func(
           "       Params
           "      ) % LTI
           "
           "     [Variable, {
           "        Terms
           "       } % LTI
           " }}}
           let stack = ['prev_term_plus']
           let plus = (mode ==# 'inside' ? 2 : 1)
           call s:Log('    "' . token .
                     \'" token found at end of line -> find previous token')
         elseif mode ==# 'align_to_begin_element'
           " Examples: {{{
           "
           " mode == 'align_to_begin_element' && !last_token_of_line
           "
           "     my_func(stored_vcol
           "            ) % LTI
           "
           "     [Variable, {stored_vcol
           "                } % LTI
           "
           " mode == 'align_to_begin_element' && i == 0
           "
           "     (
           "       stored_vcol
           "     ) % LTI
           "
           "     {
           "       stored_vcol
           "     } % LTI
           " }}}
           call s:Log('    "' . token . '" token (whose closing token ' .
                     \'starts LTI) found -> return')
           return curr_vcol
         elseif stored_vcol ==# -1
           " Examples: {{{
           "
           " mode == 'inside' && stored_vcol == -1 && !last_token_of_line
           "
           "     my_func(
           "             LTI
           "     [Variable, {
           "                 LTI
           "
           " mode == 'inside' && stored_vcol == -1 && i == 0
           "
           "     (
           "      LTI
           "
           "     {
           "      LTI
           " }}}
           call s:Log('    "' . token .
                     \'" token (which directly precedes LTI) found -> return')
           return curr_vcol + 1
         else
           " Examples: {{{
           "
           " mode == 'inside' && stored_vcol != -1 && !last_token_of_line
           "
           "     my_func(stored_vcol,
           "             LTI
           "
           "     [Variable, {stored_vcol,
           "                 LTI
           "
           " mode == 'inside' && stored_vcol != -1 && i == 0
           "
           "     (stored_vcol,
           "      LTI
           "
           "     {stored_vcol,
           "      LTI
           " }}}
           call s:Log('    "' . token .
                     \'" token (whose block contains LTI) found -> return')
           return stored_vcol
         endif
       endif

     elseif index(['end', ')', ']', '}', '>>'], token) != -1

       " If we can be sure that there is synchronization in the Erlang
       " syntax, we use searchpair to make the script quicker. Otherwise we
       " just push the token onto the stack and keep parsing.
   
       " No synchronization -> no searchpair optimization
       if !exists('b:erlang_syntax_synced')
         call s:Push(stack, token)

       " We don't have searchpair optimization for '>>'
       elseif token ==# '>>'
         call s:Push(stack, token)

       elseif token ==# 'end'
         let [lnum_new, col_new] = s:SearchEndPair(lnum, curr_col)

         if lnum_new ==# 0
           return s:IndentError('Matching token for "end" not found',
                               \token, stack)
         else
           if lnum_new != lnum
             call s:Log('    Tokenize for "end" <<<<')
             let [lnum, indtokens] = s:TokenizeLine(lnum_new, 'up')
             call s:Log('    >>>> Tokenize for "end"')
           endif

           let [success, i] = s:GetIndtokenAtCol(indtokens, col_new)
           if !success | return i | endif
           let [token, curr_vcol, curr_col] = indtokens[i]
           call s:Log('    Match for "end" in line ' . lnum_new . ': ' .
                     \string(indtokens[i]))
         endif

       else " token is one of the following: ')', ']', '}'

         call s:Push(stack, token)

         " We have to escape '[', because this string will be interpreted as a
         " regexp
         let open_paren = (token ==# ')' ? '(' :
                          \token ==# ']' ? '\[' :
                          \               '{')

         let [lnum_new, col_new] = s:SearchPair(lnum, curr_col,
                                               \open_paren, '', token)

         if lnum_new ==# 0
           return s:IndentError('Matching token not found',
                               \token, stack)
         else
           if lnum_new != lnum
             call s:Log('    Tokenize the opening paren <<<<')
             let [lnum, indtokens] = s:TokenizeLine(lnum_new, 'up')
             call s:Log('    >>>>')
           endif

           let [success, i] = s:GetIndtokenAtCol(indtokens, col_new)
           if !success | return i | endif
           let [token, curr_vcol, curr_col] = indtokens[i]
           call s:Log('    Match in line ' . lnum_new . ': ' .
                     \string(indtokens[i]))

           " Go back to the beginning of the loop and handle the opening paren
           continue
         endif
       endif

     elseif token ==# ';'

       if empty(stack)
         call s:Push(stack, ';')
       elseif index([';', '->', 'when', 'end', 'after', 'catch', 'else'],
                   \stack[0]) != -1
         " Pass:
         "
         " - If the stack top is another ';', then one ';' is
         "   enough.
         " - If the stack top is an '->' or a 'when', then we
         "   should keep that, because they signify the type of the
         "   LTI (branch, condition or guard).
         " - From the indentation point of view, the keyword
         "   (of/catch/after/else/end) before the LTI is what counts, so
         "   if the stack already has a catch/after/else/end, we don't
         "   modify it. This way when we reach case/try/receive/maybe,
         "   there will be at most one of/catch/after/else/end token in
         "   the stack.
       else
         return s:UnexpectedToken(token, stack)
       endif

     elseif token ==# '->'

       if empty(stack) && !last_token_of_line
         call s:Log('    LTI is in expression after arrow -> return')
         return stored_vcol
       elseif empty(stack) || stack[0] ==# ';' || stack[0] ==# 'end'
         " stack = [';']  -> LTI is either a branch or in a guard
         " stack = ['->']  ->  LTI is a condition
         " stack = ['->', ';']  -> LTI is a branch
         call s:Push(stack, '->')
       elseif index(['->', 'when', 'end', 'after', 'catch', 'else'],
                   \stack[0]) != -1
         " Pass:
         "
         " - If the stack top is another '->', then one '->' is
         "   enough.
         " - If the stack top is a 'when', then we should keep
         "   that, because this signifies that LTI is a in a guard.
         " - From the indentation point of view, the keyword
         "   (of/catch/after/else/end) before the LTI is what counts, so
         "   if the stack already has a catch/after/else/end, we don't
         "   modify it. This way when we reach case/try/receive/maybe,
         "   there will be at most one of/catch/after/else/end token in
         "   the stack.
       else
         return s:UnexpectedToken(token, stack)
       endif

     elseif token ==# 'when'

       " Pop all ';' from the top of the stack
       while !empty(stack) && stack[0] ==# ';'
         call s:Pop(stack)
       endwhile

       if empty(stack)
         if semicolon_abscol != ''
           let stored_vcol = semicolon_abscol
         endif
         if !last_token_of_line
           " Example:
           "   when A,
           "        LTI
           let [ret, res] = s:BeginElementFoundIfEmpty(stack, token, curr_vcol,
                                                      \stored_vcol, shiftwidth())
           if ret | return res | endif
         else
           " Example:
           "   when
           "       LTI
           call s:Push(stack, token)
         endif
       elseif index(['->', 'when', 'end', 'after', 'catch', 'else'],
                   \stack[0]) != -1
         " Pass:
         " - If the stack top is another 'when', then one 'when' is
         "   enough.
         " - If the stack top is an '->' or a 'when', then we
         "   should keep that, because they signify the type of the
         "   LTI (branch, condition or guard).
         " - From the indentation point of view, the keyword
         "   (of/catch/after/else/end) before the LTI is what counts, so
         "   if the stack already has a catch/after/else/end, we don't
         "   modify it. This way when we reach case/try/receive/maybe,
         "   there will be at most one of/catch/after/else/end token in
         "   the stack.
       else
         return s:UnexpectedToken(token, stack)
       endif

     elseif token ==# 'of' || token ==# 'after' || token ==# 'else' ||
          \ (token ==# 'catch' && !s:IsCatchStandalone(lnum, i))

       if token ==# 'after' || token ==# 'else'
         " If LTI is between an after/else and the corresponding 'end', then
         " let's return because calculating the indentation based on
         " after/else is enough.
         "
         " Example:
         "   receive A after
         "                 LTI
         "   maybe A else
         "               LTI
         "
         " Note about Emacs compatibility {{{
         "
         " It would be fine to indent the examples above the following way:
         "
         "   receive A after
         "       LTI
         "   maybe A else
         "       LTI
         "
         " We intend it the way above because that is how Emacs does it.
         " Also, this is a bit faster.
         "
         " We are still not 100% Emacs compatible because of placing the
         " 'end' after the indented blocks.
         "
         " Emacs example:
         "
         "   receive A after
         "                 LTI
         "             end,
         "   maybe A else
         "               LTI
         "               end % Yes, it's here (in OTP 25.0, might change
         "                   % later)
         "
         " vim-erlang example:
         "
         "   receive A after
         "                 LTI
         "   end,
         "   maybe A else
         "               LTI
         "   end
         " }}}
         let [ret, res] = s:BeginElementFoundIfEmpty(stack, token, curr_vcol,
                                                    \stored_vcol, shiftwidth())
         if ret | return res | endif
       endif

       if empty(stack) || stack[0] ==# '->' || stack[0] ==# 'when'
         call s:Push(stack, token)
       elseif stack[0] ==# 'catch' || stack[0] ==# 'after' ||
             \stack[0] ==# 'else' || stack[0] ==# 'end'
         " Pass: From the indentation point of view, the keyword
         " (of/catch/after/end) before the LTI is what counts, so
         " if the stack already has a catch/after/end, we don't
         " modify it. This way when we reach case/try/receive,
         " there will be at most one of/catch/after/end token in
         " the stack.
       else
         return s:UnexpectedToken(token, stack)
       endif

     elseif token ==# '||' && empty(stack) && !last_token_of_line

       call s:Log('    LTI is in expression after "||" -> return')
       return stored_vcol

     else
       call s:Log('    Misc token, stack unchanged = ' . string(stack))

     endif

     if empty(stack) || stack[0] ==# '->' || stack[0] ==# 'when'
       let stored_vcol = curr_vcol
       let semicolon_abscol = ''
       call s:Log('    Misc token when the stack is empty or has "->" ' .
                 \'-> setting stored_vcol to ' . stored_vcol)
     elseif stack[0] ==# ';'
       let semicolon_abscol = curr_vcol
       call s:Log('    Setting semicolon-stored_vcol to ' . stored_vcol)
     endif

     let i -= 1
     call s:Log('    Token processed. stored_vcol=' . stored_vcol)

     let last_token_of_line = 0

   endwhile " iteration on tokens in a line

   call s:Log('  Line analyzed. stored_vcol=' . stored_vcol)

   if empty(stack) && stored_vcol != -1 &&
    \ (!empty(indtokens) && indtokens[0][0] != '<string_end>' &&
    \                       indtokens[0][0] != '<quoted_atom_end>')
     call s:Log('    Empty stack at the beginning of the line -> return')
     return stored_vcol
   endif

   let lnum -= 1

 endwhile " iteration on lines

endfunction

" ErlangIndent function {{{1
" =====================

function! ErlangIndent()

 call s:ClearTokenCacheIfNeeded()

 let currline = getline(v:lnum)
 call s:Log('Indenting line ' . v:lnum . ': ' . currline)

 if s:IsLineStringContinuation(v:lnum) || s:IsLineAtomContinuation(v:lnum)
   call s:Log('String or atom continuation found -> ' .
             \'leaving indentation unchanged')
   return -1
 endif

 " If the line starts with the comment, and so is the previous non-blank line
 if currline =~# '^\s*%'
   let lnum = prevnonblank(v:lnum - 1)
   if lnum ==# 0
     call s:Log('First non-empty line of the file -> return 0.')
     return 0
   else
     let ml = matchlist(getline(lnum), '^\(\s*\)%')
     " If the previous line also starts with a comment, then return the same
     " indentation that line has. Otherwise exit from this special "if" and
     " don't care that the current line is a comment.
     if !empty(ml)
       let new_col = s:CalcVCol(ml[1], 0, len(ml[1]) - 1, 0, &tabstop)
       call s:Log('Comment line after another comment line -> ' .
                 \'use same indent: ' . new_col)
       return new_col
     endif
   endif
 endif

 let ml = matchlist(currline,
                   \'^\(\s*\)\(\%(end\|of\|catch\|after\|else\)\>\|[)\]}]\|>>\)')

 " If the line has a special beginning, but not a standalone catch
 if !empty(ml) && !(ml[2] ==# 'catch' && s:IsCatchStandalone(v:lnum, 0))

   let curr_col = len(ml[1])

   " If we can be sure that there is synchronization in the Erlang
   " syntax, we use searchpair to make the script quicker.
   if ml[2] ==# 'end' && exists('b:erlang_syntax_synced')

     let [lnum, col] = s:SearchEndPair(v:lnum, curr_col)

     if lnum ==# 0
       return s:IndentError('Matching token for "end" not found',
                           \'end', [])
     else
       call s:Log('    Tokenize for "end" <<<<')
       let [lnum, indtokens] = s:TokenizeLine(lnum, 'up')
       call s:Log('    >>>> Tokenize for "end"')

       let [success, i] = s:GetIndtokenAtCol(indtokens, col)
       if !success | return i | endif
       let [token, curr_vcol, curr_col] = indtokens[i]
       call s:Log('    Match for "end" in line ' . lnum . ': ' .
                  \string(indtokens[i]))
       return curr_vcol
     endif

   else

     call s:Log("  Line type = 'end'")
     let new_col = s:ErlangCalcIndent(v:lnum - 1,
                                     \[ml[2], 'align_to_begin_element'])
   endif
 else
   call s:Log("  Line type = 'normal'")

   let new_col = s:ErlangCalcIndent(v:lnum - 1, [])
   if currline =~# '^\s*when\>'
     let new_col += 2
   endif
 endif

 if new_col < -1
   call s:Log('WARNING: returning new_col == ' . new_col)
   return g:erlang_unexpected_token_indent
 endif

 return new_col

endfunction

" ErlangShowTokensInLine functions {{{1
" ================================

" These functions are useful during development.

function! ErlangShowTokensInLine(line)
 echo "Line: " . a:line
 let indtokens = s:GetTokensFromLine(a:line, 0, 0, &tabstop)
 echo "Tokens:"
 for it in indtokens
   echo it
 endfor
endfunction

function! ErlangShowTokensInCurrentLine()
 return ErlangShowTokensInLine(getline('.'))
endfunction

" Cleanup {{{1
" =======

let &cpo = s:cpo_save
unlet s:cpo_save

" vim: sw=2 et fdm=marker