#! /bin/bash

# Written by Carlo Wood, September/October 2016.

function fatal
{
	echo "$0: ERROR: $*"
	exit 1
}

# Make sure we're not having a broken gawk.
AWK_VERSION=$(awk -V | head -n 1)
if [[ $AWK_VERSION =~ ^GNU\ Awk\ 4\.[0-9]+\.[0-9]+ ]]; then
	AWK_VERSION=$(echo $AWK_VERSION | sed -e 's/GNU Awk \(4\.[0-9]*\.[0-9]*\).*/\1/')
	if [[ $AWK_VERSION =~ ^4\.0*([2-9]+|1\.0*[2-9]+) ]]; then
		fatal "Your version of awk ($AWK_VERSION) is broken. Please use version 4.1.1 or lower."
	fi
fi
echo "AWK_VERSION=$AWK_VERSION"

# Find out what the base directory is.
BASEDIR="$(dirname $(dirname $(readlink -en "$0")))"
echo "BASEDIR=\"$BASEDIR\""
striplen=$((${#BASEDIR} + 2))

# BASEDIR may not contain a space, that's just too hard to get to work.
expr index "$BASEDIR" " " >/dev/null && fatal "it is not supported that BASEDIR contains a space."

# Make sure that worked.
test -f $BASEDIR/cmake/posix/px4_impl_posix.cmake || fatal "Failed to determine BASEDIR: '\$BASEDIR/cmake/posix/px4_impl_posix.cmake' is not a regular file."

# Parse command line parameters.
debug=0	# Set to non-zero to enable debugging.
force=0	# Set to 1 to force running of script even when there are uncommitted changes.
merge=0	# Set to 1 when merging a branch that didn't run this script into master that did already run this script.
while [[ $# -gt 0 ]]
do
	case $1 in
		--debug)
			debug=1
			;;
		--force)
			force=1
			;;
		--merge)
			force=1
			merge=1
			fatal "--merge is not implemented yet."
			;;
		-*)
			fatal "Unknown option $1"
			;;
		--|*)
			break
			;;
	esac
	shift
done
non_option_arguments=$#
if [ $non_option_arguments -eq 0 -a $debug -ne 0 ]; then
	fatal "--debug screws up the source files with debug output! You must provide a single filename to run on."
fi

# Better not run this script with changes that still need to be committed.
cd "$BASEDIR" || fatal "Could not change directory to \"$BASEDIR\""
if ! git diff-index --quiet HEAD --; then
	if [ $non_option_arguments -ne 0 -o $force -eq 1 ]; then
		if [ $force -eq 1 ]; then
			echo "Uncommitted changes, but running anyway because --force is used."
		else
			echo -n "WARNING: You have uncommitted changes (use --force to remove this warning). Run anyway? [y/N] "
			read answer
			if [ "x$answer" != "xy" -a "x$answer" != "xY" ]; then exit 0; fi
		fi
	else
		fatal "Your working directory has uncommitted changes (see 'git status')! Bailing out."
	fi
fi

# Find a reasonable tmp directory.
# First make a list of all build directories by looking for a CMakeCache.txt in them. Sort them so the most recent one is first.
CMAKECACHE_FILES=$(find "$BASEDIR" -mindepth 2 -maxdepth 2 -type f -name CMakeCache.txt -wholename "$BASEDIR/build/*/CMakeCache.txt" | xargs /bin/ls -td)
# Make a list of all candidate tmp directories.
TMPDIRS=
for f in $CMAKECACHE_FILES; do
	if [ -d $(dirname $f)/tmp ]; then
		TMPDIRS+=" $(dirname $f)/tmp"
	fi
done
# Put BASEDIR first in case there are no build directories because /tmp is probably on a different file system.
TMPDIRS+=" $BASEDIR /tmp ."
# Pick the first one that is actually writable.
for tmp in $TMPDIRS; do
	TMPDIR="$tmp"
	if [ -w "$TMPDIR" ]; then
		break;
	fi
done
test -n "$TMPDIR" || fatal "Can not find a writable tmp directory."
echo "TMPDIR=\"$TMPDIR\""

# Make a list of all source and header files that we need to fix.
# List of directories that we don't want to touch.
EXCLUDE_FOLDERS=".git Tools"
EXCLUDE_PATTERNS="examples matlab/scripts tests test unit_test *_test *_tests test_* apps/test_* UnitTests"
# A regular expression for the exclude patterns.
EXCLUDE_PATTERNS_RE="($(echo $EXCLUDE_PATTERNS | sed -e 's/\*/[^\/]*/g;s/ /|/g'))"
# Extensions of files that we do want to change (leaving out .y and .py for now).
C_EXTENSIONS=".c .c_in .c_shipped"
H_EXTENSIONS=".h .h.in .h_template"
CXX_EXTENSIONS=".cc .cpp .cpp.in .cxx .cpp_template"
HXX_EXTENSIONS=".hh .hpp .hxx"
# The regular expression that we consider to be an #include.
INCLUDE_RE='^[[:space:]]*#[[:space:]]*include[[:space:]]*[<"]'
# Regular expression for empty lines.
EMPTY_LINE_RE='^[[:space:]]*$'
# Regular expression for one-line comments.
COMMENT_LINE_RE='^[[:space:]]*(\/\/.*|\/\*([^*]|\*+[^\/*])*\*+\/[[:space:]]*)$'
# Regular expression for a #define (on one line).
DEFINE_RE='^[[:space:]]*#[[:space:]]*define[[:space:]].*[^\\]$'
# Regular expression for an #if[[n]def].
IF_RE='^[[:space:]]*#[[:space:]]*if(n?def)?[[:space:]]'
# Regular expression for an #endif.
ENDIF_RE='^[[:space:]]*#[[:space:]]*endif($|[^[:alnum:]])'
# Regular expression for header file extension.
HEADER_RE="($(echo $H_EXTENSIONS $HXX_EXTENSIONS | sed -e 's/\./\\./g;s/ /|/g'))"
# Regular expression for C++ source and header files.
CXXSRC_RE="($(echo $CXX_EXTENSIONS $HXX_EXTENSIONS | sed -e 's/\./\\./g;s/ /|/g'))"
# List of standard C header files. Note that cfcntl, cshed and cunistd are NOT standard header files, even though they are in NuttX/nuttx/include/cxx.
REAL_STDC_HEADERS_RE='(cassert|ccomplex|cctype|cerrno|cfenv|cfloat|cinttypes|ciso646|climits|clocale|cmath|csetjmp|csignal|cstdalign|cstdarg|cstdbool|cstddef|cstdint|cstdio|cstdlib|cstring|ctgmath|ctime|cuchar|cwchar|cwctype)'
STDC_HEADERS=$(find "$BASEDIR/NuttX/nuttx/include/cxx" -mindepth 1 -maxdepth 1 -type f | xargs basename -a | grep -E "$REAL_STDC_HEADERS_RE" | xargs echo)
# Regular expression of standard C header files, but with the leading 'c' stripped.
STDC_HEADERS_RE="($(echo $STDC_HEADERS | sed -e 's/^c//;s/ c/|/g'))"
# Actual list of standard C header files.
# List of standard C++ header files.
REAL_STDCXX_HEADERS_RE='(algorithm|any|array|atomic|bitset|cassert|ccomplex|cctype|cerrno|cfenv|cfloat|chrono|cinttypes|ciso646|climits|clocale|cmath|codecvt|complex|condition_variable|csetjmp|csignal|cstdalign|cstdarg|cstdbool|cstddef|cstdint|cstdio|cstdlib|cstring|ctgmath|ctime|cuchar|cwchar|cwctype|deque|exception|execution|filesystem|forward_list|fstream|functional|future|initializer_list|iomanip|ios|iosfwd|iostream|istream|iterator|limits|list|locale|map|memory|memory_resource|mutex|new|numeric|optional|ostream|queue|random|ratio|regex|scoped_allocator|set|shared_mutex|sstream|stack|stdexcept|streambuf|string|string_view|strstream|system_error|thread|tuple|typeindex|typeinfo|type_traits|unordered_map|unordered_set|utility|valarray|variant|vector)'
STDCXX_HEADERS=$(find "$BASEDIR/NuttX/misc/uClibc++/include/uClibc++" -mindepth 1 -maxdepth 1 -type f | xargs basename -a | grep -E "$REAL_STDCXX_HEADERS_RE" | grep -E -v "$REAL_STDC_HEADERS_RE" | xargs echo)
# Regular expression of C++ header files.
STDCXX_HEADERS_RE="($(echo $STDCXX_HEADERS | sed -e 's/ /|/g'))"
# Regular expression for #pragma once.
PRAGMA_ONCE_RE='^#pragma once'
# Regular expression to recognize the start of a C-comment block.
COMMENT_BEGIN_RE='(^|[^\/])\/\*([^*]|\*+($|[^\/*]))*$'
# Regular expression to recognize the end of a C-comment block.
COMMENT_END_RE='\*\/'
# Regular expression to match C++ unsafe headers. We currently don't have any C++ unsafe headers, do we?
# v2.0/standard/mavlink.h is not unsafe, but this way the script will leave it alone and not
# move it above function declarations that need to be declared before including it.
UNSAFE_HEADERS_RE='(v2\.0\/standard\/mavlink\.h)'
#UNSAFE_HEADERS_RE='(stm32\.h|arch\/board\/board\.h)'

# Find all submodules.
test -f $BASEDIR/.gitmodules || fatal "No such file: $BASEDIR/.gitmodules"
SUBMODULES=$(grep -A 1 '^\[submodule' $BASEDIR/.gitmodules | grep '^[[:space:]]*path = ' | sed -r -e 's/^[[:space:]]*path = //' | xargs echo)
echo "SUBMODULES=\"$SUBMODULES\""
SUBMODULES_RE="($(echo $SUBMODULES | sed -e 's/ /|/g'))"

# Disable path name expansion (otherwise the find patterns will be expanded against the files in the current working directory).
set -f

EXCLUDE_ARGS=
for excl in $EXCLUDE_FOLDERS; do
	if [ -z "$EXCLUDE_ARGS" ]; then
		EXCLUDE_ARGS="-wholename $BASEDIR/$excl/*"
	else
		EXCLUDE_ARGS+=" -o -wholename $BASEDIR/$excl/*"
	fi
done
for excl in $EXCLUDE_PATTERNS; do
	EXCLUDE_ARGS+=" -o -wholename */$excl/*"
done
INCLUDE_H_ARGS=
for ext in $H_EXTENSIONS $HXX_EXTENSIONS; do
	if [ -z "$INCLUDE_H_ARGS" ]; then
		INCLUDE_H_ARGS="-name *$ext"
	else
		INCLUDE_H_ARGS+=" -o -name *$ext"
	fi
done
INCLUDE_C_ARGS=
for ext in $C_EXTENSIONS $CXX_EXTENSIONS; do
	if [ -z "$INCLUDE_C_ARGS" ]; then
		INCLUDE_C_ARGS="-name *$ext"
	else
		INCLUDE_C_ARGS+=" -o -name *$ext"
	fi
done
# Also exclude all submodules -- because we don't maintain those (are we?).
for subm in $SUBMODULES; do
	if [ -z "$SUBMODULES_ARGS" ]; then
		SUBMODULES_ARGS="-wholename $BASEDIR/$subm/*"
	else
		SUBMODULES_ARGS+=" -o -wholename $BASEDIR/$subm/*"
	fi
done

echo -n "Finding all source files with #include's (excluding submodules and build directory)... "
find $BASEDIR -mindepth 2 -type f ! \( -wholename $BASEDIR/build/* -o $EXCLUDE_ARGS -o $SUBMODULES_ARGS \) \( $INCLUDE_C_ARGS -o $INCLUDE_H_ARGS \) > $TMPDIR/fix_headers_sources
cat "$TMPDIR/fix_headers_sources" | xargs grep -l "$INCLUDE_RE" > $TMPDIR/fix_headers_sources_with_includes
echo "done"
number_of_files=$(sed -n '$=' "$TMPDIR/fix_headers_sources_with_includes")
count=0

echo -n "Finding all submodule header files (excluding stdc++ headers)... "
find $BASEDIR -type f ! \( $EXCLUDE_ARGS \) \( $SUBMODULES_ARGS \) \( $INCLUDE_H_ARGS \) > $TMPDIR/fix_headers_SUBMODULE_HEADERS
echo "done"

echo -n "Finding all header files (excluding stdc++ headers)... "
find $BASEDIR -type f ! \( $EXCLUDE_ARGS \) -wholename $BASEDIR/build/* \( $INCLUDE_H_ARGS \) > $TMPDIR/fix_headers_HEADERS
grep -E "$HEADER_RE" $TMPDIR/fix_headers_sources >> $TMPDIR/fix_headers_HEADERS
cat $TMPDIR/fix_headers_SUBMODULE_HEADERS >> $TMPDIR/fix_headers_HEADERS
echo "done"

echo -n "Finding all include paths... "
for f in `cat $TMPDIR/fix_headers_sources_with_includes`; do grep -E "$INCLUDE_RE" $f | sed -r -e "s%$INCLUDE_RE%%"';s/[">].*//'; done | sort -u | grep -E -v "(/|^)$EXCLUDE_PATTERNS_RE/" > $TMPDIR/fix_headers_include_paths
echo "done"

function include_path()
{
	# If the include path starts with a '.', then it is a local header.
	if [[ $1 =~ ^\. ]]; then return 1; fi
	# If the include path starts with 'platforms/' then it is a local header;
	# added this exception here because not everyone has all build_ directories for all targets installed.
	if [[ $1 =~ platforms/ ]]; then return 1; fi
	# apps.h is generated from apps.h.in.
	if [ $1 = "apps.h" ]; then return 1; fi
	# Treat the following headers from src/platforms/*/include as system header because they replace what is found in nuttx (for posix and qurt).
	if [ $1 = "arch/board/board.h" -o $1 = "crc32.h" -o $1 = "i2c.h" -o $1 = "queue.h" -o $1 = "poll.h" -o $1 = "sys/ioctl.h" ]; then return 2; fi
	# Escape the path for reg.exp. matching.
	PATH_RE=$(echo $1 | sed -e 's/\([+.]\)/\\\1/')
	issubmodule=0;
	islocal=0;
	foo=0
	for includedir in $(grep "/$PATH_RE\$" $TMPDIR/fix_headers_HEADERS | cut -c $striplen-); do
		# If the include directory is NuttX header that was copied to the build directory, then it's still a system file.
		if [[ $includedir/ =~ ^build/.*/NuttX/ ]]; then
			issubmodule=1
		# If the include directory is a submodule, then treat it as a system file.
		elif [[ $includedir/ =~ ^$SUBMODULES_RE/ ]]; then
			issubmodule=1;
		else
			islocal=1
		fi
	done
	if [ $islocal -eq 0 ]; then
		if [ $issubmodule -eq 0 ]; then
			# If an include path can't be found then usually it will be a real system header,
			# however, there are a few (ros related?) files that start with px4... In that
			# case just leave the quotes alone ("px4muorb.h" and several <px4/...>).
			if [[ $1 =~ ^px4 ]]; then return 0; fi
			# While if the include path starts with uORB/topics or topics, and it isn't found,
			# then likely we just don't have a build directory. These should be local though.
			# Same for the generated files mixer_multirotor.generated.h and build_git_version.h.
			if [[ $1 =~ ((/|^)topics/|mixer_multirotor\.generated\.h|build_git_version\.h) ]]; then return 1; fi
		fi
		return 2;
	fi	# Submodule or system header.
	if [ $issubmodule -eq 0 ]; then return 1; fi	# Local.
	# Files that are both local and submodule are simply left alone.
	# These are (at this moment): "battery.h" "common.h" "Matrix.hpp" "mavlink.h" "protocol.h" "pwm.h" "spi.h" "Vector.hpp".
	return 0;
}

# Run the include_path function for each of the files in $TMPDIR/fix_headers_include_paths
echo -n "Determining which headers need to be included with double quotes... "
echo -n > $TMPDIR/fix_headers_quotes
for arg in $(cat "$TMPDIR/fix_headers_include_paths"); do
	include_path $arg
	localsystem=$?
	if [ $localsystem -eq 1 ]; then
		echo "$arg \"$arg\"" >> $TMPDIR/fix_headers_quotes
	elif [ $localsystem -eq 2 ]; then
		echo "$arg <$arg>" >> $TMPDIR/fix_headers_quotes
	fi
done
echo "done"

# Truncate the error log.
echo -n > $TMPDIR/fix_headers_ERROR.log

function print_error
{
	echo
	echo -n "  ";
	echo "*** $1" | tee -a "$TMPDIR/fix_headers_ERROR.log"
	return 1
}

if [ $debug -ne 0 ]; then
	# Debug Line.
	DL='if (cdbl != NR) { printf "\n%u. \"%s\"", NR, $0; cdbl = NR }'
	# Debug Begin.
	DB='if (cdbl != NR) { printf "\n%u. \"%s\" ---> ", NR, $0; cdbl = NR } else printf "; "; printf'
	# Debug End.
	DE=''
else
	DL='#'
	DB='#'
	DE=''
fi
# Error Prefix.
EP='###'

# The main function that is called for each source file.
function fixup_header
{
	count=$((count + 1))
	echo -n "[$((100 * count / number_of_files))%] Fixing headers of $1... "

	# Is this a header?
	echo "$1" | sed -e 's/\.in$/;in/;s/.*\././;s/;in$/.in/' | grep -v -E "$HEADER_RE\$" >/dev/null; is_header=$?
	if [ $debug -ne 0 ]; then echo "is_header = \"$is_header\""; fi

	# Is this C++ source?
	echo "$1" | sed -e 's/.*\././' | grep -v -E $CXXSRC_RE >/dev/null; is_cxxsrc=$?
	if [ $debug -ne 0 ]; then echo "is_cxxsrc = \"$is_cxxsrc\""; fi
	dont_make_cxxsrc=1
	if [ $is_cxxsrc -eq 0 -a $is_header -ne 0 ]; then
		grep -m 1 -q -E "^[[:space:]]*(#[[:space:]]*include[[:space:]]*<$STDCXX_HEADERS_RE>|(template|namespace|class)(\$|[^[:alnum:]_]))" "$1"
		dont_make_cxxsrc=$?
	fi
	if [ $dont_make_cxxsrc -eq 0 ]; then
		is_cxxsrc=1
	fi

	# Current directory.
	curdir=$(dirname "$BASEDIR/$1")

	# Parse the file.
	#
	# Returns an array of line[]'s. The first line is either the first #include, when it is outside
	# any #if*...#endif constructs not counting the header guard if the file is a header. For example:
	#
	#	  // Anything here except #include lines.
	#	  #include <first_include.h>	// <-- first line.
	#
	# Or, the first #if* that contains the first #include line. For example:
	#	  // Anything here except #include lines.
	#	  #ifndef FOO_H // header guard.
	#	  #define FOO_H
	#	  int global = 1; // Anything unknown.
	#	  #ifdef SOMETHING		// <-- first line.
	#	  #if maybe_more
	#	    // anything except #include lines.
	#	  #else
	#	    // anything except #include lines.
	#	    #include <first_include.h>
	#
	# Subsequent line[]'s mark the beginning of a new block, where we have the following blocks:
	# type[]		Description
	type_include=0		# An #include, outside #if*...#endif constructs except a possible header guard.
	type_ifincludeendif=1	# #if*...#endif constructs with #include's.
	type_ifendif=2		# #if*...#endif constructs without #include's.
	type_decls=3		# __BEGIN_DECLS ... __END_DECLS block.
	type_macro=4		# Contiguous #define block.
	type_comment=5		#(Multi-line) comments.
	type_emptyline=6	# Empty lines.
	type_pragmaonce=7	# #pragma once (must be outside any #if*...#endif constructs).
	type_end=8		# The first line of the remainder of the file.
	#
	# However, any block NOT containing one or more #include's (all types > 1) will
	# cause subsequent blocks that do not contain #include's to be ignored,
	# with as result that those blocks will be treated as contiguous code blocks.
	# A comment that is followed by a type that is not to be ignored as such
	# is given the type that follows (which itself is then ignored).
	# Empty lines are ignored unless they appear directly in front of a type
	# that is not to be ignored according to the above rules, where 'previous
	# types' then are the types before the empty line.
	#
	# For example:
	#
	#   >	#include <first_header.h>	# type_include
	#   >	#include <second_header.h>	# type_include
	#   >					# type_emptyline
	#   >	#include <third_header.h>	# type_include
	#   ^	#ifdef FOO			# type_ifendif
	#   |	#define BAR 1
	#   |	#endif				# (detected here)
	#   |								<-- ignored because:
	#   v	#define BAZ(x) x // Do baz				<-- ignored (prev and this type in {type_ifendif, type_macro})
	#   >					# type_emptyline
	#   ^	// This include is important:	# type_comment, but then replaced by type_ifincludeendif
	#   |								<-- ignored because:
	#   |	// more here.						<-- ignored same type
	#   |	#ifdef BAR						<-- "ignored": type_ifincludeendif, but put 3 lines higher.
	#   |	#include <bar.h>
	#   v	#endif				# (detected here)
	#   >					# type_emptyline
	#   >	#include <another.h>		# type_include
	#
	# This script stops parsing at the first not recognized line outside #if*...#endif constructs
	# unless no first line was found yet. It does not attempt overly hard to decode rare constructs,
	# most notably anything with a leading C comment is not recognized and will thus lead to an abort.
	# For example the following lines are not recognized:
	#
	# /* Some comment */ #include <header.h>
	# /* Some comment */ // Another comment.
	#
	# Lines that have a trailing comment are recognized (by ignoring the comment).

	result=$(awk "\
		function add(l, t) {
			# First add always succeeds.
			if (ptr > 0) {
				# An empty line is always added, at first, unless the immediate preceding type is an empty line.
				if (t == $type_emptyline && type[ptr - 1] == $type_emptyline) {
					return;				$DB \"ignored because line %d is also empty.\", line[ptr - 1] $DE
				}
				# A comment is always, added at first, unless the preceding non-empty line type is a comment.
				# Same for #include's.
				if (t == $type_comment && last_none_type == t) {
									$DB \"ignoring because same type as last_none_type (%s)\", type_name[t] $DE
					# Gobble up preceding empty lines.
					if (type[ptr - 1] == $type_emptyline) {
						--ptr;			$DB \"ptr = %d; Removed type_emptyline @ line %d\", ptr, line[ptr] $DE
					}
					return;

				}
				# {ifendif, macro}'s are collapsed too.
				if ((t == $type_ifendif || t == $type_macro) && (last_nonws_type == $type_ifendif || last_nonws_type == $type_macro)) {
					# Gobble up preceding comments and empty lines.
					while (ptr > 0 && (type[ptr - 1] == $type_emptyline || type[ptr - 1] == $type_comment)) {
						--ptr;			$DB \"ptr = %d; Removed %s @ line %d\", ptr, type_name[type[ptr]], line[ptr] $DE
					}
					# ptr > 0 here because the first add is never for an empty line or comment.
					last_none_type = type[ptr - 1];	$DB \"last_none_type = %s\", type_name[last_none_type] $DE
					return;
				}
				# type_include and type_pragmaonce and higher are always added.
			}
			if (t == $type_end) {
				# Remove drag.
				while(ptr > 0 && line[ptr - 1] >= l) --ptr;
			}
			# If this type is not an empty line and it was preceded by a comment, then melt it together with that comment.
			else if (t != $type_emptyline && last_none_type == $type_comment) {
				# In this case t cannot be type_comment.
				# Gobble up preceding empty lines.
				if (type[ptr - 1] == $type_emptyline) {
					--ptr;				$DB \"ptr = %d; Removed type_emptyline @ line %d\", ptr, line[ptr] $DE
				}
				# And replace the comment type.
				--ptr;					$DB \"ptr = %d; replacing the %s @ line %d\", ptr, type_name[type[ptr]], line[ptr] $DE
				l = line[ptr];

			}
			line[ptr] = l;					$DB \"ptr = %d; %s @ line %d\", ptr, type_name[t], l $DE;
			type[ptr++] = t;
			if (t != $type_emptyline) {
				last_none_type = t;			$DB \"last_none_type = %s\", type_name[last_none_type] $DE
				if (t != $type_comment)
					last_nonws_type = t;
			}
		}

		BEGIN {
			debug = $debug;		# 0: no debug output; non-zero: print debug output.
			header = $is_header;	# 0: do not look for a header guard; 1: treat first #ifndef as header guard.
			in_if = 0;		# The number of nested levels inside #if, #ifdef or #ifndef ... #endif constructs.
			in_if_base = 0;		# 0: no header guard was found (or #pragma once); 1: an #ifndef header guard was found.
			in_decl = 0;		# 0: not inside a __BEGIN_DECLS ... __END_DECLS block; 1: inside such a block.
			found_guard = 0;	# 0: no header guard was found; 1: a header guard was found (including #pragma once).
			base_if = 0;		# The current base-level #if that we are scanning.
			drag = 0;		# The number of lines since the last certainly relevant line (a base-level #include or a base-level #endif containing one of more #includes).
			skipped = 0;		# 0: No #include was encountered in the current (base-level) #if block; 1: one or more #include's encountered in the current base-level #if block.
			in_comment = 0;		# 0: not in a multi-line C comment; 1: in a multi-line C comment.
			cdbl = 0;		# Current debug line.
			error = 0;		# 0: no error occured; 1: an error occured.
			ptr = 0;		# Current pointer into line[] and type[].
			found_comment_end = 0;	# The last line (possibly the current line) that is/was a multi-line C comment termination.
			last_none_type = -1;	# The last non-emptyline type that was added.
			last_nonws_type = -1;	# The last non-whitespace type that was added.
			# For debug purposes:
			type_name[$type_ifendif] = \"type_ifendif\";
			type_name[$type_ifincludeendif] = \"type_ifincludeendif\";
			type_name[$type_decls] = \"type_decls\";
			type_name[$type_comment] = \"type_comment\";
			type_name[$type_emptyline] = \"type_emptyline\";
			type_name[$type_include] = \"type_include\";
			type_name[$type_macro] = \"type_macro\";
			type_name[$type_pragmaonce] = \"type_pragmaonce\";
			type_name[$type_end] = \"type_end\";
		}

		END {
			last_line = NR - drag;
			add(last_line + 1, $type_end);			$DB \"\n\" $DE;
			# Print output.
			if (error || ptr == 0 || last_line < line[0]) {
				print \"error=1\";
				exit
			}
			printf \"lines=\\\"\";
			for (i = 0; i < ptr - 1; ++i)
				printf \"%d \", line[i];
			printf \"%d\\\"; \", line[ptr - 1];
			printf \"types=\\\"\";
			for (i = 0; i < ptr - 1; ++i)
				printf \"%d \", type[i];
			printf \"%d\\\"; \", type[ptr - 1];
			print \"error=0; first_line=\" line[0] \"; last_line=\" last_line
		}

	#======================================================================================================
	# Handle multi-line C comments.

		/$COMMENT_END_RE/ {
			if (in_comment) {
				in_comment = 0;				$DB \"comment end\" $DE;
				found_comment_end = NR;
				sub(/^([^*]|\*+[^*\/])*\*+\//, \"\")	# Remove the tail of the comment.
			}
			# FALL-THROUGH
		}

		{
			if (in_comment) {
				++drag;					$DB \"in comment; drag = %d\", drag $DE;
				next
			}
			found_comment_begin = 0;
			# FALL-THROUGH
		}

		/$COMMENT_BEGIN_RE/ {
			in_comment = 1;					$DB \"comment begin\" $DE;
			found_comment_begin = 1;
			sub(/\/\*([^*]|\*+($|[^*\/]))*$/, \"\")		# Remove the head of the comment so that we'll recognize this as an empty line if it is.
			# FALL-THROUGH
		}

	#======================================================================================================
	# Detect and handle header guard.

		/$PRAGMA_ONCE_RE/ {
			++drag;						$DB \"drag = %d\", drag $DE;
			if (header && found_guard == 0 && in_if == 0) {
				found_guard = NR;			$DB \"found_guard = %d\", found_guard $DE;
				if (ptr > 0)
					add(NR, $type_pragmaonce)
				next
			}
			print \"\\n$EP $1:\" NR \": unexpected #pragma once\";
			error = 1;
			exit
		}

		/^#ifndef / {
			if (ptr == 0 && header && found_guard == 0 && in_if == 0) {
				found_guard = NR;			$DB \"found_guard = %d\", found_guard $DE;
				in_if = 1;				$DB \"in_if = %d\", in_if $DE;
				in_if_base = 1;				$DB \"in_if_base = %d\", in_if_base $DE;
				next
			}
			# FALL-THROUGH
		}

	#======================================================================================================
	# Detect and handle __BEGIN_DECLS ... __END_DECLS blocks.

		/^[[:space:]]*__BEGIN_DECLS/ {
			++drag;						$DB \"drag = %d\", drag $DE;
			if (in_decl == 0) {
				in_decl = 1;				$DB \"in_decl = 1\" $DE
				add(NR, $type_decls);
				next
			}
			print \"\\n$EP $1:\" NR \": Nested __BEGIN_DECLS!\";
			error = 1;
			exit
		}

		/^[[:space:]]*__END_DECLS/ {
			++drag;						$DB \"drag = %d\", drag $DE;
			if (in_decl == 1) {
				in_decl = 0;				$DB \"in_decl = 0\" $DE
				if (skipped) {
					drag = 0;
				} else if (ptr == 1) {
					ptr = 0;			$DB \"erase DECLS block\" $DE
					last_none_type = -1;
				}
				next
			}
			print \"\\n$EP $1:\" NR \": __END_DECLS without matching __BEGIN_DECLS!\";
			error = 1;
			exit
		}

	#======================================================================================================
	# Detect and handle #if ... #endif blocks.

		/$IF_RE/ {
			++drag;						$DB \"drag = %d\", drag $DE;
			if (in_if == in_if_base && in_decl == 0) {
				skipped = 0;				$DB \"skipped = 0\" $DE;
				base_if = NR;				$DB \"base_if = %d\", NR $DE;
			}
			++in_if;					$DB \"in_if = %d\", in_if $DE;
			next
		}

		/$ENDIF_RE/ {
			--in_if;					$DB \"in_if = %d\", in_if $DE;
			if (in_if < 0) {
				print \"\\n$EP $1:\" NR \": #endif without matching #if!\";
				error = 1;
				exit
			}
			++drag;
			if (in_if == in_if_base && in_decl == 0) {
				if (skipped) {
					drag = 0;
					add(base_if, $type_ifincludeendif);
				} else if (ptr > 0)
					add(base_if, $type_ifendif);
			}						$DB \"drag = %d\", drag $DE;
			# Left header guard?
			if (in_if < in_if_base) {			$DB \"left header guard:\" $DE;
				# assert(in_if == 0 && in_if_base == 1 && header && found_guard)
				exit
			}
			next
		}

	#======================================================================================================
	# Handle #include lines.

		/$INCLUDE_RE/ {
			if (!/\"(\.\/)?mavlink_msg/) {
				# If we're inside a __BEGIN_DECLS ... __END_DECLS block then only certain headers may be included.
				hname = gensub(/^[[:space:]]*#[[:space:]]*include[[:space:]]*[<\"]([^>\"]*)[>\"].*/, \"\\\1\", \"1\");
				cpp_safe = !(hname ~ /$UNSAFE_HEADERS_RE/);
										$DB \"hname = \\\"\" hname \"\\\"; cpp_safe = \" cpp_safe \"; in_decl = \" in_decl \"; is_cxxsrc = $is_cxxsrc\" $DE
				if (in_decl && cpp_safe) {
					print \"\\n$EP $1:\" NR \": including \" hname \" inside a __BEGIN_DECLS ... __END_DECLS block.\";
					error = 1;
					exit
				} else if (!in_decl && !cpp_safe && $is_cxxsrc) {
					print \"\\n$EP $1:\" NR \": including \" hname \" outside a __BEGIN_DECLS ... __END_DECLS block!\";
					error = 1;
					exit
				}
				if (in_if > in_if_base || in_decl) {
					skipped = 1;				$DB \"skipped = 1\" $DE;
				} else {
					drag = 0;				$DB \"drag = 0\" $DE;
					add(NR, $type_include);			$DB \"first_line = %d\", NR $DE;
				}
				next
			}
		}

	#======================================================================================================
	# Ignore #define's, empty lines and lines with just comments.

		/$DEFINE_RE/ {
			++drag;						$DB \"drag = %d\", drag $DE;
			if (ptr > 0 && in_if == in_if_base && in_decl == 0) {
				add(NR, $type_macro);
			}
			next
		}

		/$EMPTY_LINE_RE/ {
			++drag;						$DB \"drag = %d\", drag $DE;
			if (ptr > 0 && in_if == in_if_base && in_decl == 0) {
				if (found_comment_begin)
					add(NR, $type_comment);
				else if (found_comment_end != NR)
					add(NR, $type_emptyline);
			}
			next
		}

		/$COMMENT_LINE_RE/ {
			++drag;						$DB \"drag = %d\", drag $DE;
			if (ptr > 0 && in_if == in_if_base && in_decl == 0 && type[ptr - 1] != $type_comment) {
				add(NR, $type_comment);
			}
			next
		}

	#======================================================================================================
	# Handle everything else (unrecognized lines).

		{
			++drag;						$DB \"unknown; drag = %d\", drag $DE;
			if (ptr > 0 && in_if <= in_if_base && in_decl == 0) {
				exit
			}
		}

		" "$BASEDIR/$1")

	# Decode the result.
	vars=$(echo "$result" | tail -n 1)
	error_msg=$(echo "$result" | grep "^$EP " | sed -e 's/^....//')
	if [ $debug -ne 0 ]; then
		len=$(echo "$result" | wc --lines)
		echo "$result" | head -n $((len - 1)) | grep -v "^$EP "	# Debug messages
		echo "vars: $vars"
	fi
	# Evaluate the last line printed in END.
	error=1; eval $vars
	test -z "$error_msg" || print_error "$error_msg" || return
	test $error -eq 0 -a $first_line -gt 0 || print_error "FAILED to find an #include in $1?!" || return
	test $last_line -ge $first_line || print_error "FAILED to find a sensible last line in $1?!" || return

	# Calculate the number of lines starting from the current line.
	# Use sed to count lines, because wc --lines doesn't report the last line when that doesn't end on a new-line, contrary to the fact that tail treats such lines as lines.
	total_lines=$(sed -n '$=' "$BASEDIR/$1")
	if [ $debug -ne 0 ]; then echo "total_lines = \"$total_lines\""; fi

	# Edit the first_line...last_line block.
	# Header files are ordered as follows (lowest value first):
	cat_winsock=0;		# Winsock2.h
	cat_posix_sys=1;	# posix_sys.h or one of the px4_ headers that include it.
	cat_px4=2;		# Other px4_*.h
	cat_local=3;		# "*.h"
	cat_cxx=4;		# <std c++ header>, ie <iostream>
	cat_c=5;		# <c std c++ header>, ie <cstdio>
	cat_system=6;		# <*.h>

	head -n $last_line "$BASEDIR/$1" | tail -n $((last_line - first_line + 1))  | awk "

		function sort_by_type_line_header_type_hname(blk2, v2, blk1, v1) {
			# Return true if blk1 comes before blk2.
			# Move type_include before the rest. Keep the same line order for the rest.
			return (type[blk2] != $type_include && (type[blk1] == $type_include || line[blk1] < line[blk2])) ||
			       (type[blk2] == $type_include && type[blk1] == $type_include &&
				   # If both are include's then put include with a lower header_type first; sort alphabetically for the same header type.
				   (header_type[blk1] < header_type[blk2] || (header_type[blk1] == header_type[blk2] && hname[blk1] < hname[blk2])));
		}

		BEGIN {
			first_line = $first_line;
			split(\"$lines\", line);
			split(\"$types\", type);
			i = 0;
			do {
				line[++i] -= first_line - 1;
			} while(type[i] != $type_end)
			for(b = 0; b < i; ++b) header_type[b] = 100;
			blk = 1;
			n = 0;
			is_cxxsrc = $is_cxxsrc;
			# px4_posix.h includes px4_defines.h includes px4_log.h includes posix_sys.h which must be the first header included.
			sys_val[\"px4_posix.h\"] = 1;
			sys_val[\"px4_defines.h\"] = 2;
			sys_val[\"px4_log.h\"] = 3;
			sys_val[\"posix_sys.h\"] = 4;
			saw_sys_val = 5;		# Didn't see any of the above; otherwise the lowest value of the header seen.
			for(b = 0; b < i; ++b) saw_sys[b] = saw_sys_val;
		}

		END {
			l = asorti(txt, k, \"sort_by_type_line_header_type_hname\");
			for (b = 1; b <= l; ++b) {
				if (type[k[b]] == $type_include && header_type[k[b]] == $cat_posix_sys && saw_sys[k[b]] > saw_sys_val) continue;
				len = length(txt[k[b]]);
				for (n = 0; n < len; ++n) print txt[k[b]][n];
				if (b < l && type[k[b]] == $type_include && type[k[b+1]] != $type_emptyline &&
				    (type[k[b+1]] != $type_include || (header_type[k[b]] != header_type[k[b+1]] && header_type[k[b+1]] != $cat_px4))) {
					printf \"\n\";
				}
			}
		}

		{
			if (NR == line[blk + 1]) {
				++blk;
				n = 0;
			}
		}

		/$INCLUDE_RE/ {
			# Don't use double quotes around standard header names.
			\$0 = gensub(/^([[:space:]]*#[[:space:]]*include[[:space:]]*)\\\"$STDC_HEADERS_RE\\.h\\\"/, \"\\\1<\\\2.h>\", \"1\");
			if (is_cxxsrc) {
				\$0 = gensub(/^([[:space:]]*#[[:space:]]*include[[:space:]]*)\\\"$STDCXX_HEADERS_RE\\\"/, \"\\\1<\\\2>\", \"1\");
				# Change deprecated C header names to standard C++ header names in C++ source files.
				\$0 = gensub(/^([[:space:]]*#[[:space:]]*include[[:space:]]*<)$STDC_HEADERS_RE\\.h>/, \"\\\1c\\\2>\", \"1\");
			}
			# Don't include \"./foo.h\", that is implied, so just include \"foo.h\".
			\$0 = gensub(/^([[:space:]]*#[[:space:]]*include[[:space:]]*\\\")\.\//, \"\\\1\", \"1\");
			# Extract the header filename.
			hname[blk] = gensub(/^[[:space:]]*#[[:space:]]*include[[:space:]]*[<\"]([^>\"]*)[>\"].*/, \"\\\1\", \"1\");
			# If the header exists in the directory of the including file, then it is a local header.
			command = sprintf(\"test -e %s/%s\", \"$curdir\", hname[blk]);
			if (system(command) == 0) {
				\$0 = gensub(/^([[:space:]]*#[[:space:]]*include[[:space:]]*)[\"<]([^\">]*)[\">]/, \"\\\1\\\"\\\2\\\"\", \"1\");
			} else {
				# Do we know if this is a local file, or a submodule / system header?
				# The grep reg.exp needs \\ (for backslah) and \1 for back reference, thus: \\\1.
				# However we print the grep command using sprintf, so each backslash needs to be escaped once more: \\\\\\1.
				# Finally, this is a bash string and we need to escape each backslash once more to pass it corrently to awk, hence we need twelve backslahes:
				command = sprintf(\"grep '^%s ' '%s' 2>/dev/null\", gensub(/([.+])/, \"\\\\\\\\\\\\1\", \"g\", hname[blk]), \"$TMPDIR/fix_headers_quotes\");
				ret = command | getline result;
				if (ret != 0) {
					result = substr(result, index(result, \" \") + 1);
					\$0 = gensub(/^([[:space:]]*#[[:space:]]*include[[:space:]]*)[\"<][^\">]*[\">]/, \"\\\1\" result, \"1\");
				}
			}
			# Categorise the header.
			if (hname[blk] == \"Winsock2.h\") {
				if (header_type[blk] > $cat_winsock)
					header_type[blk] = $cat_winsock;
			}
			else if (hname[blk] in sys_val) {
				if (header_type[blk] > $cat_posix_sys)
					header_type[blk] = $cat_posix_sys;
				# posix_sys.h is sometimes included within #ifdef __PX4_POSIX ... #endif. The other headers should not be conditional.
				if ((hname[blk] == \"posix_sys.h\" || type[blk] == $type_include)) {
					type[blk] = $type_include;		# Treat #ifdef __PX4_POSIX #include \"posix_sys.h\" #endif as an include for sorting purposes.
					saw_sys[blk] = sys_val[hname[blk]];	# There will be only one include (header name) for this block.
					if (sys_val[hname[blk]] < saw_sys_val)
						saw_sys_val = sys_val[hname[blk]];
				}
				# Use double quotes for these headers.
				\$0 = gensub(/<([[:alnum:]_\/.]*)>/, \"\\\"\\\1\\\"\", \"1\");
			}
			else if (hname[blk] ~ /^(platforms\/px4_|px4_)/) {
				if (header_type[blk] > $cat_px4)
					header_type[blk] = $cat_px4;
				# Use double quotes for these headers.
				\$0 = gensub(/<([[:alnum:]_\/.]*)>/, \"\\\"\\\1\\\"\", \"1\");
			}
			else if (\$0 ~ /^[[:space:]]*#[[:space:]]*include[[:space:]]*\"/) {
				if (header_type[blk] > $cat_local)
					header_type[blk] = $cat_local;
			}
			else if (hname[blk] ~ /^$STDCXX_HEADERS_RE\$/) {
				if (header_type[blk] > $cat_cxx)
					header_type[blk] = $cat_cxx;
			}
			else if (hname[blk] ~ /^c$STDC_HEADERS_RE\$/) {
				if (header_type[blk] > $cat_c)
					header_type[blk] = $cat_c;
			}
			else if (hname[blk] ~ /^$STDC_HEADERS_RE\.h\$/) {
				if (header_type[blk] > $cat_system)
					header_type[blk] = $cat_system;
			}
		}

		{
			# Remove empty lines before #include's.
			if (type[blk] == $type_include) {
				for (i = 1; blk > i && type[blk - i] == $type_emptyline; ++i)
					delete txt[blk - i]
			}
			txt[blk][n++] = \$0;
		}

		" > $TMPDIR/fix_headers_current_block

	# Construct a new file in TMPDIR.
	head -n $((first_line - 1)) "$BASEDIR/$1" > $TMPDIR/fix_headers_current_file

	# Append the editted block.
	cat $TMPDIR/fix_headers_current_block >> $TMPDIR/fix_headers_current_file

	# Append the rest.
	tail -n $((total_lines - last_line)) "$BASEDIR/$1" >> $TMPDIR/fix_headers_current_file

	# Compare original with result.
	if cmp --quiet "$BASEDIR/$1" $TMPDIR/fix_headers_current_file; then
		echo "No change"
	else
		echo "Fixed lines $first_line-$last_line"
		mv $TMPDIR/fix_headers_current_file "$BASEDIR/$1" || fatal "Failed to move $TMPDIR/fix_headers_current_file to $BASEDIR/$1 !?!"
	fi
}

if [ $non_option_arguments -ne 0 ]; then
	fixup_header $1
	exit
fi

# Run the fixup function for each of the files in $TMPDIR/fix_headers_sources_with_includes.
# Strip BASEDIR because we don't know how long that is and it might too much for bash.
for arg in $(cat "$TMPDIR/fix_headers_sources_with_includes" | cut -c $striplen-); do
		fixup_header $arg
done

# Clean up.
if [ $debug -eq 0 -o $# -eq 0 ]; then
	rm "$TMPDIR/fix_headers_sources" "$TMPDIR/fix_headers_sources_with_includes" "$TMPDIR/fix_headers_SUBMODULE_HEADERS" "$TMPDIR/fix_headers_HEADERS" \
	   "$TMPDIR/fix_headers_include_paths" "$TMPDIR/fix_headers_quotes" "$TMPDIR/fix_headers_current_block"
fi

# Print all error messages again at the end.
if [ -s "$TMPDIR/fix_headers_ERROR.log" ]; then
	echo "$0 finished with errors:"
	cat "$TMPDIR/fix_headers_ERROR.log"
else
	echo "SUCCESS"
	rm "$TMPDIR/fix_headers_ERROR.log"
fi