libraries/luaformatter/formatter.lua - ldt/org.eclipse.ldt - Git at Google

 --------------------------------------------------------------------------------
 -- Copyright (c) 2011, 2014 Sierra Wireless and others.
 -- All rights reserved. This program and the accompanying materials
 -- are made available under the terms of the Eclipse Public License v1.0
 -- which accompanies this distribution, and is available at
 -- http://www.eclipse.org/legal/epl-v10.html
 --
 -- Contributors:
 --     Sierra Wireless - initial API and implementation
 --------------------------------------------------------------------------------

 --------------------------------------------------------------------------------
 -- Uses Metalua capabilities to indent code and provide source code offset
 -- semantic depth.
 --
 -- @module formatter
 --
 --------------------------------------------------------------------------------

 local M = {}
 require 'metalua.loader'
 local math = require 'math'
 local mlc  = require 'metalua.compiler'.new()
 local Q    = require 'metalua.treequery'

 local COMMENT = '--'

 --------------------------------------------------------------------------------
 -- Format utilities
 --------------------------------------------------------------------------------

 ---
 -- Comment adjusted first line and first offset of a node.
 --
 -- @return #number, #number
 local function getfirstline(node, ignorecomments)
   -- Consider preceding comments as part of current chunk
   -- WARNING: This is NOT the default in Metalua
   local first, offset
   local offsets = node.lineinfo
   if offsets.first.comments and not ignorecomments then
     first = offsets.first.comments.lineinfo.first.line
     offset = offsets.first.comments.lineinfo.first.offset
   else
     -- Regular node
     first = offsets.first.line
     offset = offsets.first.offset
   end
   return first, offset
 end

 ---
 -- Last line of a node.
 --
 -- @return #number
 local function getlastline(node)
   return node.lineinfo.last.line , node.lineinfo.last.offset
 end

 local function indent(cfg, st, startline, startindex, endline, parent)

   -- Indent following lines when current one does not start with first statement
   -- of current block.
   if not cfg.source:sub(1,startindex-1):find("[\r\n]%s*$") then
     startline = startline + 1
   end

   -- Nothing interesting to do
   if endline < startline then
     return
   end

   -- Indent block first line
   st.indentation[startline] = true

   -- Restore indentation
   if not st.unindentation[endline+1] then
     -- Only when not performed by a higher node
     st.unindentation[endline+1] = getfirstline(parent)
   end
 end

 ---
 -- Indent all lines of an expression list.
 local function indentexprlist(cfg, st, node, parent, ignorecomments)
   local endline = getlastline(node)
   local startline, startindex = getfirstline(node, ignorecomments)
   indent(cfg, st, startline, startindex, endline, parent)
 end

 ---
 -- Indents `Local and `Set
 local function assignments(cfg, st, node)

   -- Indent only when node spreads across several lines
   local nodestart = getfirstline(node, true)
   local nodeend = getlastline(node)
   if nodestart >= nodeend then
     return
   end

   -- Format it
   local lhs, exprs = unpack(node)
   if #exprs == 0 then
     -- Regular `Local handling
     indentexprlist(cfg, st, lhs, node)
     -- Avoid problems and format functions later.
   elseif not (#exprs == 1 and exprs[1].tag == 'Function') then

     -- for local, indent lhs
     if node.tag == 'Local' then

       -- Else way, indent LHS and expressions like a single chunk.
       local endline = getlastline(exprs)
       local startline, startindex = getfirstline(lhs, true)
       indent(cfg, st, startline, startindex, endline, node)

     end

     -- In this chunk indent expressions one more.
     indentexprlist(cfg, st, exprs, node)
   end
 end

 ---
 -- Indents parameters
 --
 -- @param callable  Node containing the params
 -- @param firstparam first parameter of the given callable
 local function indentparams(cfg, st, firstparam, lastparam, parent)

   -- Determine parameters first line
   local paramstartline,paramstartindex = getfirstline(firstparam)

   -- Determine parameters last line
   local paramlastline = getlastline(lastparam)

   -- indent
   indent(cfg, st, paramstartline, paramstartindex, paramlastline, parent)
 end

 ---
 -- Indent all lines of a chunk.
 local function indentchunk(cfg, st, node, parent)

   -- Get regular start
   local startline, startindex = getfirstline(node[1])

   -- Handle trailing comments as they were statements
   local endline
   local lastnode = node[#node]
   if lastnode.lineinfo.last.comments then
     endline = lastnode.lineinfo.last.comments.lineinfo.last.line
   else
     endline = lastnode.lineinfo.last.line
   end

   indent(cfg, st, startline, startindex, endline, parent)
 end

 --------------------------------------------------------------------------------
 -- Expressions formatters
 --------------------------------------------------------------------------------
 local case = { }

 function case.String(cfg, st, node)
   local firstline, _ = getfirstline(node,true)
   local lastline = getlastline(node)
   for line=firstline+1, lastline do
     st.indentation[line]=false
   end
 end

 function case.Table(cfg, st, node)

   if not cfg.indenttable then
     return
   end

   -- Format only inner values across several lines
   local firstline, firstindex = getfirstline(node,true)
   local lastline = getlastline(node)
   if #node > 0 and firstline < lastline then

     -- Determine first line to format
     local firstnode = unpack(node)
     local childfirstline, childfirstindex = getfirstline(firstnode)

     -- Determine last line to format
     local lastnode = #node == 1 and firstnode or node[ #node ]
     local childlastline = getlastline(lastnode)

     -- Actual formating
     indent(cfg, st, childfirstline, childfirstindex, childlastline, node)
   end
 end

 --------------------------------------------------------------------------------
 -- Statements formatters
 --------------------------------------------------------------------------------
 function case.Call(cfg, st, node)
   local expr, firstparam = unpack(node)
   if firstparam then
     indentparams(cfg, st, firstparam, node[#node], node)
   end
 end

 function case.Do(cfg, st, node, parent)
   -- Ignore empty node
   if #node == 0 or not parent then
     return
   end
   indentchunk(cfg, st, node, parent)
 end

 function case.Forin(cfg, st, node)
   local ids, iterator, _ = unpack(node)
   indentexprlist(cfg, st, ids, node)
   indentexprlist(cfg, st, iterator, node)
 end

 function case.Fornum(cfg, st, node)
   -- Format from variable name to last expressions
   local var, init, limit, range = unpack(node)
   local startline, startindex   = getfirstline(var)

   -- Take range as last expression, when not available limit will do
   local lastexpr = range.tag and range or limit
   indent(cfg, st, startline, startindex, getlastline(lastexpr), node)
 end

 function case.Function(cfg, st, node)
   local params, chunk = unpack(node)
   indentexprlist(cfg, st, params, node)
 end

 function case.Index(cfg, st, node, parent)

   -- Bug 422778 - [ast] Missing a lineinfo attribute on one Index
   -- the following if is a workaround avoid a nil exception but the formatting
   -- of the current node is avoided.
   if not node.lineinfo then
     return
   end
   -- avoid indent if the index is on one line
   local nodestartline = node.lineinfo.first.line
   local nodeendline = node.lineinfo.last.line
   if nodeendline == nodestartline then
     return
   end

   local left, right = unpack(node)
   -- Bug 422778 [ast] Missing a lineinfo attribute on one Index
   -- the following line is a workaround avoid a nil exception but the
   -- formatting of the current node is avoided.
   if left.lineinfo then
     local leftendline, leftendoffset = getlastline(left)
     -- For Call,Set and Local nodes we want to indent to end of the parent node
     -- not only the index itself
     local parentisassignment = parent.tag == 'Set' or parent.tag == 'Local'
     local parenthaschild = parent[1] and #parent[1] ==  1
     if (parent[1] == node and parent.tag == 'Call') or
       (parentisassignment and parenthaschild and parent[1][1] == node)
     then
       local parentendline = getlastline(parent)
       indent(cfg, st, leftendline, leftendoffset+1, parentendline, parent)
     else
       local rightendline = getlastline(right)
       indent(cfg, st, leftendline, leftendoffset+1, rightendline, node)
     end
   end

 end

 function case.If(cfg, st, node)
   -- Indent only conditions, chunks are already taken care of.
   local nodesize = #node
   for conditionposition=1, nodesize-(nodesize%2), 2 do
     indentexprlist(cfg, st, node[conditionposition], node)
   end
 end

 function case.Invoke(cfg, st, node)
   local expr, str, firstparam = unpack(node)

   --indent str
   local exprendline, exprendoffset = getlastline(expr)
   local nodeendline = getlastline(node)
   indent(cfg, st, exprendline, exprendoffset+1, nodeendline, node)

   --indent parameters
   if firstparam then
     indentparams(cfg, st, firstparam, node[#node], str)
   end

 end

 function case.Repeat(cfg, st, node)
   local _, expr = unpack(node)
   indentexprlist(cfg, st, expr, node)
 end

 function case.Return(cfg, st, node, parent)
   if #node > 0 then
     indentchunk(cfg, st, node, parent)
   end
 end

 case.Local = assignments
 case.Set   = assignments

 function case.While(cfg, st, node)
   local expr, _ = unpack(node)
   indentexprlist(cfg, st, expr, node)
 end

 --------------------------------------------------------------------------------
 -- Calculate all indent level
 -- @param Source code to analyze
 -- @return #table {linenumber = indentationlevel}
 -- @usage local depth = format.indentLevel("local var")
 --------------------------------------------------------------------------------
 local function getindentlevel(source, indenttable)

   -----------------------------------------------------------------------------
   -- Walk through AST
   --
   -- Walking the AST, we store which lines deserve one and always one
   -- indentation.
   --
   -- We will not indent back. To obtain a smaller indentation, we will refer to
   -- a less indented preceding line.
   --
   -- Why so complicated?
   -- We use two tables as `state` simply for handling the case of one line
   -- indentation.
   -- We choose to use reference to a preceding line to avoid handling
   -- indent-back computation and mistakes. When leaving a node after formatting
   -- it, we simply use indentation of before entering this node.
   -----------------------------------------------------------------------------
   local configuration = {
     indenttable = indenttable,
     source = source
   }

   --
   local state = {
     -- Indentations line numbers
     indentation = { },
     -- Key:   Line number to indent back.
     -- Value: Previous line number, it has the indentation depth wanted.
     unindentation = { },
     -- cache of handled comment
     handledcomments = { },
   }

   local function onNode(...)
     local node = (...)
     local tag = node.tag
     if not tag then case.Do(configuration, state, ...) else
       local f = case[tag]
       if f then f(configuration, state, ...) end
     end

     -- Do not indent long comment
     -- -----------------------------------------
     -- Define function to deal with long comment
     local function indentlongcomment (comment)
       -- If this is a long comment
       -- (Only long comment has value at index 2 : this is the number of '=' for this comment)
       if comment[2] and not state.handledcomments[comment]
         and comment.lineinfo and comment.lineinfo.first and comment.lineinfo.first.line
         and comment.lineinfo.last and comment.lineinfo.last.line then

         state.handledcomments[comment] = true
         for i=comment.lineinfo.first.line+1, comment.lineinfo.last.line do
           state.indentation[i] = false
         end
       end
     end
     -- manage comment before, then after this node
     if node.lineinfo and node.lineinfo.first and node.lineinfo.first.comments then
       for _, comment in ipairs(node.lineinfo.first.comments) do
         indentlongcomment(comment)
       end
     end
     if node.lineinfo and node.lineinfo.last and node.lineinfo.last.comments then
       for _, comment in ipairs(node.lineinfo.last.comments) do
         indentlongcomment(comment)
       end
     end
   end

   local ast = mlc:src_to_ast(source)
   Q(ast) :foreach(onNode)

   -- Built depth table
   local currentdepth = 0
   local depthtable = {}
   for line=1, getlastline(ast[#ast]) do

     -- Restore depth
     if state.unindentation[line] then
       currentdepth = depthtable[state.unindentation[line]]
     end

     -- Indent
     if state.indentation[line] then
       currentdepth = currentdepth + 1
       depthtable[line] = currentdepth
     elseif state.indentation[line] == false then
       -- Ignore any kind of indentation
       depthtable[line] = false
     else
       -- Use current indentation
       depthtable[line] = currentdepth
     end

   end
   return depthtable
 end

 --------------------------------------------------------------------------------
 -- Trim white spaces before and after given string
 --
 -- @usage local trimmedstr = trim('          foo')
 -- @param #string string to trim
 -- @return #string string trimmed
 --------------------------------------------------------------------------------
 local function trim(string)
   local pattern = "^(%s*)(.*)"
   local _, strip =  string:match(pattern)
   if not strip then return string end
   local restrip
   _, restrip = strip:reverse():match(pattern)
   return restrip and restrip:reverse() or strip
 end

 --------------------------------------------------------------------------------
 -- Provides position of next end of line
 --
 -- @param #string str Where to seek for end of line
 -- @param #number strstart Search starting index
 -- @return #number, #number Start and end of end of line
 -- @return #nil When no end of line is found
 --------------------------------------------------------------------------------
 local delimiterposition = function (str, strstart)
   local starts = {}
   local ends = {}
   for _, delimiter in ipairs({'\r\n', '\n', '\r'}) do
     local dstart, dend = str:find(delimiter, strstart, true)
     if dstart and not ends[dstart] then
       starts[#starts + 1] = dstart
       ends[dstart] = dend
     end
   end
   if #starts > 0 then
     local min = math.min( unpack(starts) )
     return min, ends[min]
   end
 end

 --------------------------------------------------------------------------------
 -- Indent Lua Source Code.
 --
 -- @function [parent=#formatter] indentcode
 -- @param #string source Source code to format
 -- @param #string delimiter Delimiter used in resulting formatted source
 -- @param indenttable true if you want to indent in table
 -- @param ...
 -- @return #string Formatted code
 -- @return #nil, #string In case of error
 -- @usage indentCode('local var', '\n', true, '\t')
 -- @usage indentCode('local var', '\n', true, --[[tabulationSize]]4, --[[indentationSize]]2)
 --------------------------------------------------------------------------------
 function M.indentcode(source, delimiter,indenttable, ...)

   --
   -- Create function which will generate indentation
   --
   local tabulation
   if select('#', ...) > 1 then
     local tabSize = select(1, ...)
     local indentationSize = select(2, ...)
     -- When tabulation size and indentation size is given, tabulation is
     -- composed of tabulation and spaces
     tabulation = function(depth)
       local range = depth * indentationSize
       local tabCount = math.floor(range / tabSize)
       local spaceCount = range % tabSize
       local tab = '\t'
       local space = ' '
       return tab:rep(tabCount) .. space:rep(spaceCount)
     end
   else
     local char = select(1, ...)
     -- When tabulation character is given, this character will be duplicated
     -- according to length
     tabulation = function (depth) return char:rep(depth) end
   end

   -- Delimiter position table
   -- Initialization represent string's start offset
   local positions = {0}

   -- Handle shebang
   local shebang = source:match('^#')
   if shebang then
     -- Simply comment shebang when formating
     source = table.concat({COMMENT, source})
   end

   --
   -- Seek for delimiters positions
   --
   local sourcePosition = 1
   repeat
     -- Find end of line
     local delimiterStart, delimiterEnd = delimiterposition(source,
       sourcePosition)
     if delimiterStart then
       if delimiterEnd < #source then
         positions[#positions + 1] = delimiterStart
       end
       sourcePosition = delimiterEnd + 1
     end
   until not delimiterStart

   -- No need for indentation, when no delimiter has been found
   if #positions < 2 then
     return shebang and source:sub(1 + #COMMENT) or source
   end

   -- calculate indentation
   local linetodepth = getindentlevel(source, indenttable)

   -- Concatenate string with right indentation
   local indented = {}
   for position=1, #positions do
     -- Extract source code line
     local offset = positions[position]
     -- Get the interval between two positions
     local rawline
     if positions[position + 1] then
       rawline = source:sub(offset + 1, positions[position + 1] -1)
     else
       -- From current position to end of line
       rawline = source:sub(offset + 1)
     end

     -- Trim white spaces
     local indentcount = linetodepth[position]
     if not indentcount then
       indented[#indented+1] = rawline
     else
       -- Indent only when there is code on the line
       local line = trim(rawline)
       if #line > 0 then

         -- Prefix with right indentation
         if indentcount > 0 then
           indented[#indented+1] = tabulation( indentcount )
         end

         -- Append trimmed source code
         indented[#indented+1] = line
       end
     end

     -- Append new line
     if position < #positions then
       indented[#indented+1] = delimiter
     end
   end

   -- Ensure single final new line
   if #indented > 0 and not indented[#indented]:match('%s$') then
     indented[#indented + 1] = delimiter
   end

   -- Uncomment shebang when needed
   local formattedcode = table.concat(indented)
   if shebang and #formattedcode then
     return formattedcode:sub(1 + #COMMENT)
   end
   return formattedcode
 end

 return M
	--------------------------------------------------------------------------------
	-- Copyright (c) 2011, 2014 Sierra Wireless and others.
	-- All rights reserved. This program and the accompanying materials
	-- are made available under the terms of the Eclipse Public License v1.0
	-- which accompanies this distribution, and is available at
	-- http://www.eclipse.org/legal/epl-v10.html
	--
	-- Contributors:
	-- Sierra Wireless - initial API and implementation
	--------------------------------------------------------------------------------

	--------------------------------------------------------------------------------
	-- Uses Metalua capabilities to indent code and provide source code offset
	-- semantic depth.
	--
	-- @module formatter
	--
	--------------------------------------------------------------------------------

	local M = {}
	require 'metalua.loader'
	local math = require 'math'
	local mlc = require 'metalua.compiler'.new()
	local Q = require 'metalua.treequery'

	local COMMENT = '--'

	--------------------------------------------------------------------------------
	-- Format utilities
	--------------------------------------------------------------------------------

	---
	-- Comment adjusted first line and first offset of a node.
	--
	-- @return #number, #number
	local function getfirstline(node, ignorecomments)
	-- Consider preceding comments as part of current chunk
	-- WARNING: This is NOT the default in Metalua
	local first, offset
	local offsets = node.lineinfo
	if offsets.first.comments and not ignorecomments then
	first = offsets.first.comments.lineinfo.first.line
	offset = offsets.first.comments.lineinfo.first.offset
	else
	-- Regular node
	first = offsets.first.line
	offset = offsets.first.offset
	end
	return first, offset
	end

	---
	-- Last line of a node.
	--
	-- @return #number
	local function getlastline(node)
	return node.lineinfo.last.line , node.lineinfo.last.offset
	end

	local function indent(cfg, st, startline, startindex, endline, parent)

	-- Indent following lines when current one does not start with first statement
	-- of current block.
	if not cfg.source:sub(1,startindex-1):find("[\r\n]%s*$") then
	startline = startline + 1
	end

	-- Nothing interesting to do
	if endline < startline then
	return
	end

	-- Indent block first line
	st.indentation[startline] = true

	-- Restore indentation
	if not st.unindentation[endline+1] then
	-- Only when not performed by a higher node
	st.unindentation[endline+1] = getfirstline(parent)
	end
	end

	---
	-- Indent all lines of an expression list.
	local function indentexprlist(cfg, st, node, parent, ignorecomments)
	local endline = getlastline(node)
	local startline, startindex = getfirstline(node, ignorecomments)
	indent(cfg, st, startline, startindex, endline, parent)
	end

	---
	-- Indents `Local and `Set
	local function assignments(cfg, st, node)

	-- Indent only when node spreads across several lines
	local nodestart = getfirstline(node, true)
	local nodeend = getlastline(node)
	if nodestart >= nodeend then
	return
	end

	-- Format it
	local lhs, exprs = unpack(node)
	if #exprs == 0 then
	-- Regular `Local handling
	indentexprlist(cfg, st, lhs, node)
	-- Avoid problems and format functions later.
	elseif not (#exprs == 1 and exprs[1].tag == 'Function') then

	-- for local, indent lhs
	if node.tag == 'Local' then

	-- Else way, indent LHS and expressions like a single chunk.
	local endline = getlastline(exprs)
	local startline, startindex = getfirstline(lhs, true)
	indent(cfg, st, startline, startindex, endline, node)

	end

	-- In this chunk indent expressions one more.
	indentexprlist(cfg, st, exprs, node)
	end
	end

	---
	-- Indents parameters
	--
	-- @param callable Node containing the params
	-- @param firstparam first parameter of the given callable
	local function indentparams(cfg, st, firstparam, lastparam, parent)

	-- Determine parameters first line
	local paramstartline,paramstartindex = getfirstline(firstparam)

	-- Determine parameters last line
	local paramlastline = getlastline(lastparam)

	-- indent
	indent(cfg, st, paramstartline, paramstartindex, paramlastline, parent)
	end

	---
	-- Indent all lines of a chunk.
	local function indentchunk(cfg, st, node, parent)

	-- Get regular start
	local startline, startindex = getfirstline(node[1])

	-- Handle trailing comments as they were statements
	local endline
	local lastnode = node[#node]
	if lastnode.lineinfo.last.comments then
	endline = lastnode.lineinfo.last.comments.lineinfo.last.line
	else
	endline = lastnode.lineinfo.last.line
	end

	indent(cfg, st, startline, startindex, endline, parent)
	end

	--------------------------------------------------------------------------------
	-- Expressions formatters
	--------------------------------------------------------------------------------
	local case = { }

	function case.String(cfg, st, node)
	local firstline, _ = getfirstline(node,true)
	local lastline = getlastline(node)
	for line=firstline+1, lastline do
	st.indentation[line]=false
	end
	end

	function case.Table(cfg, st, node)

	if not cfg.indenttable then
	return
	end

	-- Format only inner values across several lines
	local firstline, firstindex = getfirstline(node,true)
	local lastline = getlastline(node)
	if #node > 0 and firstline < lastline then

	-- Determine first line to format
	local firstnode = unpack(node)
	local childfirstline, childfirstindex = getfirstline(firstnode)

	-- Determine last line to format
	local lastnode = #node == 1 and firstnode or node[ #node ]
	local childlastline = getlastline(lastnode)

	-- Actual formating
	indent(cfg, st, childfirstline, childfirstindex, childlastline, node)
	end
	end

	--------------------------------------------------------------------------------
	-- Statements formatters
	--------------------------------------------------------------------------------
	function case.Call(cfg, st, node)
	local expr, firstparam = unpack(node)
	if firstparam then
	indentparams(cfg, st, firstparam, node[#node], node)
	end
	end

	function case.Do(cfg, st, node, parent)
	-- Ignore empty node
	if #node == 0 or not parent then
	return
	end
	indentchunk(cfg, st, node, parent)
	end

	function case.Forin(cfg, st, node)
	local ids, iterator, _ = unpack(node)
	indentexprlist(cfg, st, ids, node)
	indentexprlist(cfg, st, iterator, node)
	end

	function case.Fornum(cfg, st, node)
	-- Format from variable name to last expressions
	local var, init, limit, range = unpack(node)
	local startline, startindex = getfirstline(var)

	-- Take range as last expression, when not available limit will do
	local lastexpr = range.tag and range or limit
	indent(cfg, st, startline, startindex, getlastline(lastexpr), node)
	end

	function case.Function(cfg, st, node)
	local params, chunk = unpack(node)
	indentexprlist(cfg, st, params, node)
	end

	function case.Index(cfg, st, node, parent)

	-- Bug 422778 - [ast] Missing a lineinfo attribute on one Index
	-- the following if is a workaround avoid a nil exception but the formatting
	-- of the current node is avoided.
	if not node.lineinfo then
	return
	end
	-- avoid indent if the index is on one line
	local nodestartline = node.lineinfo.first.line
	local nodeendline = node.lineinfo.last.line
	if nodeendline == nodestartline then
	return
	end

	local left, right = unpack(node)
	-- Bug 422778 [ast] Missing a lineinfo attribute on one Index
	-- the following line is a workaround avoid a nil exception but the
	-- formatting of the current node is avoided.
	if left.lineinfo then
	local leftendline, leftendoffset = getlastline(left)
	-- For Call,Set and Local nodes we want to indent to end of the parent node
	-- not only the index itself
	local parentisassignment = parent.tag == 'Set' or parent.tag == 'Local'
	local parenthaschild = parent[1] and #parent[1] == 1
	if (parent[1] == node and parent.tag == 'Call') or
	(parentisassignment and parenthaschild and parent[1][1] == node)
	then
	local parentendline = getlastline(parent)
	indent(cfg, st, leftendline, leftendoffset+1, parentendline, parent)
	else
	local rightendline = getlastline(right)
	indent(cfg, st, leftendline, leftendoffset+1, rightendline, node)
	end
	end

	end

	function case.If(cfg, st, node)
	-- Indent only conditions, chunks are already taken care of.
	local nodesize = #node
	for conditionposition=1, nodesize-(nodesize%2), 2 do
	indentexprlist(cfg, st, node[conditionposition], node)
	end
	end

	function case.Invoke(cfg, st, node)
	local expr, str, firstparam = unpack(node)

	--indent str
	local exprendline, exprendoffset = getlastline(expr)
	local nodeendline = getlastline(node)
	indent(cfg, st, exprendline, exprendoffset+1, nodeendline, node)

	--indent parameters
	if firstparam then
	indentparams(cfg, st, firstparam, node[#node], str)
	end

	end

	function case.Repeat(cfg, st, node)
	local _, expr = unpack(node)
	indentexprlist(cfg, st, expr, node)
	end

	function case.Return(cfg, st, node, parent)
	if #node > 0 then
	indentchunk(cfg, st, node, parent)
	end
	end

	case.Local = assignments
	case.Set = assignments

	function case.While(cfg, st, node)
	local expr, _ = unpack(node)
	indentexprlist(cfg, st, expr, node)
	end

	--------------------------------------------------------------------------------
	-- Calculate all indent level
	-- @param Source code to analyze
	-- @return #table {linenumber = indentationlevel}
	-- @usage local depth = format.indentLevel("local var")
	--------------------------------------------------------------------------------
	local function getindentlevel(source, indenttable)

	-----------------------------------------------------------------------------
	-- Walk through AST
	--
	-- Walking the AST, we store which lines deserve one and always one
	-- indentation.
	--
	-- We will not indent back. To obtain a smaller indentation, we will refer to
	-- a less indented preceding line.
	--
	-- Why so complicated?
	-- We use two tables as `state` simply for handling the case of one line
	-- indentation.
	-- We choose to use reference to a preceding line to avoid handling
	-- indent-back computation and mistakes. When leaving a node after formatting
	-- it, we simply use indentation of before entering this node.
	-----------------------------------------------------------------------------
	local configuration = {
	indenttable = indenttable,
	source = source
	}

	--
	local state = {
	-- Indentations line numbers
	indentation = { },
	-- Key: Line number to indent back.
	-- Value: Previous line number, it has the indentation depth wanted.
	unindentation = { },
	-- cache of handled comment
	handledcomments = { },
	}

	local function onNode(...)
	local node = (...)
	local tag = node.tag
	if not tag then case.Do(configuration, state, ...) else
	local f = case[tag]
	if f then f(configuration, state, ...) end
	end

	-- Do not indent long comment
	-- -----------------------------------------
	-- Define function to deal with long comment
	local function indentlongcomment (comment)
	-- If this is a long comment
	-- (Only long comment has value at index 2 : this is the number of '=' for this comment)
	if comment[2] and not state.handledcomments[comment]
	and comment.lineinfo and comment.lineinfo.first and comment.lineinfo.first.line
	and comment.lineinfo.last and comment.lineinfo.last.line then

	state.handledcomments[comment] = true
	for i=comment.lineinfo.first.line+1, comment.lineinfo.last.line do
	state.indentation[i] = false
	end
	end
	end
	-- manage comment before, then after this node
	if node.lineinfo and node.lineinfo.first and node.lineinfo.first.comments then
	for _, comment in ipairs(node.lineinfo.first.comments) do
	indentlongcomment(comment)
	end
	end
	if node.lineinfo and node.lineinfo.last and node.lineinfo.last.comments then
	for _, comment in ipairs(node.lineinfo.last.comments) do
	indentlongcomment(comment)
	end
	end
	end

	local ast = mlc:src_to_ast(source)
	Q(ast) :foreach(onNode)

	-- Built depth table
	local currentdepth = 0
	local depthtable = {}
	for line=1, getlastline(ast[#ast]) do

	-- Restore depth
	if state.unindentation[line] then
	currentdepth = depthtable[state.unindentation[line]]
	end

	-- Indent
	if state.indentation[line] then
	currentdepth = currentdepth + 1
	depthtable[line] = currentdepth
	elseif state.indentation[line] == false then
	-- Ignore any kind of indentation
	depthtable[line] = false
	else
	-- Use current indentation
	depthtable[line] = currentdepth
	end

	end
	return depthtable
	end

	--------------------------------------------------------------------------------
	-- Trim white spaces before and after given string
	--
	-- @usage local trimmedstr = trim(' foo')
	-- @param #string string to trim
	-- @return #string string trimmed
	--------------------------------------------------------------------------------
	local function trim(string)
	local pattern = "^(%s)(.)"
	local _, strip = string:match(pattern)
	if not strip then return string end
	local restrip
	_, restrip = strip:reverse():match(pattern)
	return restrip and restrip:reverse() or strip
	end

	--------------------------------------------------------------------------------
	-- Provides position of next end of line
	--
	-- @param #string str Where to seek for end of line
	-- @param #number strstart Search starting index
	-- @return #number, #number Start and end of end of line
	-- @return #nil When no end of line is found
	--------------------------------------------------------------------------------
	local delimiterposition = function (str, strstart)
	local starts = {}
	local ends = {}
	for _, delimiter in ipairs({'\r\n', '\n', '\r'}) do
	local dstart, dend = str:find(delimiter, strstart, true)
	if dstart and not ends[dstart] then
	starts[#starts + 1] = dstart
	ends[dstart] = dend
	end
	end
	if #starts > 0 then
	local min = math.min( unpack(starts) )
	return min, ends[min]
	end
	end

	--------------------------------------------------------------------------------
	-- Indent Lua Source Code.
	--
	-- @function [parent=#formatter] indentcode
	-- @param #string source Source code to format
	-- @param #string delimiter Delimiter used in resulting formatted source
	-- @param indenttable true if you want to indent in table
	-- @param ...
	-- @return #string Formatted code
	-- @return #nil, #string In case of error
	-- @usage indentCode('local var', '\n', true, '\t')
	-- @usage indentCode('local var', '\n', true, --[[tabulationSize]]4, --[[indentationSize]]2)
	--------------------------------------------------------------------------------
	function M.indentcode(source, delimiter,indenttable, ...)

	--
	-- Create function which will generate indentation
	--
	local tabulation
	if select('#', ...) > 1 then
	local tabSize = select(1, ...)
	local indentationSize = select(2, ...)
	-- When tabulation size and indentation size is given, tabulation is
	-- composed of tabulation and spaces
	tabulation = function(depth)
	local range = depth * indentationSize
	local tabCount = math.floor(range / tabSize)
	local spaceCount = range % tabSize
	local tab = '\t'
	local space = ' '
	return tab:rep(tabCount) .. space:rep(spaceCount)
	end
	else
	local char = select(1, ...)
	-- When tabulation character is given, this character will be duplicated
	-- according to length
	tabulation = function (depth) return char:rep(depth) end
	end

	-- Delimiter position table
	-- Initialization represent string's start offset
	local positions = {0}

	-- Handle shebang
	local shebang = source:match('^#')
	if shebang then
	-- Simply comment shebang when formating
	source = table.concat({COMMENT, source})
	end

	--
	-- Seek for delimiters positions
	--
	local sourcePosition = 1
	repeat
	-- Find end of line
	local delimiterStart, delimiterEnd = delimiterposition(source,
	sourcePosition)
	if delimiterStart then
	if delimiterEnd < #source then
	positions[#positions + 1] = delimiterStart
	end
	sourcePosition = delimiterEnd + 1
	end
	until not delimiterStart

	-- No need for indentation, when no delimiter has been found
	if #positions < 2 then
	return shebang and source:sub(1 + #COMMENT) or source
	end

	-- calculate indentation
	local linetodepth = getindentlevel(source, indenttable)

	-- Concatenate string with right indentation
	local indented = {}
	for position=1, #positions do
	-- Extract source code line
	local offset = positions[position]
	-- Get the interval between two positions
	local rawline
	if positions[position + 1] then
	rawline = source:sub(offset + 1, positions[position + 1] -1)
	else
	-- From current position to end of line
	rawline = source:sub(offset + 1)
	end

	-- Trim white spaces
	local indentcount = linetodepth[position]
	if not indentcount then
	indented[#indented+1] = rawline
	else
	-- Indent only when there is code on the line
	local line = trim(rawline)
	if #line > 0 then

	-- Prefix with right indentation
	if indentcount > 0 then
	indented[#indented+1] = tabulation( indentcount )
	end

	-- Append trimmed source code
	indented[#indented+1] = line
	end
	end

	-- Append new line
	if position < #positions then
	indented[#indented+1] = delimiter
	end
	end

	-- Ensure single final new line
	if #indented > 0 and not indented[#indented]:match('%s$') then
	indented[#indented + 1] = delimiter
	end

	-- Uncomment shebang when needed
	local formattedcode = table.concat(indented)
	if shebang and #formattedcode then
	return formattedcode:sub(1 + #COMMENT)
	end
	return formattedcode
	end

	return M