px4-firmware/Tools/fix_headers.sh

902 lines
36 KiB
Bash
Executable File
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#! /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