38 files changed, 1510 insertions, 109 deletions

diff --git a/src/Bindings/.gitignore b/src/Bindings/.gitignore
index 711ae9c3a..16f9db55d 100644
--- a/src/Bindings/.gitignore
+++ b/src/Bindings/.gitignore
@@ -1,3 +1,4 @@
+docs/
 lua51.dll
 LuaState_Declaration.inc
 LuaState_Implementation.cpp
diff --git a/src/Bindings/BindingsProcessor.lua b/src/Bindings/BindingsProcessor.lua
index e7b909ded..28a6a053c 100644
--- a/src/Bindings/BindingsProcessor.lua
+++ b/src/Bindings/BindingsProcessor.lua
@@ -3,11 +3,68 @@
 
 -- Implements additional processing that is done while generating the Lua bindings
 
+--[[
+The primary purpose of this file is to provide transformations for ToLua - it is loaded by ToLua++
+before processing the C++ code.
+
+This file can also be used as a standalone Lua program to actually generate the bindings, it invokes
+ToLua++ if executed by a regular Lua interpreter
+
+The transformations implemented:
+	- Modify ToLua++ behavior so that it doesn't generate bindings for private and protected members
+	- Export additional files to be included in cLuaState:
+		- Forward declarations and typedefs for custom classes' pointers
+		- Pushing and popping of bindings' classes
+
+To parse DoxyComments, the preprocessor first replaces them with markers and then the parser uses
+those markers to apply the DoxyComment to the next or previous item in the container, based on
+the DoxyComment type.
+
+Placeholders in use (i = internal ToLua++):
+	- \1 and \2: (i) Embedded Lua code
+	- \3 and \4: (i) Embedded C code ("<>")
+	- \5 and \6: (i) Embedded C code ("{}")
+	- \17 and \18: DoxyComment for next item ("/** ... */") via an ID lookup
+	- \19 and \20: DocyComment for previous item ("///< ... \n") via an ID lookup
+--]]
+
+
+
+
+
+--- Invokes the ToLua++ parser
+-- Called when this script detects it has been run outside of ToLua++'s processing
+local function invokeToLua()
+	-- The values used by ToLua scripts, normally filled from the cmdline params:
+	flags =
+	{
+		L = "BindingsProcessor.lua",
+		o = "Bindings.cpp",
+		H = "Bindings.h",
+		f = "AllToLua.pkg",
+		-- P = true,  -- Prints the structure to stdout, doesn't generate cpp file
+	}
+	_extra_parameters = {}
+	TOLUA_VERSION = "tolua++-1.0.92"
+	TOLUA_LUA_VERSION = "Lua 5.1"
+
+	-- Path to the ToLua scripts
+	path = "../../lib/tolua++/src/bin/lua/"
+
+	-- Run the ToLua processing:
+	dofile(path .. "all.lua")
+end
+
 
 
 
 
-local access = {public = 0, protected = 1, private = 2}
+local access =
+{
+	public = 0,
+	protected = 1,
+	private = 2
+}
 
 
 
@@ -24,20 +81,73 @@ local g_HasCustomPushImplementation =
 
 
 
-function parser_hook(s)
-	local container = classContainer.curr -- get the current container
+--- Array-table of forward DoxyComments that are replaced in preprocess_hook() and substituted back in parser_hook()
+-- We need to use a lookup table because the comments themselves may contain "//" which the preprocessor
+-- would eliminate, thus breaking the code
+-- The "n" member is a counter for faster insertion
+local g_ForwardDoxyComments =
+{
+	n = 0
+}
+
+
+--- Array-table of backward DoxyComments that are replaced in preprocess_hook() and substituted back in parser_hook()
+-- We need to use a lookup table because the comments themselves may contain "//" which the preprocessor
+-- would eliminate, thus breaking the code
+-- The "n" member is a counter for faster insertion
+local g_BackwardDoxyComments =
+{
+	n = 0,
+}
+
+
+
+
 
-	-- process access-specifying labels (public, private, etc)
+--- Provides extra parsing in addition to ToLua++'s own
+-- Called by ToLua++ each time it extracts the next piece of code to parse
+-- a_Code is the string representing the code to be parsed
+-- The return value is the remaining code to be parsed in the next iteration
+-- Processes the class access specifiers (public, protected, private), and doxycomments
+function parser_hook(a_Code)
+	-- Process access-specifying labels (public, private, etc)
 	do
-		local b, e, label = string.find(s, "^%s*(%w*)%s*:[^:]") -- we need to check for [^:], otherwise it would match 'namespace::type'
+		local b, e, label = string.find(a_Code, "^%s*(%w*)%s*:[^:]") -- we need to check for [^:], otherwise it would match 'namespace::type'
 		if b then
-
-			-- found a label, get the new access value from the global 'access' table
+			-- Found a label, get the new access value for it:
 			if access[label] then
-				container.curr_member_access = access[label]
+				classContainer.curr.curr_member_access = access[label]
 			end -- else ?
-
-			return strsub(s, e) -- normally we would use 'e+1', but we need to preserve the [^:]
+			return strsub(a_Code, e) -- normally we would use 'e + 1', but we need to preserve the [^:]
+		end
+	end
+	
+	-- Process forward DoxyComments:
+	do
+		local b, e, comment = a_Code:find("^%s*(%b\17\18)")
+		if (b) then
+			local curr = classContainer.curr
+			if (curr.n and (curr.n > 0)) then
+				curr[curr.n].next_DoxyComment = g_ForwardDoxyComments[tonumber(comment:sub(2, -2))]
+			else
+				curr.first_child_DoxyComment = g_ForwardDoxyComments[tonumber(comment:sub(2, -2))]
+			end
+			return strsub(a_Code, e + 1)
+		end
+	end
+	
+	-- Process backward DoxyComments:
+	do
+		local b, e, comment = a_Code:find("^%s*(%b\19\20)")
+		if (b) then
+			comment = g_BackwardDoxyComments[tonumber(comment:sub(2, -2))]
+			local currContainer = classContainer.curr
+			if (currContainer.n > 0) then
+				currContainer[currContainer.n].DoxyComment = comment
+			else
+				print("Backward DoxyComment lost in " .. (currContainer.name or currContainer.lname or currContainer.cname or "<no name>"))
+			end
+			return strsub(a_Code, e + 1)
 		end
 	end
 end
@@ -163,16 +273,725 @@ end
 
 
 
+local function FormatString(a_Str)
+	local fmt = string.format("%q", a_Str)
+	return (string.gsub(string.gsub(fmt, "\\\n", "\\n"), "\\\r\n", "\\r\\n"))
+end
+
+
+
+
+
+local function OutputTable(a_File, a_Table, a_Name, a_Indent, a_Visited, a_Metas)
+	-- Check and update the "visited" status:
+	if (a_Visited[a_Table]) then
+		a_File:write(a_Indent .. "{ \"visited: " .. a_Visited[a_Table] .. "\", }")
+		return
+	end
+	a_Visited[a_Table] = a_Name
+
+	-- Output the table contents:
+	a_File:write(a_Indent .. "{\n")
+	local indent = a_Indent .. "\t"
+	for k, v in pairs(a_Table) do
+		if (type(k) == "string") then
+			a_File:write(indent .. "[" .. FormatString(k) .. "] =")
+		else
+			a_File:write(indent .. "[" .. tostring(k) .. "] =")
+		end
+		local t = type(v)
+		if (
+			(t == "number") or
+			(t == "boolean")
+		) then
+			a_File:write(" ", tostring(v))
+		elseif (t == "string") then
+			a_File:write(" ", FormatString(v))
+		elseif (t == "table") then
+			local metatab = getmetatable(v)
+			if (metatab) then
+				a_File:write("  -- meta: " .. tostring(metatab))
+				a_Metas[metatab] = metatab
+			end
+			a_File:write("\n")
+			OutputTable(a_File, v, a_Name .. "." .. tostring(k), indent, a_Visited, a_Metas)
+		else
+			print("Unhandled type: " .. t .. ": " .. tostring(v))
+			a_File:write(" ", tostring(v))
+		end
+		a_File:write(",\n")
+	end  -- for k, v - a_Table
+	a_File:write(a_Indent .. "}")
+end
+
+
+
+
+
+--- Outputs the docs for all the functions in the specified class
+-- a_File is the output file
+-- a_Class is the ToLua's classClass object
+-- a_Functions is a dictionary of function descriptions: "name" -> { {<description>}, ...}
+local function outputClassFunctionDocs(a_File, a_Class, a_Functions)
+	-- Sort the functions by name:
+	local functions = {}
+	for name, descs in pairs(a_Functions) do
+		table.insert(functions, { Name = name, Descs = descs })
+	end
+	table.sort(functions,
+		function (a_Fn1, a_Fn2)
+			return (a_Fn1.Name < a_Fn2.Name)
+		end
+	)
+	
+	-- If there are no functions, bail out:
+	if not(functions[1]) then
+		return
+	end
+	
+	-- Output the descriptions:
+	a_File:write("\t\tFunctions =\n\t\t{\n")
+	for _, fn in ipairs(functions) do
+		local name = fn.Name
+		if (name:sub(1, 1) == ".") then
+			name = "[\"" .. name .. "\"]"
+		end
+		a_File:write("\t\t\t", name, " =\n\t\t\t{\n")
+		for _, desc in ipairs(fn.Descs) do
+			a_File:write("\t\t\t\t{\n\t\t\t\t\tParams =\n\t\t\t\t\t{\n")
+			for _, param in ipairs(desc.Parameters) do
+				a_File:write("\t\t\t\t\t\t{\n")
+				a_File:write("\t\t\t\t\t\t\tType = \"", param.Type, "\",\n")
+				a_File:write("\t\t\t\t\t\t\tName = \"", param.Name, "\",\n")
+				a_File:write("\t\t\t\t\t\t},\n")
+			end
+			a_File:write("\t\t\t\t\t},\n\t\t\t\t\tReturns =\n\t\t\t\t\t{\n")
+			for _, ret in ipairs(desc.Returns) do
+				a_File:write("\t\t\t\t\t\t{\n\t\t\t\t\t\t\tType = \"", ret.Type, "\",\n\t\t\t\t\t\t},\n")
+			end
+			a_File:write("\t\t\t\t\t},\n")
+			if (desc.IsStatic) then
+				a_File:write("\t\t\t\t\tIsStatic = true,\n")
+			end
+			if (desc.DoxyComment) then
+				a_File:write("\t\t\t\t\tDesc = ", string.format("%q", desc.DoxyComment), ",\n")
+			end
+			a_File:write("\t\t\t\t},\n")
+		end
+		a_File:write("\t\t\t},\n")
+	end
+	a_File:write("\t\t},\n")
+end
+
+
+
+
+
+--- Outputs the docs for all the member variables in the specified class
+-- a_File is the output file
+-- a_Class is the ToLua's classClass object
+-- a_Variables is a dictionary of variable descriptions: "name" -> {<description>}
+local function outputClassVariableDocs(a_File, a_Class, a_Variables)
+	-- Sort the variables by name:
+	local variables = {}
+	for name, desc in pairs(a_Variables) do
+		table.insert(variables, { Name = name, Desc = desc })
+	end
+	table.sort(variables,
+		function (a_Var1, a_Var2)
+			return (a_Var1.Name < a_Var2.Name)
+		end
+	)
+	
+	-- If there are no variables, bail out:
+	if not(variables[1]) then
+		return
+	end
+	
+	-- Output the descriptions:
+	a_File:write("\t\tVariables =\n\t\t{\n")
+	for _, v in ipairs(variables) do
+		a_File:write("\t\t\t", v.Name, " =\n\t\t\t{\n")
+		a_File:write("\t\t\t\tType = \"", v.Desc.Type, "\",\n")
+		if (v.Desc.DoxyComment) then
+			a_File:write("\t\t\t\tDesc = ", string.format("%q", v.Desc.DoxyComment), ",\n")
+		end
+		a_File:write("\t\t\t},\n")
+	end
+	a_File:write("\t\t},\n")
+end
+
+
+
+
+
+--- Outputs the docs for all the member constants in the specified class
+-- a_File is the output file
+-- a_Class is the ToLua's classClass object
+-- a_Constants is a dictionary of constant descriptions: "name" -> {<description>}
+-- a_IgnoredConstants is a dictionary of constants not to be exported: "name" -> true (used for ToLua++'s multi-inheritance)
+local function outputClassConstantDocs(a_File, a_Class, a_Constants, a_IgnoredConstants)
+	-- Sort the constants by name:
+	local constants = {}
+	for name, desc in pairs(a_Constants) do
+		if not(a_IgnoredConstants[name]) then
+			table.insert(constants, { Name = name, Desc = desc })
+		end
+	end
+	table.sort(constants,
+		function (a_Var1, a_Var2)
+			return (a_Var1.Name < a_Var2.Name)
+		end
+	)
+	
+	-- If there are no constants, bail out:
+	if not(constants[1]) then
+		return
+	end
+	
+	-- Output the descriptions:
+	a_File:write("\t\tConstants =\n\t\t{\n")
+	for _, con in ipairs(constants) do
+		a_File:write("\t\t\t", con.Name, " =\n\t\t\t{\n")
+		a_File:write("\t\t\t\tType = \"", con.Desc.Type, "\",\n")
+		if (con.Desc.DoxyComment) then
+			a_File:write("\t\t\t\tDesc = ", string.format("%q", con.Desc.DoxyComment), ",\n")
+		end
+		a_File:write("\t\t\t},\n")
+	end
+	a_File:write("\t\t},\n")
+end
+
+
+
+
+
+--- Outputs the docs for all the member enums in the specified class
+-- a_File is the output file
+-- a_Class is the ToLua's classClass object
+-- a_Enums is an array of ToLua's classEnum objects
+local function outputClassEnumDocs(a_File, a_Class, a_Enums)
+	-- If there are no enums, bail out:
+	if (not(a_Enums) or not(a_Enums[1])) then
+		return
+	end
+	
+	-- Sort the enums by name:
+	table.sort(a_Enums,
+		function (a_Enum1, a_Enum2)
+			return (a_Enum1.name < a_Enum2.name)
+		end
+	)
+	
+	-- Output the enums:
+	a_File:write("\t\tEnums =\n\t\t{\n")
+	for i, enum in ipairs(a_Enums) do
+		local name = enum.name
+		if (not(name) or (name == "")) then
+			name = string.format("unnamedEnum_%d", i)
+		end
+		a_File:write("\t\t\t", name, " =\n\t\t\t{\n")
+		local valnames = {}
+		-- Make a copy of enum.lnames so that we can sort it:
+		local idx = 1
+		for i, valname in ipairs(enum.lnames) do
+			valnames[idx] = { Name = valname, DoxyComment = enum.DoxyComments[i] }
+			idx = idx + 1
+		end
+		table.sort(valnames,
+			function (a_Val1, a_Val2)
+				return (a_Val1.Name < a_Val2.Name)
+			end
+		)
+		for _, valname in ipairs(valnames) do
+			assert(not(valname.Name:find("\17")))
+			assert(not(valname.Name:find("\18")))
+			assert(not(valname.Name:find("\19")))
+			assert(not(valname.Name:find("\20")))
+			a_File:write("\t\t\t\t{\n")
+			a_File:write("\t\t\t\t\tName = \"", valname.Name, "\",\n")
+			if (valname.DoxyComment) then
+				a_File:write("\t\t\t\t\tDesc = ", string.format("%q", valname.DoxyComment), ",\n")
+			end
+			a_File:write("\t\t\t\t},\n")
+		end
+		a_File:write("\t\t\t},\n")
+	end
+	a_File:write("\t\t},\n")
+end
+
+
+
+
+
+--- Outputs the docs for the specified class, which has been parsed for its functions, variables and constants
+-- a_Class is the ToLua's classClass object
+-- a_Functions is a dictionary of function descriptions: "name" -> { {<description>}, ...}
+-- a_Variables is a dictionary of variable descriptions: "name" -> {<description>}
+-- a_Constants is a dictionary of constant descriptions: "name" -> {<description>}
+-- a_Filenames is an array into which the name of the docs file is to be appended
+local function outputClassDocs(a_Class, a_Functions, a_Variables, a_Constants, a_Filenames)
+	-- Add the output file to list of filenames:
+	local fnam = a_Class.lname .. ".lua"
+	table.insert(a_Filenames, fnam)
+
+	-- Output the header:
+	local f = assert(io.open("docs/" .. fnam, "w"))
+	f:write("return\n{\n\t", a_Class.lname, " =\n\t{\n")
+	if (a_Class.DoxyComment) then
+		f:write("\t\tDesc = ", string.format("%q", a_Class.DoxyComment), ",\n")
+	end
+	
+	-- If the class inherits from anything, output it here:
+	local ignoredConstants = {}
+	if (a_Class.base and (a_Class.base ~= "")) then
+		local bases = {a_Class.base}
+		local idx = 2
+		for _, b in ipairs(a_Class.extra_bases or {}) do
+			bases[idx] = b
+			idx = idx + 1
+			-- ToLua++ handles multiple inheritance by adding "constants" for the base types; ignore those:
+			ignoredConstants["__" .. b .. "__"] = true
+		end
+		table.sort(bases)
+		f:write("\t\tInherits =\n\t\t{\n")
+		for _, b in ipairs(bases) do
+			f:write("\t\t\t", string.format("%q", b), ",\n")
+		end
+		f:write("\t\t},\n")
+	end
+	
+	-- Output the functions:
+	outputClassFunctionDocs(f, a_Class, a_Functions)
+	
+	-- Output the variables:
+	outputClassVariableDocs(f, a_Class, a_Variables)
+	
+	-- Output the constants:
+	outputClassConstantDocs(f, a_Class, a_Constants, ignoredConstants)
+	
+	-- Output the enums:
+	outputClassEnumDocs(f, a_Class, a_Class.enums)
+	
+	-- Output the footer:
+	f:write("\t},\n}\n")
+	f:close()
+end
+
+
+
+
+
+--- Recursively applies the next_DoxyComment member to the next item, and first_child_DoxyComment to first child item in the container.
+-- a_Container is the ToLua++'s table potentially containing children as its array members
+local function applyNextDoxyComments(a_Container)
+	-- Apply the DoxyComment to the first child, if appropriate:
+	if (a_Container[1] and a_Container.first_child_DoxyComment) then
+		a_Container[1].DoxyComment = a_Container.first_child_DoxyComment
+	end
+
+	-- Apply each child's next_DoxyComment to the actual next child:
+	local i = 1
+	while (a_Container[i]) do
+		if (a_Container[i].next_DoxyComment) then
+			if (a_Container[i + 1]) then
+				a_Container[i + 1].DoxyComment = a_Container[i].next_DoxyComment
+			end
+		end
+		applyNextDoxyComments(a_Container[i])
+		i = i + 1
+	end
+end
+
+
+
+
+
+--- Generates documentation for a package.
+local function genPackageDocs(a_Self)
+	-- DEBUG: Output the raw package object:
+	do
+		local f = io.open("docs/_raw.lua", "w")
+		if (f) then
+			OutputTable(f, a_Self, "", "", {}, {})
+			f:close()
+		end
+	end
+	
+	applyNextDoxyComments(a_Self)
+
+	-- Generate docs for each member:
+	local i = 1
+	local filenames = {}
+	while (a_Self[i]) do
+		if (
+			a_Self[i]:check_public_access() and  -- Do not export private and protected members
+			a_Self[i].genDocs
+		) then
+			a_Self[i]:genDocs(filenames)
+		end
+		i = i + 1
+	end
+	
+	-- Output the globals' docs:
+	local functions = {}
+	local variables = {}
+	local constants = {}
+	while (a_Self[i]) do
+		if (a_Self[i].genMemberDocs) then
+			a_Self[i]:genMemberDocs(functions, variables, constants)
+		end
+		i = i + 1
+	end
+	local oldName = a_Self.lname
+	a_Self.lname = "Globals"
+	outputClassDocs(a_Self, functions, variables, constants, filenames)
+	a_Self.lname = oldName
+	
+	-- Output the list of docs files:
+	table.sort(filenames)
+	local f = assert(io.open("docs/_files.lua", "w"))
+	f:write("return\n{\n")
+	for _, fnam in ipairs(filenames) do
+		f:write("\t\"", fnam, "\",\n")
+	end
+	f:write("}\n")
+	f:close()
+end
+
+
+
+
+
+local function genClassDocs(a_Self, a_Filenames)
+	assert(a_Self.lname)
+	assert(type(a_Filenames) == "table")
+	--[[
+	print("\n\nGenerating docs for class " .. a_Self.lname)
+	local visited = {[a_Self.parent] = "<package>"}
+	local metas = {}
+	OutputTable(io.stdout, a_Self, a_Self.lname, "", visited, metas)
+	--]]
+
+	-- Collect the function, variable and constant docs:
+	local i = 1
+	local functions = {}
+	local variables = {}
+	local constants = {}
+	while (a_Self[i]) do
+		if (
+			a_Self[i]:check_public_access() and  -- Don't export private and protected members
+			a_Self[i].genMemberDocs
+		) then
+			a_Self[i]:genMemberDocs(functions, variables, constants)
+		end
+		i = i + 1
+	end
+	
+	-- Output the individual docs
+	outputClassDocs(a_Self, functions, variables, constants, a_Filenames)
+end
+
+
+
+
+
+--- Parses the specified function's parameters and returns their description as a table
+-- a_Function is the ToLua's classFunction object
+local function parseFunctionParameters(a_Function)
+	-- If the only param is a "void", then report no params:
+	if (
+		a_Function.args and                  -- The params are present
+		(#(a_Function.args) == 1) and        -- There is exactly one param
+		(a_Function.args[1].type == "void")  -- The param is a void
+	) then
+		return {}
+	end
+	
+	local res = {}
+	local idx = 1
+	for _, param in ipairs(a_Function.args or {}) do
+		local t = param.type
+		t = t:gsub("^const ", "")  -- Remove the "const" keyword, if present
+		res[idx] =
+		{
+			Name = param.name,
+			Type = t,
+			IsConst = (param.type:match("^const ") ~= nil),
+		}
+		idx = idx + 1
+	end
+	return res
+end
+
+
+
+
+
+--- Parses the specified function's return values and returns their description as a table
+-- a_Function is the ToLua's classFunction object
+local function parseFunctionReturns(a_Function)
+	local res = {}
+	local idx = 1
+	if (a_Function.type and (a_Function.type ~= "void")) then
+		res[idx] = { Type = a_Function.type }
+		idx = idx + 1
+	end
+	for _, param in ipairs(a_Function.args or {}) do
+		if ((param.mod == "&") or (param.ret == "&")) then
+			res[idx] = { Type = param.type:gsub("^const ", "") }
+			idx = idx + 1
+		end
+	end
+	return res
+end
+
+
+
+
+
+local function genFunctionMemberDocs(a_Self, a_Functions, a_Variables, a_Constants)
+	assert(a_Self.lname)
+	
+	local fn = a_Functions[a_Self.lname] or {}
+	a_Functions[a_Self.lname] = fn
+
+	local desc =
+	{
+		LuaName = a_Self.lname,
+		CType = a_Self.type,
+		DoxyComment = a_Self.DoxyComment,
+		Parameters = parseFunctionParameters(a_Self),
+		Returns = parseFunctionReturns(a_Self),
+	}
+	local _, _, hasStatic = string.find(a_Self.mod, "^%s*(static)")
+	if (hasStatic) then
+		desc.IsStatic = true
+	end
+	table.insert(fn, desc)
+end
+
+
+
+
+
+local function genVariableMemberDocs(a_Self, a_Functions, a_Variables, a_Constants)
+	assert(a_Self.lname)
+	
+	local desc =
+	{
+		Name = a_Self.lname,
+		Type = a_Self.type,
+		DoxyComment = a_Self.DoxyComment,
+	}
+	
+	if (string.find(a_Self.type,'const%s+') or string.find(a_Self.mod, 'tolua_readonly') or string.find(a_Self.mod, 'tolua_inherits'))  then
+		a_Constants[a_Self.lname] = desc
+	else
+		a_Variables[a_Self.lname] = desc
+	end
+end
+
+
+
+
+
+--- Generates the entire documentation for the API
+-- a_Package is ToLua++'s classPackage object
+-- Checks if the documentation folder is writable, if not, skips the docs generation
+-- Returns true if documentation was generated, false and message if not
+local function generateDocs(a_Package)
+	-- Check if the docs folder is writable:
+	local f, msg = io.open("docs/_files.lua", "w")
+	if not(f) then
+		return false, "Cannot access the docs folder: " .. msg
+	end
+	f:close()
+	
+	-- Generate the docs:
+	classPackage.genDocs = genPackageDocs
+	classClass.genDocs = genClassDocs
+	classFunction.genMemberDocs = genFunctionMemberDocs
+	classVariable.genMemberDocs = genVariableMemberDocs
+	a_Package:genDocs()
+	return true
+end
+
+
+
+
+
+--- Outputs the cLuaState helper files.
+-- Called by ToLua++ before it starts outputting its generated files.
+-- a_Package is ToLua++'s classPackage object
 function pre_output_hook(a_Package)
 	OutputLuaStateHelpers(a_Package)
+
+	-- Generate the documentation:
+	-- (must generate documentation before ToLua++ writes the bindings, because "static" information is lost at that point)
+	local isSuccess, msg = generateDocs(a_Package)
+	if not(isSuccess) then
+		print("API docs haven't been generated due to an error: " .. (msg or "<no message>"))
+	else
+		print("API docs have been generated.");
+	end
+end
+
+
+
+
+
+--- Outputs the documentation files.
+-- Called by ToLua++ after writing its generated files.
+-- a_Package is ToLua++'s classPackage object
+function post_output_hook(a_Package)
+	print("Lua bindings have been generated.")
+end
+
+
+
+
+
+--- Provides DoxyComment processing while parsing the C++ code.
+-- Called by ToLua++ parser before it starts parsing the code.
+-- a_Package is the ToLua++'s classPackage object, currently unparsed
+-- The C++ code to be parsed is in a_Packade.code
+function preprocess_hook(a_Package)
+	assert(a_Package)
+	assert(type(a_Package.code) == "string")
+	
+	-- Replace all DoxyComments with placeholders so that they aren't erased later on:
+	a_Package.code = a_Package.code
+		:gsub("/%*%*%s*(.-)%s*%*/",
+			function (a_Comment)
+				local n = g_ForwardDoxyComments.n + 1
+				g_ForwardDoxyComments[n] = a_Comment
+				g_ForwardDoxyComments.n = n
+				return "\17" .. n .."\18"
+			end
+		)  -- Replace /** ... */ with an ID into a lookup table wrapped in DC1 and DC2
+		:gsub("///<%s*(.-)%s*\n%s*",
+			function (a_Comment)
+				local n = g_BackwardDoxyComments.n + 1
+				g_BackwardDoxyComments[n] = a_Comment
+				g_BackwardDoxyComments.n = n
+				return "\19" .. n .."\20\n"
+			end
+		)  -- Replace ///< comments with an ID into a lookup table wrapped in DC3 and DC4
+	local f = io.open("code_out.cpp", "wb")
+	f:write(a_Package.code)
+	f:close()
+end
+
+
+
+
+
+--- Chooses the smaller of the indices, and the number indicating whether it chose the first or the second
+-- If one of the indices is nil, returns the other one
+-- If both indices are nil, returns nil
+local function chooseNextIndex(a_Index1, a_Index2)
+	if not(a_Index1) then
+		return a_Index2, 2
+	end
+	if not(a_Index2) then
+		return a_Index1, 1
+	end
+	if (a_Index1 > a_Index2) then
+		return a_Index2, 2
+	else
+		return a_Index1, 1
+	end
+end
+
+
+
+
+
+--- Override for ToLua++'s own code extraction
+-- Called for each "$cfile" and "$hfile" directive in the package file
+-- a_FileName is the C++ header filename
+-- a_Contents is the code contents of the header file
+-- The function returns the code to be parsed by ToLua++
+-- In addition to the original function, this override extracts all DoxyComments as well
+-- This is needed when a function is marked with "// tolua_export" but its DoxyComment is not included
+function extract_code(a_FileName, a_Contents)
+	local code = '\n$#include "' .. a_FileName .. '"\n'
+	a_Contents= "\n" .. a_Contents .. "\n" -- add blank lines as sentinels
+	local _, e, c, t = strfind(a_Contents, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n")
+	local dcb, dce, dc = strfind(a_Contents, "/%*%*.-%*/")
+	local nextEnd, whichOne = chooseNextIndex(e, dce)
+	while (nextEnd) do
+		if (whichOne == 2) then
+			code = code .. a_Contents:sub(dcb, dce) .. "\n"
+		else
+			t = strlower(t)
+			if (t == "begin") then
+				_, nextEnd, c = strfind(a_Contents,"(.-)\n[^\n]*[Tt][Oo][Ll][Uu][Aa]_[Ee][Nn][Dd][^\n]*\n", e)
+				if not(nextEnd) then
+				 tolua_error("Unbalanced 'tolua_begin' directive in header file " .. a_FileName)
+				end
+			end
+			code = code .. c .. "\n"
+		end
+		_, e, c, t = strfind(a_Contents, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n", nextEnd)
+		dcb, dce, dc = strfind(a_Contents, "/%*%*.-%*/", nextEnd)
+		nextEnd, whichOne = chooseNextIndex(e, dce)
+	end
+	return code
+end
+
+
+
+
+
+--- Installs a hook that is called by ToLua++ for each instantiation of classEnumerate
+-- The hook is used to fix DoxyComments in enums
+local function installEnumHook()
+	local oldEnumerate = Enumerate
+	Enumerate = function (a_Name, a_Body, a_VarName)
+		-- We need to remove the DoxyComment items from the enum
+		-- otherwise ToLua++ parser would make an enum value out of them
+		a_Body = string.gsub(a_Body, ",[%s\n]*}", "\n}") -- eliminate last ','
+		local t = split(strsub(a_Body, 2, -2), ',') -- eliminate braces
+		local doxyComments = {}
+		local enumValues = {}
+		local numEnumValues = 0
+		for _, txt in ipairs(t) do
+			txt = txt:gsub("(%b\17\18)",
+				function (a_CommentID)
+					doxyComments[numEnumValues + 1] = g_ForwardDoxyComments[tonumber(a_CommentID:sub(2, -2))]
+					return ""
+				end
+			):gsub("(%b\19\20)",
+				function (a_CommentID)
+					doxyComments[numEnumValues] = g_BackwardDoxyComments[tonumber(a_CommentID:sub(2, -2))]
+					return ""
+				end
+			)
+			if (txt ~= "") then
+				numEnumValues = numEnumValues + 1
+				enumValues[numEnumValues] = txt
+			end
+		end
+		local res = oldEnumerate(a_Name, "{" .. table.concat(enumValues, ",") .. "}", a_VarName)
+		res.DoxyComments = doxyComments
+		return res
+	end
 end
 
 
 
 
 
-function post_output_hook()
-	print("Bindings have been generated.")
+if not(TOLUA_VERSION) then
+	-- BindingsProcessor has been called standalone, invoke the entire ToLua++ machinery:
+	print("Generating Lua bindings and docs...")
+	invokeToLua()
+	return
+else
+	-- We're being executed from inside the ToLua++ parser. Install the needed hooks:
+	installEnumHook()
 end
 
 
diff --git a/src/Bindings/CMakeLists.txt b/src/Bindings/CMakeLists.txt
index 5c79225cc..23ba4c7e6 100644
--- a/src/Bindings/CMakeLists.txt
+++ b/src/Bindings/CMakeLists.txt
@@ -1,4 +1,3 @@
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
@@ -56,7 +55,6 @@ set (BINDING_OUTPUTS
 )
 
 set(BINDING_DEPENDENCIES
-	tolua
 	../Bindings/AllToLua.pkg
 	../Bindings/BindingsProcessor.lua
 	../Bindings/LuaFunctions.h
@@ -139,17 +137,21 @@ set(BINDING_DEPENDENCIES
 )
 
 if (NOT MSVC)
-	ADD_CUSTOM_COMMAND(
-		# add any new generated bindings here
-		OUTPUT ${BINDING_OUTPUTS}
-
-		# Regenerate bindings:
-		COMMAND tolua -L BindingsProcessor.lua -o Bindings.cpp -H Bindings.h AllToLua.pkg
-		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-
-		# add any new generation dependencies here
-		DEPENDS ${BINDING_DEPENDENCIES}
-	)
+	if (HAS_LUA_INTERPRETER)
+		ADD_CUSTOM_COMMAND(
+			OUTPUT ${BINDING_OUTPUTS}
+			COMMAND lua BindingsProcessor.lua
+			WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+			DEPENDS ${BINDING_DEPENDENCIES}
+		)
+	else()
+		ADD_CUSTOM_COMMAND(
+			OUTPUT ${BINDING_OUTPUTS}
+			COMMAND tolua -L BindingsProcessor.lua -o Bindings.cpp -H Bindings.h AllToLua.pkg
+			WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+			DEPENDS ${BINDING_DEPENDENCIES} tolua
+		)
+	endif()
 endif ()
 
 set_source_files_properties(${BINDING_OUTPUTS} PROPERTIES GENERATED TRUE)
diff --git a/src/Bindings/DiffAPIDesc.lua b/src/Bindings/DiffAPIDesc.lua
new file mode 100644
index 000000000..8b8c340e2
--- /dev/null
+++ b/src/Bindings/DiffAPIDesc.lua
@@ -0,0 +1,550 @@
+-- DiffAPIDesc.lua
+
+-- Creates a diff file containing documentation that is available from ToLua++'s doxycomment parsing, but not yet included in APIDesc.lua
+
+require("lfs")
+
+
+
+
+
+--- Translation for function names whose representation in APIDesc is different from the one in Docs
+-- Dictionary of "DocsName" -> "DescName"
+local g_FunctionNameDocsToDesc =
+{
+	["new"]    = "constructor",
+	["delete"] = "destructor",
+	[".add"]   = "operator_plus",
+	[".div"]   = "operator_div",
+	[".eq"]    = "operator_eq",
+	[".mul"]   = "operator_mul",
+	[".sub"]   = "operator_sub",
+}
+
+
+
+
+
+--- Translation from C types to Lua types
+-- Dictionary of "CType" -> "LuaType"
+local g_CTypeToLuaType =
+{
+	AString = "string",
+	bool = "boolean",
+	Byte = "number",
+	char = "number",
+	double = "number",
+	float = "number",
+	ForEachChunkProvider = "cWorld",
+	int = "number",
+	size_t = "number",
+	unsigned = "number",
+	["const AString"] = "string",
+	["const char*"] = "string",
+	["std::string"] = "string",
+	["Vector3<int>"]    = "Vector3i",
+	["Vector3<float>"]  = "Vector3f",
+	["Vector3<double>"] = "Vector3d",
+}
+
+
+
+
+
+--- Functions that should be ignored
+-- Dictionary of "FunctionName" -> true for each ignored function
+local g_IgnoreFunction =
+{
+	destructor = true,
+}
+
+
+
+
+
+local function caseInsensitiveCompare(a_Text1, a_Text2)
+	return (a_Text1:lower() < a_Text2:lower())
+end
+
+
+
+
+
+--- Loads the APIDesc.lua and its child files, returns the complete description
+-- Returns a table with Classes and Hooks members, Classes being a dictionary of "ClassName" -> { desc }
+local function loadAPIDesc()
+	-- Load the main APIDesc.lua file:
+	local apiDescPath = "../../Server/Plugins/APIDump/"
+	local desc = dofile(apiDescPath .. "APIDesc.lua")
+	if not(desc) then
+		error("Failed to load APIDesc")
+	end
+	
+	-- Merge in the information from all files in the Classes subfolder:
+	local classesPath = apiDescPath .. "Classes/"
+	for fnam in lfs.dir(apiDescPath .. "Classes") do
+		if (string.find(fnam, ".*%.lua$")) then
+			local tbls = dofile(classesPath .. fnam)
+			for k, cls in pairs(tbls) do
+				desc.Classes[k] = cls;
+			end
+		end
+	end
+	return desc
+end
+
+
+
+
+
+--- Loads the API documentation generated by ToLua++'s parser
+-- Returns a dictionary of "ClassName" -> { docs }
+local function loadAPIDocs()
+	-- Get the filelist:
+	local files = dofile("docs/_files.lua")
+	if not(files) then
+		error("Failed to load _files.lua from docs")
+	end
+	
+	-- Load the docs from all files, merge into a single dictionary:
+	local res = {}
+	for _, fnam in ipairs(files) do
+		local docs = dofile("docs/" .. fnam)
+		if (docs) then
+			for k, v in pairs(docs) do
+				assert(not(res[k]))  -- Do we have a duplicate documentation entry?
+				res[k] = v
+			end
+		end
+	end
+	return res
+end
+
+
+
+
+
+--- Returns whether the function signature in the description matches the function documentation
+-- a_FunctionDesc is a single description for a function, as loaded from APIDesc.lua (one <FnDesc> item)
+-- a_FunctionDoc is a single documentation item for a function, as loaded from ToLua++'s parser
+local function functionDescMatchesDocs(a_FunctionDesc, a_FunctionDoc)
+	-- Check the number of parameters:
+	local numParams
+	local numOptionalParams = 0
+	if (not(a_FunctionDesc.Params) or (a_FunctionDesc.Params == "")) then
+		numParams = 0
+	else
+		_, numParams = string.gsub(a_FunctionDesc.Params, ",", "")
+		numParams = numParams + 1
+		_, numOptionalParams = string.gsub(a_FunctionDesc.Params, "%b[]", "")
+	end
+	local numDocParams = #(a_FunctionDoc.Params)
+	if ((numDocParams > numParams) or (numDocParams < numParams - numOptionalParams)) then
+		return false
+	end
+	
+	return true
+end
+
+
+
+
+
+--- Returns an array of function descriptions that are in a_FunctionDocs but are missing from a_FunctionDescs
+-- a_FunctionDescs is an array of function descriptions, as loaded from APIDesc.lua (normalized into array)
+-- a_FunctionDocs is an array of function documentation items, as loaded from ToLua++'s parser
+-- If all descriptions match, nil is returned instead
+local function listMissingClassSingleFunctionDescs(a_FunctionDescs, a_FunctionDocs)
+	-- For each documentation item, try to find a match in a_FunctionDescs:
+	local res = {}
+	for _, docs in ipairs(a_FunctionDocs) do
+		local hasFound = false
+		for _, desc in ipairs(a_FunctionDescs) do
+			if (functionDescMatchesDocs(desc, docs)) then
+				hasFound = true
+				break
+			end
+		end  -- for idx - freeDescs[]
+		if not(hasFound) then
+			table.insert(res, docs)
+		end
+	end  -- for docs - a_FunctionDocs[]
+	
+	-- If no result, return nil instead of an empty table:
+	if not(res[1]) then
+		return nil
+	end
+	return res
+end
+
+
+
+
+
+--- Returns a dict of "FnName" -> { { <FnDesc> }, ... } that are documented in a_FunctionDocs but missing from a_FunctionDescs
+-- If there are no such descriptions, returns nil instead
+-- a_FunctionDescs is a dict of "FnName" -> { <FnDescs> } loaded from APIDesc.lua et al
+--    <FnDescs> may be a single desc or an array of those
+-- a_FunctionDocs is a dict og "FnName" -> { { <FnDesc> }, ... } loaded from ToLua++'s parser
+local function listMissingClassFunctionDescs(a_FunctionDescs, a_FunctionDocs)
+	-- Match the docs and descriptions for each separate function:
+	local res = {}
+	local hasSome = false
+	a_FunctionDescs = a_FunctionDescs or {}
+	a_FunctionDocs = a_FunctionDocs or {}
+	for fnName, fnDocs in pairs(a_FunctionDocs) do
+		local fnDescName = g_FunctionNameDocsToDesc[fnName] or fnName
+		if not(g_IgnoreFunction[fnDescName]) then
+			local fnDescs = a_FunctionDescs[fnDescName]
+			if not(fnDescs) then
+				-- Function not described at all, insert a dummy empty description for the matching:
+				fnDescs = {}
+			elseif not(fnDescs[1]) then
+				-- Function has a single description, convert it to the same format as multi-overload functions use:
+				fnDescs = { fnDescs }
+			end
+			local missingDocs = listMissingClassSingleFunctionDescs(fnDescs, fnDocs)
+			if (missingDocs) then
+				res[fnName] = missingDocs
+				hasSome = true
+			end
+		end  -- not ignored
+	end  -- for fnName, fnDocs - a_FunctionDocs[]
+	if not(hasSome) then
+		return nil
+	end
+	return res
+end
+
+
+
+
+
+--- Returns a dictionary of "SymbolName" -> { <desc> } for any variable or constant that is documented but not described
+-- a_VarConstDescs is an array of variable or constant descriptions, as loaded from APIDesc.lua
+-- a_VarConstDocs is an array of variable or constant documentation items, as loaded from ToLua++'s parser
+-- If no symbol is to be returned, returns nil instead
+local function listMissingClassVarConstDescs(a_VarConstDescs, a_VarConstDocs)
+	-- Match the docs and descriptions for each separate function:
+	local res = {}
+	local hasSome = false
+	a_VarConstDescs = a_VarConstDescs or {}
+	a_VarConstDocs = a_VarConstDocs or {}
+	for symName, symDocs in pairs(a_VarConstDocs) do
+		local symDesc = a_VarConstDescs[symName]
+		if (
+			not(symDesc) or        -- Symbol not described at all
+			not(symDesc.Notes) or  -- Non-existent description
+			(
+				(symDesc.Notes == "")  and             -- Empty description
+				(type(symDocs.Notes) == "string") and  -- Docs has a string ...
+				(symDocs.Notes ~= "")                  --  ... that is not empty
+			)
+		) then
+			res[symName] = symDocs
+			hasSome = true
+		end
+	end
+	if not(hasSome) then
+		return nil
+	end
+	return res
+end
+
+
+
+
+
+--- Fills a_Missing with descriptions that are documented in a_ClassDocs but missing from a_ClassDesc
+-- a_ClassDesc is the class' description loaded from APIDesc et al
+-- a_ClassDocs is the class' documentation loaded from ToLua++'s parser
+local function listMissingClassDescs(a_ClassName, a_ClassDesc, a_ClassDocs, a_Missing)
+	local missing =
+	{
+		Functions = listMissingClassFunctionDescs(a_ClassDesc.Functions, a_ClassDocs.Functions),
+		Constants = listMissingClassVarConstDescs(a_ClassDesc.Constants, a_ClassDocs.Constants),
+		Variables = listMissingClassVarConstDescs(a_ClassDesc.Variables, a_ClassDocs.Variables),
+	}
+	if (
+		not(missing.Functions) and
+		not(missing.Constants) and
+		not(missing.Variables)
+	) then
+		-- Nothing missing, don't add anything
+		return
+	end
+	a_Missing[a_ClassName] = missing
+end
+
+
+
+
+
+--- Returns a dictionary of "ClassName" -> { { <desc> }, ... } of descriptions that are documented in a_Docs but missing from a_Descs
+-- a_Descs is the descriptions loaded from APIDesc et al
+-- a_Docs is the documentation loaded from ToLua++'s parser
+local function findMissingDescs(a_Descs, a_Docs)
+	local descClasses = a_Descs.Classes
+	local res = {}
+	for clsName, clsDocs in pairs(a_Docs) do
+		local clsDesc = descClasses[clsName] or {}
+		listMissingClassDescs(clsName, clsDesc, clsDocs, res)
+	end
+	return res
+end
+
+
+
+
+
+local function outputTable(a_File, a_Table, a_Indent)
+	-- Extract all indices first:
+	local allIndices = {}
+	for k, _ in pairs(a_Table) do
+		table.insert(allIndices, k)
+	end
+	
+	-- Sort the indices:
+	table.sort(allIndices,
+		function (a_Index1, a_Index2)
+			if (type(a_Index1) == "number") then
+				if (type(a_Index2) == "number") then
+					-- Both indices are numeric, sort by value
+					return (a_Index1 < a_Index2)
+				end
+				-- a_Index2 is non-numeric, always goes after a_Index1
+				return true
+			end
+			if (type(a_Index2) == "number") then
+				-- a_Index2 is numeric, a_Index1 is not
+				return false
+			end
+			-- Neither index is numeric, use regular string comparison:
+			return caseInsensitiveCompare(tostring(a_Index1), tostring(a_Index2))
+		end
+	)
+	
+	-- Output by using the index order:
+	a_File:write(a_Indent, "{\n")
+	local indent = a_Indent .. "\t"
+	for _, index in ipairs(allIndices) do
+		-- Write the index:
+		a_File:write(indent, "[")
+		if (type(index) == "string") then
+			a_File:write(string.format("%q", index))
+		else
+			a_File:write(index)
+		end
+		a_File:write("] =")
+		
+		-- Write the value:
+		local v = a_Table[index]
+		if (type(v) == "table") then
+			a_File:write("\n")
+			outputTable(a_File, v, indent)
+		elseif (type(v) == "string") then
+			a_File:write(string.format(" %q", v))
+		else
+			a_File:write(" ", tostring(v))
+		end
+		a_File:write(",\n")
+	end
+	a_File:write(a_Indent, "}")
+end
+
+
+
+
+
+--- Returns a description of function params, as used for output
+-- a_Params is nil or an array of parameters from ToLua++'s parser
+-- a_ClassMap is a dictionary of "ClassName" -> true for all known classes
+local function extractParamsForOutput(a_Params, a_ClassMap)
+	if not(a_Params) then
+		return ""
+	end
+	assert(a_ClassMap)
+	
+	local params = {}
+	for _, param in ipairs(a_Params) do
+		local paramType = param.Type or ""
+		paramType = g_CTypeToLuaType[paramType] or paramType  -- Translate from C type to Lua type
+		local paramName = param.Name or paramType or "[unknown]"
+		paramName = paramName:gsub("^a_", "")  -- Remove the "a_" prefix, if present
+		local idxColon = paramType:find("::")  -- Extract children classes and enums within classes
+		local paramTypeAnchor = ""
+		if (idxColon) then
+			paramTypeAnchor = "#" .. paramType:sub(idxColon + 2)
+			paramType = paramType:sub(1, idxColon - 1)
+		end
+		if (a_ClassMap[paramType]) then
+			-- Param type is a class name, make it a link
+			if not(param.Name) then
+				paramName = "{{" .. paramType .. paramTypeAnchor .. "}}"
+			else
+				paramName = "{{" .. paramType .. paramTypeAnchor .. "|" .. paramName .. "}}"
+			end
+		end
+		table.insert(params, paramName)
+	end
+	return table.concat(params, ", ")
+end
+
+
+
+
+
+--- Returns a single line of function description for output
+-- a_Desc is the function description
+-- a_ClassMap is a dictionary of "ClassName" -> true for all known classes
+local function formatFunctionDesc(a_Docs, a_ClassMap)
+	local staticClause = ""
+	if (a_Docs.IsStatic) then
+		staticClause = "IsStatic = true, "
+	end
+	return string.format("{ Params = %q, Return = %q, %sNotes = %q },\n",
+		extractParamsForOutput(a_Docs.Params, a_ClassMap),
+		extractParamsForOutput(a_Docs.Returns, a_ClassMap),
+		staticClause,
+		(a_Docs.Desc or ""):gsub("%.\n", ". "):gsub("\n", ". "):gsub("%s+", " ")
+	)
+end
+
+
+
+
+
+--- Outputs differences in function descriptions into a file
+-- a_File is the output file
+-- a_Functions is nil or a dictionary of "FunctionName" -> { { <desc> }, ... }
+-- a_ClassMap is a dictionary of "ClassName" -> true for all known classes
+local function outputFunctions(a_File, a_Functions, a_ClassMap)
+	assert(a_File)
+	if not(a_Functions) then
+		return
+	end
+	
+	-- Get a sorted array of all function names:
+	local fnNames = {}
+	for fnName, _ in pairs(a_Functions) do
+		table.insert(fnNames, fnName)
+	end
+	table.sort(fnNames, caseInsensitiveCompare)
+	
+	-- Output the function descs:
+	a_File:write("\t\tFunctions =\n\t\t{\n")
+	for _, fnName in ipairs(fnNames) do
+		a_File:write("\t\t\t", g_FunctionNameDocsToDesc[fnName] or fnName, " =")
+		local docs = a_Functions[fnName]
+		if (docs[2]) then
+			-- There are at least two descriptions, use the array format:
+			a_File:write("\n\t\t\t{\n")
+			for _, doc in ipairs(docs) do
+				a_File:write("\t\t\t\t", formatFunctionDesc(doc, a_ClassMap))
+			end
+			a_File:write("\t\t\t},\n")
+		else
+			-- There's only one description, use the simpler one-line format:
+			a_File:write(" ", formatFunctionDesc(docs[1], a_ClassMap))
+		end
+	end
+	a_File:write("\t\t},\n")
+end
+
+
+
+
+
+--- Returns the description of a single variable or constant
+-- a_Docs is the ToLua++'s documentation of the symbol
+-- a_ClassMap is a dictionary of "ClassName" -> true for all known classes
+local function formatVarConstDesc(a_Docs, a_ClassMap)
+	local descType = ""
+	if (a_Docs.Type) then
+		local luaType = g_CTypeToLuaType[a_Docs.Type] or a_Docs.Type
+		if (a_ClassMap[a_Docs.Type]) then
+			descType = string.format("Type = {{%q}}, ", luaType);
+		else
+			descType = string.format("Type = %q, ", luaType);
+		end
+	end
+	return string.format("{ %sNotes = %q },\n", descType, a_Docs.Desc or "")
+end
+
+
+
+
+
+--- Outputs differences in variables' or constants' descriptions into a file
+-- a_File is the output file
+-- a_VarConst is nil or a dictionary of "VariableOrConstantName" -> { <desc> }
+-- a_Header is a string, either "Variables" or "Constants"
+-- a_ClassMap is a dictionary of "ClassName" -> true for all known classes
+local function outputVarConst(a_File, a_VarConst, a_Header, a_ClassMap)
+	assert(a_File)
+	assert(type(a_Header) == "string")
+	if not(a_VarConst) then
+		return
+	end
+	
+	-- Get a sorted array of all symbol names:
+	local symNames = {}
+	for symName, _ in pairs(a_VarConst) do
+		table.insert(symNames, symName)
+	end
+	table.sort(symNames, caseInsensitiveCompare)
+	
+	-- Output the symbol descs:
+	a_File:write("\t\t", a_Header, " =\n\t\t{\n")
+	for _, symName in ipairs(symNames) do
+		local docs = a_VarConst[symName]
+		a_File:write("\t\t\t", symName, " = ", formatVarConstDesc(docs, a_ClassMap))
+	end
+	a_File:write("\t\t},\n")
+end
+
+
+
+
+
+--- Outputs the diff into a file
+-- a_Diff is the diff calculated by findMissingDescs()
+-- The output file is written as a Lua source file formatted to match APIDesc.lua
+local function outputDiff(a_Diff)
+	-- Sort the classnames:
+	local classNames = {}
+	local classMap = {}
+	for clsName, _ in pairs(a_Diff) do
+		table.insert(classNames, clsName)
+		classMap[clsName] = true
+	end
+	table.sort(classNames, caseInsensitiveCompare)
+	
+	-- Output each class:
+	local f = assert(io.open("APIDiff.lua", "w"))
+	-- outputTable(f, diff, "")
+	f:write("return\n{\n")
+	for _, clsName in ipairs(classNames) do
+		f:write("\t", clsName, " =\n\t{\n")
+		local desc = a_Diff[clsName]
+		outputFunctions(f, desc.Functions, classMap)
+		outputVarConst(f, desc.Variables, "Variables", classMap)
+		outputVarConst(f, desc.Constants, "Constants", classMap)
+		f:write("\t},\n")
+	end
+	f:write("}\n")
+	f:close()
+end
+
+
+
+
+
+local apiDesc = loadAPIDesc()
+local apiDocs = loadAPIDocs()
+local diff = findMissingDescs(apiDesc, apiDocs)
+outputDiff(diff)
+print("Diff has been output to file APIDiff.lua.")
+
+
+
diff --git a/src/Bindings/ManualBindings.cpp b/src/Bindings/ManualBindings.cpp
index 1d735ac83..8bcd5a4e6 100644
--- a/src/Bindings/ManualBindings.cpp
+++ b/src/Bindings/ManualBindings.cpp
@@ -30,6 +30,7 @@
 #include "../BlockEntities/NoteEntity.h"
 #include "../BlockEntities/MobHeadEntity.h"
 #include "../BlockEntities/FlowerPotEntity.h"
+#include "../Generating/ChunkDesc.h"
 #include "../LineBlockTracer.h"
 #include "../WorldStorage/SchematicFileSerializer.h"
 #include "../CompositeChat.h"
@@ -3443,6 +3444,33 @@ static int tolua_cBoundingBox_Intersect(lua_State * a_LuaState)
 
 
 
+static int tolua_cChunkDesc_GetBlockTypeMeta(lua_State * a_LuaState)
+{
+	/* Function signature:
+	ChunkDesc:GetBlockTypeMeta(RelX, RelY, RelZ) -> BlockType, BlockMeta
+	*/
+
+	cLuaState L(a_LuaState);
+	const cChunkDesc * self;
+	int relX, relY, relZ;
+	if (!L.GetStackValues(1, self, relX, relY, relZ))
+	{
+		L.LogStackValues();
+		tolua_error(a_LuaState, "Invalid function params. Expected chunkDesc:GetBlockTypeMeta(relX, relY, relZ)", nullptr);
+		return 0;
+	}
+	BLOCKTYPE blockType;
+	NIBBLETYPE blockMeta;
+	self->GetBlockTypeMeta(relX, relY, relZ, blockType, blockMeta);
+	L.Push(blockType);
+	L.Push(blockMeta);
+	return 2;
+}
+
+
+
+
+
 static int tolua_cCompositeChat_AddRunCommandPart(lua_State * tolua_S)
 {
 	// function cCompositeChat:AddRunCommandPart(Message, Command, [Style])
@@ -3736,6 +3764,10 @@ void cManualBindings::Bind(lua_State * tolua_S)
 			tolua_function(tolua_S, "Intersect",            tolua_cBoundingBox_Intersect);
 		tolua_endmodule(tolua_S);
 
+		tolua_beginmodule(tolua_S, "cChunkDesc");
+			tolua_function(tolua_S, "GetBlockTypeMeta", tolua_cChunkDesc_GetBlockTypeMeta);
+		tolua_endmodule(tolua_S);
+
 		tolua_beginmodule(tolua_S, "cClientHandle");
 			tolua_constant(tolua_S, "MAX_VIEW_DISTANCE", cClientHandle::MAX_VIEW_DISTANCE);
 			tolua_constant(tolua_S, "MIN_VIEW_DISTANCE", cClientHandle::MIN_VIEW_DISTANCE);
diff --git a/src/BlockEntities/CMakeLists.txt b/src/BlockEntities/CMakeLists.txt
index 6c164c4b4..8e57c172f 100644
--- a/src/BlockEntities/CMakeLists.txt
+++ b/src/BlockEntities/CMakeLists.txt
@@ -1,5 +1,3 @@
-
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
diff --git a/src/BlockEntities/DispenserEntity.h b/src/BlockEntities/DispenserEntity.h
index 03ce3ad69..4e81b455a 100644
--- a/src/BlockEntities/DispenserEntity.h
+++ b/src/BlockEntities/DispenserEntity.h
@@ -25,11 +25,11 @@ public:
 	// tolua_begin
 
 	/** Spawns a projectile of the given kind in front of the dispenser with the specified speed.
-	Returns the UniqueID of the spawned projectile, or 0 on failure. */
+	Returns the UniqueID of the spawned projectile, or cEntity::INVALID_ID on failure. */
 	UInt32 SpawnProjectileFromDispenser(int a_BlockX, int a_BlockY, int a_BlockZ, cProjectileEntity::eKind a_Kind, const Vector3d & a_Speed, const cItem * a_Item = nullptr);
 
-	/** Returns a unit vector in the cardinal direction of where the dispenser is facing. */
-	Vector3d GetShootVector(NIBBLETYPE a_Meta);
+	/** Returns a unit vector in the cardinal direction of where the dispenser with the specified meta would be facing. */
+	static Vector3d GetShootVector(NIBBLETYPE a_BlockMeta);
 
 	// tolua_end
 
diff --git a/src/BlockEntities/MobHeadEntity.h b/src/BlockEntities/MobHeadEntity.h
index 0aac95536..eef88a201 100644
--- a/src/BlockEntities/MobHeadEntity.h
+++ b/src/BlockEntities/MobHeadEntity.h
@@ -42,7 +42,7 @@ public:
 	/** Set the player for mob heads with player type */
 	void SetOwner(const cPlayer & a_Owner);
 
-	/** Sets the player components for the mob heads with player type */
+	/** Sets the player components for the mob heads with player type. */
 	void SetOwner(const AString & a_OwnerUUID, const AString & a_OwnerName, const AString & a_OwnerTexture, const AString & a_OwnerTextureSignature);
 
 	/** Returns the type of the mob head */
diff --git a/src/Blocks/CMakeLists.txt b/src/Blocks/CMakeLists.txt
index e9b3ce386..9f46a6809 100644
--- a/src/Blocks/CMakeLists.txt
+++ b/src/Blocks/CMakeLists.txt
@@ -1,5 +1,3 @@
-
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 76a18801d..13bf6e379 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,4 +1,3 @@
-cmake_minimum_required (VERSION 2.8.2)
 project (Cuberite)
 
 
@@ -252,6 +251,10 @@ else ()
 		foreach (hdr ${FOLDER_HDRS})
 			list(APPEND SOURCE "${folder}/${hdr}")
 		endforeach(hdr)
+
+		# Include this folder's CMakeLists.txt in the project:
+		list(APPEND SOURCE "${folder}/CMakeLists.txt")
+		source_group("${folder}" FILES "${folder}/CMakeLists.txt")
 	endforeach(folder)
 
 	list(APPEND SOURCE "${SRCS}")
@@ -315,19 +318,26 @@ if (MSVC)
 		list (APPEND BINDINGS_DEPENDENCIES "Bindings/${dep}")
 	endforeach(dep)
 
-	ADD_CUSTOM_COMMAND(
-		OUTPUT ${BINDING_OUTPUTS}
-
-		# Copy the Lua DLL into the Bindings folder, so that tolua can run from there:
-		COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_SOURCE_DIR}/Server/lua51.dll ./lua51.dll
+	if (HAS_LUA_INTERPRETER)
+		ADD_CUSTOM_COMMAND(
+			OUTPUT ${BINDING_OUTPUTS}
+			COMMAND lua BindingsProcessor.lua
+			WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/Bindings/
+			DEPENDS ${BINDINGS_DEPENDENCIES}
+		)
+	else()
+		ADD_CUSTOM_COMMAND(
+			OUTPUT ${BINDING_OUTPUTS}
 
-		# Regenerate bindings:
-		COMMAND tolua -L BindingsProcessor.lua -o Bindings.cpp -H Bindings.h AllToLua.pkg
-		WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/Bindings/
+			# Copy the Lua DLL into the Bindings folder, so that tolua can run from there:
+			COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_SOURCE_DIR}/Server/lua51.dll ./lua51.dll
 
-		# add any new generation dependencies here
-		DEPENDS ${BINDINGS_DEPENDENCIES}
-	)
+			# Regenerate bindings:
+			COMMAND tolua -L BindingsProcessor.lua -o Bindings.cpp -H Bindings.h AllToLua.pkg
+			WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/Bindings/
+			DEPENDS ${BINDINGS_DEPENDENCIES} tolua
+		)
+	endif()
 endif()
 
 add_executable(${EXECUTABLE} ${SOURCE})
@@ -378,3 +388,6 @@ if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
 endif()
 
 target_link_libraries(${EXECUTABLE} luaexpat jsoncpp_lib_static mbedtls zlib sqlite lua SQLiteCpp event_core event_extra)
+
+# Create a folder for Bindings' documentation:
+FILE(MAKE_DIRECTORY "Bindings/docs")
diff --git a/src/Chunk.h b/src/Chunk.h
index 162c8de96..925680fdd 100644
--- a/src/Chunk.h
+++ b/src/Chunk.h
@@ -397,7 +397,7 @@ public:
 	/** Set a meta value, with the option of not informing the client and / or not marking dirty.
 	Used for setting metas that are of little value for saving to disk and / or for sending to the client,
 	such as leaf decay flags. */
-	inline void SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Meta, bool a_ShouldMarkDirty = true, bool a_ShouldInformClient = true)
+	inline void SetMeta(int a_RelX, int a_RelY, int a_RelZ, NIBBLETYPE a_Meta, bool a_ShouldMarkDirty = true, bool a_ShouldInformClients = true)
 	{
 			bool hasChanged = m_ChunkData.SetMeta(a_RelX, a_RelY, a_RelZ, a_Meta);
 			if (hasChanged)
@@ -406,7 +406,7 @@ public:
 				{
 					MarkDirty();
 				}
-				if (a_ShouldInformClient)
+				if (a_ShouldInformClients)
 				{
 					m_PendingSendBlocks.push_back(sSetBlock(m_PosX, m_PosZ, a_RelX, a_RelY, a_RelZ, GetBlock(a_RelX, a_RelY, a_RelZ), a_Meta));
 				}
diff --git a/src/ChunkMap.cpp b/src/ChunkMap.cpp
index 55cabaa67..cb60b4841 100644
--- a/src/ChunkMap.cpp
+++ b/src/ChunkMap.cpp
@@ -1228,7 +1228,7 @@ NIBBLETYPE cChunkMap::GetBlockBlockLight(int a_BlockX, int a_BlockY, int a_Block
 
 
 
-void cChunkMap::SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockMeta, bool a_ShouldMarkDirty, bool a_ShouldInformClient)
+void cChunkMap::SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockMeta, bool a_ShouldMarkDirty, bool a_ShouldInformClients)
 {
 	int ChunkX, ChunkZ;
 	cChunkDef::AbsoluteToRelative(a_BlockX, a_BlockY, a_BlockZ, ChunkX, ChunkZ);
@@ -1238,7 +1238,7 @@ void cChunkMap::SetBlockMeta(int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYP
 	cChunkPtr Chunk = GetChunk(ChunkX, ChunkZ);
 	if ((Chunk != nullptr) && Chunk->IsValid())
 	{
-		Chunk->SetMeta(a_BlockX, a_BlockY, a_BlockZ, a_BlockMeta, a_ShouldMarkDirty, a_ShouldInformClient);
+		Chunk->SetMeta(a_BlockX, a_BlockY, a_BlockZ, a_BlockMeta, a_ShouldMarkDirty, a_ShouldInformClients);
 	}
 }
 
diff --git a/src/ChunkMap.h b/src/ChunkMap.h
index 8a604ac09..70d9954eb 100644
--- a/src/ChunkMap.h
+++ b/src/ChunkMap.h
@@ -158,7 +158,7 @@ public:
 	NIBBLETYPE GetBlockMeta      (int a_BlockX, int a_BlockY, int a_BlockZ);
 	NIBBLETYPE GetBlockSkyLight  (int a_BlockX, int a_BlockY, int a_BlockZ);
 	NIBBLETYPE GetBlockBlockLight(int a_BlockX, int a_BlockY, int a_BlockZ);
-	void       SetBlockMeta      (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockMeta, bool a_ShouldMarkDirty, bool a_ShouldInformClient);
+	void       SetBlockMeta      (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_BlockMeta, bool a_ShouldMarkDirty, bool a_ShouldInformClients);
 	void       SetBlock          (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, bool a_SendToClients = true);
 	bool       GetBlockTypeMeta  (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta);
 	bool       GetBlockInfo      (int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_Meta, NIBBLETYPE & a_SkyLight, NIBBLETYPE & a_BlockLight);
diff --git a/src/Enchantments.h b/src/Enchantments.h
index e2f10be63..acc15dc7e 100644
--- a/src/Enchantments.h
+++ b/src/Enchantments.h
@@ -79,7 +79,7 @@ public:
 	cEnchantments(const AString & a_StringSpec);
 
 	/** Adds the enchantments contained in a_Other into this object.
-	Existing enchantments are preserved, unless a_Other specifies a different level, in which case the level is changed. */
+	Existing enchantments are preserved, unless a_Other specifies a different level, in which case the level is changed to the a_Other's one. */
 	void Add(const cEnchantments & a_Other);
 
 	/** Adds enchantments in the stringspec; if a specified enchantment already exists, overwrites it */
diff --git a/src/Entities/CMakeLists.txt b/src/Entities/CMakeLists.txt
index 0416d5338..488c8da59 100644
--- a/src/Entities/CMakeLists.txt
+++ b/src/Entities/CMakeLists.txt
@@ -1,5 +1,3 @@
-
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
diff --git a/src/Entities/Entity.h b/src/Entities/Entity.h
index 6923795db..c543fd9c1 100644
--- a/src/Entities/Entity.h
+++ b/src/Entities/Entity.h
@@ -305,7 +305,7 @@ public:
 	/** Returns the hitpoints that this pawn can deal to a_Receiver using its equipped items */
 	virtual int GetRawDamageAgainst(const cEntity & a_Receiver);
 
-	/** Returns whether armor will protect against the passed damage type */
+	/** Returns whether armor will protect against the specified damage type */
 	virtual bool ArmorCoversAgainst(eDamageType a_DamageType);
 
 	/** Returns the hitpoints out of a_RawDamage that the currently equipped armor would cover */
@@ -329,9 +329,13 @@ public:
 	/** Returns the currently equipped boots; empty item if none */
 	virtual cItem GetEquippedBoots(void) const { return cItem(); }
 
-	/** Called when the health drops below zero. a_Killer may be nullptr (environmental damage) */
+	// tolua_end
+
+	/** Called when the health drops below zero. a_TDI's Attacker may be nullptr (environmental damage) */
 	virtual void KilledBy(TakeDamageInfo & a_TDI);
 
+	// tolua_begin
+
 	/** Called when the entity kills another entity */
 	virtual void Killed(cEntity * a_Victim) {}
 
@@ -404,7 +408,7 @@ public:
 	virtual void TeleportToCoords(double a_PosX, double a_PosY, double a_PosZ);
 
 	/** Schedules a MoveToWorld call to occur on the next Tick of the entity */
-	void ScheduleMoveToWorld(cWorld * a_World, Vector3d a_NewPosition, bool a_SetPortalCooldown = false);
+	void ScheduleMoveToWorld(cWorld * a_World, Vector3d a_NewPosition, bool a_ShouldSetPortalCooldown = false);
 
 	bool MoveToWorld(cWorld * a_World, bool a_ShouldSendRespawn, Vector3d a_NewPosition);
 
diff --git a/src/Entities/Pawn.h b/src/Entities/Pawn.h
index 05bc09e88..6a7035ee6 100644
--- a/src/Entities/Pawn.h
+++ b/src/Entities/Pawn.h
@@ -39,23 +39,17 @@ public:
 
 	// tolua_begin
 
-	/** Applies an entity effect
+	/** Applies an entity effect.
 	Checks with plugins if they allow the addition.
-	@param a_EffectType          The entity effect to apply
-	@param a_EffectDurationTicks The duration of the effect
-	@param a_EffectIntensity     The level of the effect (0 = Potion I, 1 = Potion II, etc)
-	@param a_DistanceModifier    The scalar multiplied to the potion duration, only applies to splash potions)
+	a_EffectIntensity is the level of the effect (0 = Potion I, 1 = Potion II, etc).
+	a_DistanceModifier is the scalar multiplied to the potion duration (only applies to splash potions).
 	*/
 	void AddEntityEffect(cEntityEffect::eType a_EffectType, int a_EffectDurationTicks, short a_EffectIntensity, double a_DistanceModifier = 1);
 
-	/** Removes a currently applied entity effect
-	@param a_EffectType The entity effect to remove
-	*/
+	/** Removes a currently applied entity effect. */
 	void RemoveEntityEffect(cEntityEffect::eType a_EffectType);
 
-	/** Returns true, if the entity effect is currently applied
-	@param a_EffectType The entity effect to check
-	*/
+	/** Returns true, if the entity effect is currently applied. */
 	bool HasEntityEffect(cEntityEffect::eType a_EffectType) const;
 
 	/** Removes all currently applied entity effects (used when drinking milk) */
@@ -63,7 +57,7 @@ public:
 
 	// tolua_end
 
-	/** remove the monster from the list of monsters targeting this pawn. */
+	/** Remove the monster from the list of monsters targeting this pawn. */
 	void NoLongerTargetingMe(cMonster * a_Monster);
 
 	/** Add the monster to the list of monsters targeting this pawn. (Does not check if already in list!) */
diff --git a/src/Generating/CMakeLists.txt b/src/Generating/CMakeLists.txt
index dd346b6c4..8b0577129 100644
--- a/src/Generating/CMakeLists.txt
+++ b/src/Generating/CMakeLists.txt
@@ -1,5 +1,3 @@
-
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
diff --git a/src/Generating/ChunkDesc.cpp b/src/Generating/ChunkDesc.cpp
index fcbebf1ca..6ba63d5ce 100644
--- a/src/Generating/ChunkDesc.cpp
+++ b/src/Generating/ChunkDesc.cpp
@@ -72,7 +72,7 @@ void cChunkDesc::SetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE
 
 
 
-void cChunkDesc::GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta)
+void cChunkDesc::GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const
 {
 	m_BlockArea.GetRelBlockTypeMeta(a_RelX, a_RelY, a_RelZ, a_BlockType, a_BlockMeta);
 }
diff --git a/src/Generating/ChunkDesc.h b/src/Generating/ChunkDesc.h
index aa689fcd6..9e3f4af5e 100644
--- a/src/Generating/ChunkDesc.h
+++ b/src/Generating/ChunkDesc.h
@@ -52,7 +52,12 @@ public:
 
 	void       FillBlocks(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
 	void       SetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta);
-	void       GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta);
+
+	// tolua_end
+	/** Returns the BlockType and BlockMeta at the specified coords.
+	Exported to Lua manually to avoid extra parameters generated by ToLua++. */
+	void GetBlockTypeMeta(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE & a_BlockType, NIBBLETYPE & a_BlockMeta) const;
+	// tolua_begin
 
 	void       SetBlockType(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType);
 	BLOCKTYPE  GetBlockType(int a_RelX, int a_RelY, int a_RelZ);
diff --git a/src/HTTP/CMakeLists.txt b/src/HTTP/CMakeLists.txt
index acb3ac2cd..03cda2adc 100644
--- a/src/HTTP/CMakeLists.txt
+++ b/src/HTTP/CMakeLists.txt
@@ -1,5 +1,3 @@
-
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
diff --git a/src/IniFile.h b/src/IniFile.h
index 2eb81c879..37bf451d7 100644
--- a/src/IniFile.h
+++ b/src/IniFile.h
@@ -79,7 +79,8 @@ public:
 	Returns true if successful, false otherwise. */
 	bool ReadFile(const AString & a_FileName, bool a_AllowExampleRedirect = true);
 
-	/** Writes data stored in class to the specified ini file */
+	/** Writes data stored in class to the specified ini file.
+	Returns true on success, false on failure. */
 	bool WriteFile(const AString & a_FileName) const;
 
 	virtual bool Flush() override { return WriteFile(m_Filename); }
diff --git a/src/Inventory.h b/src/Inventory.h
index adad2fcbb..2bcc66ec1 100644
--- a/src/Inventory.h
+++ b/src/Inventory.h
@@ -62,10 +62,10 @@ public:
 	void Clear(void);
 
 	/** Returns number of items out of a_ItemStack that can fit in the storage */
-	int HowManyCanFit(const cItem & a_ItemStack, bool a_ConsiderEmptySlots);
+	int HowManyCanFit(const cItem & a_ItemStack, bool a_ConsiderEmptySlots = true);
 
 	/** Returns how many items of the specified type would fit into the slot range specified */
-	int HowManyCanFit(const cItem & a_ItemStack, int a_BeginSlotNum, int a_EndSlotNum, bool a_ConsiderEmptySlots);
+	int HowManyCanFit(const cItem & a_ItemStack, int a_BeginSlotNum, int a_EndSlotNum, bool a_ConsiderEmptySlots = true);
 
 	/** Adds as many items out of a_ItemStack as can fit.
 	If a_AllowNewStacks is set to false, only existing stacks can be topped up;
diff --git a/src/ItemGrid.h b/src/ItemGrid.h
index 090649c44..46e200b9c 100644
--- a/src/ItemGrid.h
+++ b/src/ItemGrid.h
@@ -78,10 +78,9 @@ public:
 
 	/** Adds as many items out of a_ItemStack as can fit.
 	If a_AllowNewStacks is set to false, only existing stacks can be topped up;
-	if a_AllowNewStacks is set to true, empty slots can be used for the rest.
-	If a_PrioritarySlot is set to a positive value, then the corresponding slot will be used in
-	first (if empty or compatible with added items)
-	if a_PrioritarySlot is set to -1, regular order apply
+	If a_AllowNewStacks is set to true, empty slots can be used for the rest.
+	If a_PrioritarySlot is set to a positive value, then the corresponding slot will be used  first (if empty or compatible with added items).
+	If a_PrioritarySlot is set to -1, regular order applies.
 	Returns the number of items that fit.
 	*/
 	int AddItem(cItem & a_ItemStack, bool a_AllowNewStacks = true, int a_PrioritarySlot = -1);
@@ -89,10 +88,9 @@ public:
 	/** Same as AddItem, but works on an entire list of item stacks.
 	The a_ItemStackList is modified to reflect the leftover items.
 	If a_AllowNewStacks is set to false, only existing stacks can be topped up;
-	if a_AllowNewStacks is set to true, empty slots can be used for the rest.
-	If a_PrioritarySlot is set to a positive value, then the corresponding slot will be used in
-	first (if empty or compatible with added items)
-	if a_PrioritarySlot is set to -1, regular order apply
+	If a_AllowNewStacks is set to true, empty slots can be used for the rest.
+	If a_PrioritarySlot is set to a positive value, then the corresponding slot will be used first (if empty or compatible with added items).
+	If a_PrioritarySlot is set to -1, regular order applies.
 	Returns the total number of items that fit.
 	*/
 	int AddItems(cItems & a_ItemStackList, bool a_AllowNewStacks = true, int a_PrioritarySlot = -1);
diff --git a/src/Items/CMakeLists.txt b/src/Items/CMakeLists.txt
index 9b3a2d8b5..f7341bb53 100644
--- a/src/Items/CMakeLists.txt
+++ b/src/Items/CMakeLists.txt
@@ -1,5 +1,3 @@
-
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
diff --git a/src/Mobs/CMakeLists.txt b/src/Mobs/CMakeLists.txt
index 4336af7c3..85fdb4b1b 100644
--- a/src/Mobs/CMakeLists.txt
+++ b/src/Mobs/CMakeLists.txt
@@ -1,5 +1,3 @@
-
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
diff --git a/src/Noise/CMakeLists.txt b/src/Noise/CMakeLists.txt
index 4e99347f8..3c9e723d3 100644
--- a/src/Noise/CMakeLists.txt
+++ b/src/Noise/CMakeLists.txt
@@ -1,5 +1,3 @@
-
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
diff --git a/src/OSSupport/CMakeLists.txt b/src/OSSupport/CMakeLists.txt
index ee8067c6f..876b4f789 100644
--- a/src/OSSupport/CMakeLists.txt
+++ b/src/OSSupport/CMakeLists.txt
@@ -1,5 +1,3 @@
-
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
diff --git a/src/PolarSSL++/CMakeLists.txt b/src/PolarSSL++/CMakeLists.txt
index 3f268ad13..375e6f51e 100644
--- a/src/PolarSSL++/CMakeLists.txt
+++ b/src/PolarSSL++/CMakeLists.txt
@@ -1,4 +1,3 @@
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
diff --git a/src/Protocol/CMakeLists.txt b/src/Protocol/CMakeLists.txt
index 3668f0c42..783bcd79c 100644
--- a/src/Protocol/CMakeLists.txt
+++ b/src/Protocol/CMakeLists.txt
@@ -1,5 +1,3 @@
-
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
diff --git a/src/Simulator/CMakeLists.txt b/src/Simulator/CMakeLists.txt
index 98b4499c7..dcd099890 100644
--- a/src/Simulator/CMakeLists.txt
+++ b/src/Simulator/CMakeLists.txt
@@ -1,5 +1,3 @@
-
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
diff --git a/src/Simulator/IncrementalRedstoneSimulator/CMakeLists.txt b/src/Simulator/IncrementalRedstoneSimulator/CMakeLists.txt
index 87052d00a..99d87ce88 100644
--- a/src/Simulator/IncrementalRedstoneSimulator/CMakeLists.txt
+++ b/src/Simulator/IncrementalRedstoneSimulator/CMakeLists.txt
@@ -1,4 +1,3 @@
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
diff --git a/src/UI/CMakeLists.txt b/src/UI/CMakeLists.txt
index 6753c453e..e1e82c88d 100644
--- a/src/UI/CMakeLists.txt
+++ b/src/UI/CMakeLists.txt
@@ -1,5 +1,3 @@
-
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")
diff --git a/src/UI/Window.h b/src/UI/Window.h
index 8a70b5855..e1b91ccc7 100644
--- a/src/UI/Window.h
+++ b/src/UI/Window.h
@@ -77,6 +77,8 @@ public:
 
 	char GetWindowID(void) const { return m_WindowID; }  // tolua_export
 	int GetWindowType(void) const { return m_WindowType; }  // tolua_export
+
+	/** Returns the textual representation of the window's type, such as "minecraft:chest". */
 	const AString GetWindowTypeName(void) const;  // tolua_export
 
 	cWindowOwner * GetOwner(void) { return m_Owner; }
@@ -136,10 +138,12 @@ public:
 	const AString & GetWindowTitle() const { return m_WindowTitle; }
 	void SetWindowTitle(const AString & a_WindowTitle) { m_WindowTitle = a_WindowTitle; }
 
-	/** Sends the UpdateWindowProperty (0x69) packet to all clients of the window */
+	/** Updates a numerical property associated with the window. Typically used for furnace progressbars.
+	Sends the UpdateWindowProperty packet to all clients of the window */
 	virtual void SetProperty(short a_Property, short a_Value);
 
-	/** Sends the UpdateWindowPropert(0x69) packet to the specified player */
+	/** Updates a numerical property associated with the window. Typically used for furnace progressbars.
+	Sends the UpdateWindowProperty packet only to the specified player */
 	virtual void SetProperty(short a_Property, short a_Value, cPlayer & a_Player);
 
 	// tolua_end
diff --git a/src/Vector3.h b/src/Vector3.h
index 4fa9ff46c..8c8dc6ad4 100644
--- a/src/Vector3.h
+++ b/src/Vector3.h
@@ -67,6 +67,10 @@ public:
 		);
 	}
 
+	// tolua_end
+
+	/** Sets the given vector to the normalized version of this vector.
+	Removed from LuaAPI, because Lua doesn't need distinguishing from the other overload. */
 	inline void NormalizeCopy(Vector3<T> & a_Rhs) const
 	{
 		double Len = 1.0 / Length();
@@ -78,6 +82,8 @@ public:
 		);
 	}
 
+	// tolua_begin
+
 	inline bool HasNonZeroLength(void) const
 	{
 		#ifdef __clang__
@@ -168,7 +174,7 @@ public:
 		z += a_Diff.z;
 	}
 
-	/** Runs each value of the vector through std::floor() */
+	/** Returns a new Vector3i with coords set to std::floor() of this vector's coords. */
 	inline Vector3<int> Floor(void) const
 	{
 		return Vector3<int>(
diff --git a/src/World.cpp b/src/World.cpp
index a8225693f..557e110d7 100644
--- a/src/World.cpp
+++ b/src/World.cpp
@@ -2082,9 +2082,9 @@ void cWorld::SetBlock(int a_BlockX, int a_BlockY, int a_BlockZ, BLOCKTYPE a_Bloc
 
 
 
-void cWorld::SetBlockMeta(int a_X, int a_Y, int a_Z, NIBBLETYPE a_MetaData, bool a_ShouldMarkDirty, bool a_ShouldInformClient)
+void cWorld::SetBlockMeta(int a_X, int a_Y, int a_Z, NIBBLETYPE a_MetaData, bool a_ShouldMarkDirty, bool a_ShouldInformClients)
 {
-	m_ChunkMap->SetBlockMeta(a_X, a_Y, a_Z, a_MetaData, a_ShouldMarkDirty, a_ShouldInformClient);
+	m_ChunkMap->SetBlockMeta(a_X, a_Y, a_Z, a_MetaData, a_ShouldMarkDirty, a_ShouldInformClients);
 }
 
 
diff --git a/src/World.h b/src/World.h
index 368828225..fbe1f4a6d 100644
--- a/src/World.h
+++ b/src/World.h
@@ -402,7 +402,7 @@ public:
 		return m_ChunkMap->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
 	}
 
-	void       SetBlockMeta      (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_MetaData, bool a_ShouldMarkDirty = true, bool a_ShouldInformClient = true);
+	void       SetBlockMeta      (int a_BlockX, int a_BlockY, int a_BlockZ, NIBBLETYPE a_MetaData, bool a_ShouldMarkDirty = true, bool a_ShouldInformClients = true);
 	NIBBLETYPE GetBlockSkyLight  (int a_BlockX, int a_BlockY, int a_BlockZ);
 	NIBBLETYPE GetBlockBlockLight(int a_BlockX, int a_BlockY, int a_BlockZ);
 
diff --git a/src/WorldStorage/CMakeLists.txt b/src/WorldStorage/CMakeLists.txt
index 1d8b60140..b16e03160 100644
--- a/src/WorldStorage/CMakeLists.txt
+++ b/src/WorldStorage/CMakeLists.txt
@@ -1,5 +1,3 @@
-
-cmake_minimum_required (VERSION 2.6)
 project (Cuberite)
 
 include_directories ("${PROJECT_SOURCE_DIR}/../")