wmaker: work around compilers that do not support nested functions

There are a few cases in which nested functions are an helpful way to write
code, as this is explained in 'script/nested-func-to-macro.sh'. However,
some compiler do not support them (like clang), so this patch proposes an
elegant solution, where developers can get the benefit of them, but for
users they are automatically converted to C macro if needed.

The advantage of this solution is that we keep the code simple, there is no
hack in the source (like #ifdef and code duplication), yet still having the
full advantages.

The translation is done according to what have been detected by configure
(see the WM_PROG_CC_NESTEDFUNC macro) so that user has nothing to do.

Signed-off-by: Christophe CURIS <christophe.curis@free.fr>

Makefile.am

@@ -36,7 +36,8 @@ EXTRA_DIST = TODO BUGS BUGFORM FAQ FAQ.I18N INSTALL \
 	INSTALL-WMAKER README.definable-cursor \
 	The-perfect-Window-Maker-patch.txt \
 	README COPYING.WTFPL autogen.sh \
-	email-clients.txt checkpatch.pl update-changelog.pl
+	email-clients.txt checkpatch.pl update-changelog.pl \
+	script/nested-func-to-macro.sh
 
 if USE_LCOV
 coverage-reset:

configure.ac

@@ -158,6 +158,12 @@ AS_IF([test "x$debug" = "xyes"],
      AX_CFLAGS_GCC_OPTION([-Wno-deprecated-declarations])
 ])
 
+
+dnl Support for Nested Functions by the compiler
+dnl ============================================
+WM_PROG_CC_NESTEDFUNC
+
+
 dnl Posix thread
 dnl =================
 AX_PTHREAD
@@ -905,6 +911,9 @@ AS_IF([test "x$debug" = "xyes"],
     [AS_ECHO(["Debug enabled: CFLAGS = $CFLAGS"]) ])
 echo
 
+AS_IF([test "x$wm_cv_prog_cc_nestedfunc" != "xyes"],
+    [AC_MSG_WARN([[Your compiler does not support Nested Function, work-around enabled]])])
+
 dnl WM_PRINT_REDCRAP_BUG_STATUS
 
 AS_IF([test "x$enable_jpeg" = xno], [dnl

m4/wm_prog_cc_c11.m4

@@ -46,3 +46,41 @@ AS_CASE([$wm_cv_prog_cc_c11],
     [no|native], [],
     [CFLAGS="$CFLAGS $wm_cv_prog_cc_c11"])
 ])
+
+
+# WM_PROG_CC_NESTEDFUNC
+# ---------------------
+#
+# Check if the compiler support declaring Nested Functions (that means
+# declaring a function inside another function).
+#
+# If the compiler does not support them, then the Automake conditional
+# USE_NESTED_FUNC will be set to false, in which case the Makefile will
+# use the script 'scripts/nested-func-to-macro.sh' to generate a modified
+# source with the nested function transformed into a Preprocessor Macro.
+AC_DEFUN_ONCE([WM_PROG_CC_NESTEDFUNC],
+[AC_CACHE_CHECK([if compiler supports nested functions], [wm_cv_prog_cc_nestedfunc],
+    [AC_COMPILE_IFELSE(
+        [AC_LANG_SOURCE([[
+int main(int narg, char **argv)
+{
+	int local_variable;
+
+	int nested_function(int argument)
+	{
+		/* Checking we have access to upper level's scope, otherwise it is of no use */
+		return local_variable + argument;
+	}
+
+	/* To avoid a warning for unused parameter, that may falsely fail */
+	(void) argv;
+
+	/* Initialise using the parameter to main so the compiler won't be tempted to optimise too much */
+	local_variable = narg + 1;
+
+	return nested_function(2);
+}]]) ],
+        [wm_cv_prog_cc_nestedfunc=yes],
+        [wm_cv_prog_cc_nestedfunc=no]) ])
+AM_CONDITIONAL([USE_NESTED_FUNC], [test "x$wm_cv_prog_cc_nestedfunc" != "xno"])dnl
+])

script/nested-func-to-macro.sh

@@ -0,0 +1,216 @@
+#!/bin/sh
+###########################################################################
+#
+#  Window Maker window manager
+#
+#  Copyright (c) 2014 Christophe CURIS
+#  Copyright (c) 2014 Window Maker Team
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+###########################################################################
+#
+# nested-func-to-macro.sh:
+#   from a C source file specified with "-i", convert the functions
+#   specified with "-f" into preprocessor macros ("#define") and save the
+#   result as the file specified with "-o"
+#
+# The goal is to process nested functions (functions defined inside other
+# functions), because some compilers do not support that, despite the
+# advantages against macros:
+#   - there is no side effect on arguments, like what macros does;
+#   - the compiler can check the type used for arguments;
+#   - the compiler can decide wether it is best to inline them or not;
+#   - they are better handled by text editors, mainly for indentation but
+# also because there is no more '\' at end of lines;
+#   - generaly, error message from the compiler are a lot clearer.
+#
+# As opposed to simple static functions, there is a strong benefit because
+# they can access the local variables of the function in which they are
+# defined without needing extra arguments that may get complicated.
+#
+# These added values are important for developpement because they help keep
+# code simple (and so maintainable and with lower bug risk).
+#
+# Because this script convert them to macros (only if 'configure' detected
+# that the compiler does not support nested functions, see the macro
+# WM_PROG_CC_NESTEDFUNC), there are a few constraints when writing such
+# nested functions in the code:
+#
+#   - you cannot use the function's address (example: callback), but that
+# would be a bad idea anyway (in best case there's a penalty issue, in
+# worst case it can crash the program);
+#
+#   - you should be careful on what you're doing with the arguments of the
+# function, otherwise the macro's side effects will re-appear;
+#
+#   - you may need some extra '{}' when calling the function in an
+# if/for/while/... construct, because of the difference between a function
+# call and the macro that will be replaced (the macro will contain its own
+# pair of '{}' which will be followed by the ';' you use for the function
+# call;
+#
+#   - the prototype of the function must be on a single line, it must not
+# spread across multiple lines or replace will fail;
+#
+#   - you should follow the project's coding style, as hacky stuff may
+# make the script generate crap. And you don't want that to happen.
+#
+###########################################################################
+#
+# Please note that this script is writen in sh+awk on purpose: this script
+# is gonna be run on the machine of the person who is trying to compile
+# WindowMaker, and as such we cannot be sure to find any scripting language
+# in a known version and that works (python/ruby/tcl/perl/php/you-name-it).
+#
+# So for portability, we stick to the same sh+awk constraint as Autotools
+# to limit the problem, see for example:
+#   http://www.gnu.org/savannah-checkouts/gnu/autoconf/manual/autoconf-2.69/html_node/Portable-Shell.html
+#
+###########################################################################
+
+# Report an error on stderr and exit with status 1 to tell make could not work
+arg_error() {
+    echo "$0: $@" >&2
+    exit 1
+}
+
+# print help and exit with success status
+print_help() {
+    echo "$0: convert nested functions into macros in C source"
+    echo "Usage: $0 [options...] input_file"
+    echo "valid options are:"
+    echo "  -f name : add 'name' to the list of function to process"
+    echo "  -o file : set output file"
+    exit 0
+}
+
+# Extract command line arguments
+while [ $# -gt 0 ]; do
+    case $1 in
+	-f)
+	    shift
+	    echo "$1" | grep -q '^[A-Z_a-z][A-Z_a-z0-9]*$' || arg_error "function name \"$1\" is not valid"
+	    function_list="$function_list $1"
+	  ;;
+
+	-h|-help|--help) print_help ;;
+	-o) shift ; output_file="$1" ;;
+	-*) arg_error "unknow option '$1'" ;;
+
+	*)
+	    [ "x$input_file" = "x" ] || arg_error "only 1 input file can be specified, not \"$input_file\" and \"$1\""
+	    input_file="$1"
+	  ;;
+    esac
+    shift
+done
+
+# Check consistency of command-line
+[ "x$input_file" = "x" ] && arg_error "no source file given"
+[ "x$function_list" = "x" ] && arg_error "no function name were given, nothing to do"
+[ "x$output_file" = "x" ] && arg_error "no output file name specified"
+
+[ -r "$input_file" ] || arg_error "source file \"$input_file\" is not readable"
+
+# Declare a function that takes care of converting the function code into a
+# macro definition. All the code is considered part of the C function's body
+# until we have matched the right number of {} pairs
+awk_function_handler='
+function replace_definition(func_name)
+{
+   # Isolate the list of arguments from the rest of the line
+   # This code could be updated to handle arg list over multiple lines, but
+   # it would add unnecessary complexity because a function that big should
+   # probably be global static
+   arg_start = index($0, "(");
+   arg_end   = index($0, ")");
+   argsubstr = substr($0, arg_start + 1, arg_end - arg_start - 1);
+   remain    = substr($0, arg_end);
+
+   $0 = "#define " func_name "("
+
+   # Remove the types from the list of arguments
+   split(argsubstr, arglist, /,/);
+   separator = "";
+   for (i = 1; i <= length(arglist); i++) {
+      argname = substr(arglist[i], match(arglist[i], /[A-Z_a-z][A-Z_a-z0-9]*$/));
+      $0 = $0 separator argname;
+      separator = ", ";
+   }
+   delete arglist;
+   $0 = $0 remain;
+
+   # Count the number of pairs of {} and take next line until we get our matching count
+   is_first_line = 1;
+   nb_pair = 0;
+   while (1) {
+      # Count the opening braces
+      split($0, dummy, /\{/);
+      nb_pair = nb_pair + (length(dummy) - 1);
+      delete dummy;
+
+      # Count the closing braces
+      split($0, dummy, /\}/);
+      nb_pair = nb_pair - (length(dummy) - 1);
+      delete dummy;
+
+      # If we found the end of the function, stop now
+      if (nb_pair <= 0 && !is_first_line) {
+         # Note that we count on awk that is always executing the match-all
+         # pattern to print the current line in the $0 pattern
+         break;
+      }
+
+      # Otherwise, print current line with the macro continuation mark and grab
+      # next line to process it
+      $0 = $0 " \\";
+      print;
+      getline;
+      is_first_line = 0;
+   }
+
+   # We mark the current macro as defined so it can be undefined at the end
+   func_defined[func_name] = 1;
+}'
+
+# Build the list of awk pattern matching for each function:
+# The regular expression matches function definition by the name of the function
+# that must be preceeded by at least one keyword (likely the return type), but
+# nothing like a math operator or other esoteric sign
+for function in $function_list ; do
+    awk_function_handler="$awk_function_handler
+/^[\\t ]*([A-Za-z][A-Za-z_0-9]*[\\t ])+${function}[\\t ]*\\(/ {
+   replace_definition(\"${function}\");
+}"
+done
+
+# Finishing, undefine the macro at the most appropriate place we can easily
+# guess
+awk_function_handler="$awk_function_handler
+/^\\}/ {
+   # If we are at the end of a function definition, undefine all macros that
+   # have been defined so far
+   for (func_name in func_defined) {
+      print \"#undef \" func_name;
+      delete func_defined[func_name];
+   }
+}
+# Print all other lines as-is
+{ print }
+"
+
+# Find the specified functions and transform them into macros
+awk "$awk_function_handler" < "$input_file" > "$output_file"

src/Makefile.am

@@ -49,7 +49,6 @@ wmaker_SOURCES = 	\
 	main.h \
 	menu.c \
 	menu.h \
-	misc.c \
 	misc.h \
 	monitor.c \
 	monitor.h \
@@ -123,6 +122,20 @@ if WM_OSDEP_GENERIC
 wmaker_SOURCES += osdep_stub.c
 endif
 
+if USE_NESTED_FUNC
+wmaker_SOURCES += misc.c
+else
+nodist_wmaker_SOURCES = misc.hack_nf.c
+
+CLEANFILES = $(nodist_wmaker_SOURCES)
+
+misc.hack_nf.c: misc.c $(top_srcdir)/script/nested-func-to-macro.sh
+	$(top_srcdir)/script/nested-func-to-macro.sh \
+		$(srcdir)/misc.c -o $(builddir)/misc.hack_nf.c \
+		-f "append_string" -f "append_modifier"
+endif
+
+
 AM_CFLAGS =
 
 AM_CPPFLAGS = \

src/misc.c

@@ -763,8 +763,10 @@ char *GetShortcutKey(WShortKey key)
 	char buffer[256];
 	char *wr;
 
-	void append_string(const char *string)
+	void append_string(const char *text)
 	{
+		const char *string = text;
+
 		while (*string) {
 			if (wr >= buffer + sizeof(buffer) - 1)
 				break;
@@ -774,11 +776,12 @@ char *GetShortcutKey(WShortKey key)
 
 	void append_modifier(int modifier_index, const char *fallback_name)
 	{
-		if (wPreferences.modifier_labels[modifier_index])
+		if (wPreferences.modifier_labels[modifier_index]) {
 			append_string(wPreferences.modifier_labels[modifier_index]);
-		else
+		} else {
 			append_string(fallback_name);
 		}
+	}
 
 	key_name = XKeysymToString(XkbKeycodeToKeysym(dpy, key.keycode, 0, 0));
 	if (!key_name)