mulle-match-to-c

#! /usr/bin/env mulle-bash
# shellcheck shell=bash
#
#   Copyright (c) 2020 Nat! - Mulle kybernetiK
#   All rights reserved.
#
#   Redistribution and use in source and binary forms, with or without
#   modification, are permitted provided that the following conditions are met:
#
#   Redistributions of source code must retain the above copyright notice, this
#   list of conditions and the following disclaimer.
#
#   Redistributions in binary form must reproduce the above copyright notice,
#   this list of conditions and the following disclaimer in the documentation
#   and/or other materials provided with the distribution.
#
#   Neither the name of Mulle kybernetiK nor the names of its contributors
#   may be used to endorse or promote products derived from this software
#   without specific prior written permission.
#
#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
#   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
#   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
#   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
#   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
#   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
#   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
#   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
#   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
#   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
#   POSSIBILITY OF SUCH DAMAGE.
#
# Create fresh HeadersAndSources.cmake from filesystem information
#
[ "${TRACE}" = 'YES' ] && set -x && : "$0" "$@"

MULLE_EXECUTABLE_VERSION=2.1.0


usage()
{
   if [ ! -z "$1" ]
   then
      log_error "$1"
   fi

   cat <<EOF >&2
Usage:
   ${MULLE_USAGE_NAME} [options]

   Generate exportable #import and include statements for public
   project headers.

   The resulting file can be easily included into an envelope header with:

      #import "_${PROJECT_NAME:-\$PROJECT_NAME}-export.h"
      #include "_${PROJECT_NAME:-\$PROJECT_NAME}-provide.h"

   A test run that writes to stdout and does not create files can be
   accomplished with:
      ${MULLE_USAGE_NAME} --stdout

   If the outpuz is not to your liking and tweaking the patternfiles seems
   to tedious, try the environment variable options.

Options:
   --c-headers-file <file>    : c header file to create
   --objc-headers-file <file> : objc headers file to create
   --serial                   : process headers and sources serially
   --stdout                   : output to stdout

Environment:
   MULLE_MATCH_TO_C_C_HEADERS          : C headers
   MULLE_MATCH_TO_C_C_HEADERS_FILE     : C headers file to create
   MULLE_MATCH_TO_C_IGNORE_HEADERS     : headers to ignore
   MULLE_MATCH_TO_C_OBJC_HEADER_REGEX  : pattern to match ObjC headers ([A-Z])
   MULLE_MATCH_TO_C_OBJC_HEADERS       : Objective-C headers
   MULLE_MATCH_TO_C_OBJC_HEADERS_FILE  : ObjC headers file to create
   MULLE_MATCH_TO_C_PATTERNFILETYPE    : header patternfile type (header)
   MULLE_MATCH_TO_C_PROJECT_HEADERS    : project headers list, separated by ':'
   MULLE_MATCH_TO_C_UNDERSCORE_HEADERS : ignore underscore prefixed headers (NO)

EOF
   exit 1
}


#
# filename is the basename
#
r_match_type_for_filename()
{
   log_entry "r_match_type_for_filename" "$@"

   local filename="$1"
   local projectname="$2"

   local assoc

   IFS=":"; shell_disable_glob
   for assoc in ${MULLE_MATCH_TO_C_IGNORE_HEADERS}
   do
      if [ "${assoc}" = "${filename}" ]
      then
         IFS="${DEFAULT_IFS}"; shell_enable_glob
         RVAL="ignore"
         return
      fi
   done

   for assoc in ${MULLE_MATCH_TO_C_PROJECT_HEADERS}
   do
      if [ "${assoc}" = "${filename}" ]
      then
         IFS="${DEFAULT_IFS}"; shell_enable_glob
         RVAL="project"
         return
      fi
   done

   for assoc in ${MULLE_MATCH_TO_C_C_HEADERS}
   do
      if [ "${assoc}" = "${filename}" ]
      then
         IFS="${DEFAULT_IFS}"; shell_enable_glob
         RVAL="c"
         return
      fi
   done

   for assoc in ${MULLE_MATCH_TO_C_OBJC_HEADERS}
   do
      if [ "${assoc}" = "${filename}" ]
      then
         IFS="${DEFAULT_IFS}"; shell_enable_glob
         RVAL="objc"
         return
      fi
   done
   IFS="${DEFAULT_IFS}"; shell_enable_glob

   case "${filename}" in
      #
      # underscore files should be included by other files if they are
      # public and relevant
      # by default we keep them, but you can remove them with
      # MULLE_MATCH_TO_C_UNDERSCORE_HEADERS NO
      #
      _*|*[+-]_*)
         if [ "${MULLE_MATCH_TO_C_UNDERSCORE_HEADERS}" != 'YES' ]
         then
            RVAL="ignore"
            return
         fi
      ;;
   esac

   pattern="${MULLE_MATCH_TO_C_OBJC_HEADER_REGEX:-[A-Z]}"

   case "${filename}" in
      # this is the file including us
      "${projectname}".h)
         RVAL="project"
      ;;

      ${pattern}*|_${pattern}*|__${pattern}*)
         RVAL="${PROJECT_DIALECT}" # objc if set
      ;;

      *)
         RVAL="c"
      ;;
   esac
}


r_statements_for_matching_headers()
{
   log_entry "r_statements_for_matching_headers" "$@"

   local categorized_files="$1"
   local match_category="$2"
   local match_type="$3"
   local projectname="$4"

   local line
   local result
   local category
   local header
   local filename
   local type

   .foreachline line in ${categorized_files}
   .do
      category="${line%%;*}"
      header="${line##*;}"

      log_debug "category: ${category}"
      log_debug "header: ${header}"

      case "${category}" in
         ${match_category})
         ;;

         *)
            .continue
         ;;
      esac

      # ignore reflected headers
      case "${header}" in
         */reflect/*)
            .continue
         ;;
      esac

      r_basename "${header}"
      filename="${RVAL}"

      r_match_type_for_filename "${filename}" "${projectname}"
      case "${RVAL}" in
         'project')
            log_fluff "${filename} ignored as it's the envelope header"
            .continue
         ;;

         'ignore')
            log_fluff "${filename} ignored"
            .continue
         ;;

         'objc')
            if [ "${match_type}" != "objc" ]
            then
               log_fluff "${filename} looks like Objective-C, we are looking for C though"
               .continue
            fi
         ;;

         'c')
            if [ "${match_type}" != "c" ]
            then
               log_fluff "${filename} looks like C, we are looking for Objective-C though"
               .continue
            fi
         ;;
      esac

      if [ "${match_type}" = "c" ]
      then
         log_fluff "Add C #include \"${filename}\""
         r_add_line "${result}" "#include \"${filename}\""
      else
         log_fluff "Add Objective-C #import \"${filename}\""
         r_add_line "${result}" "#import \"${filename}\""
      fi
      result="${RVAL}"
   .done

   RVAL="${result}"
}


r_text_info_on()
{
   log_entry "r_text_info_on" "$@"

   local key="$1"

   RVAL="/*
 *   This file will be regenerated by \`mulle-match-to-c\` via
 *   \`mulle-sde reflect\` and any edits will be lost.
 *   Suppress generation of this file with:
 *
 *      mulle-sde environment set ${key} DISABLE
 *
 *   To not let mulle-match-to-c generate any header files:
 *
 *      mulle-sde environment set MULLE_MATCH_TO_C_RUN DISABLE
 */"
}


write_header_file()
{
   log_entry "write_header_file" "$@"

   local filename="$1"
   local text_hdr="$2"
   local projectname="$3"
   local varname="$4"

   local shield_identifier

   r_basename "${filename}"
   r_smart_file_downcase_identifier "${RVAL}"
   shield_identifier="${RVAL}__"

   r_text_info_on "${varname}"
   r_add_line "${RVAL}" "#ifndef ${shield_identifier}"
   r_add_line "${RVAL}" "#define ${shield_identifier}"
   r_add_line "${RVAL}" $'\n'
   r_add_line "${RVAL}" "${text_hdr}"
   r_add_line "${RVAL}" $'\n'
   r_add_line "${RVAL}" "#endif"
   text_hdr="${RVAL}"

   log_verbose "mulle-match-to-c writes ${C_RESET_BOLD}${filename}"
   r_dirname "${filename}"
   mkdir_if_missing "${RVAL}"
   if [ -f "${filename}" ] 
   then 
      exekutor chmod a+w "${filename}" || _fatal "Can't unprotect \"${filename}\"" 
   fi
   if ! redirect_exekutor "${filename}" printf "%s\n" "${text_hdr}"
   then
      log_error "Failed to write \"${filename}\""
      return 1
   fi
   exekutor chmod a-w "${filename}" || log_warning "Failed to protect \"${filename}\""
}


create_c_headers_file()
{
   log_entry "create_c_headers_file" "$@"

   local categorized_files="$1"
   local projectname="$2"

   local text_hdr

   case "${MULLE_MATCH_TO_C_C_HEADERS_FILE}" in
      DISABLE*)
         log_verbose "C Header generation disabled by MULLE_MATCH_TO_C_C_HEADERS_FILE=DISABLE"
         return
      ;;

      NONE)
         log_verbose "C Header file generation disabled by MULLE_MATCH_TO_C_C_HEADERS_FILE=DISABLE"
         text_hdr="# C Header output disabled by MULLE_MATCH_TO_C_C_HEADERS_FILE=NONE"
         MULLE_MATCH_TO_C_C_HEADERS_FILE=""
      ;;

      *)
         r_statements_for_matching_headers "${categorized_files}" \
                                           "PUBLIC_HEADERS" \
                                           "c" \
                                           "${projectname}"
         text_hdr="${RVAL}"

         if [ -z "${text_hdr}" ]
         then
            text_hdr="// no headers"
         fi
      ;;
   esac

   if [ ! -z "${MULLE_MATCH_TO_C_IGNORE_HEADERS}" ]
   then
      text_hdr="${text_hdr}
//
// MULLE_MATCH_TO_C_IGNORE_HEADERS=${MULLE_MATCH_TO_C_IGNORE_HEADERS}"
   fi
   if [ ! -z "${MULLE_MATCH_TO_C_C_HEADERS}" ]
   then
      text_hdr="${text_hdr}
//
// MULLE_MATCH_TO_C_C_HEADERS=${MULLE_MATCH_TO_C_C_HEADERS}"
   fi

   if [ "${MULLE_MATCH_TO_C_C_HEADERS_FILE}" = '-' ]
   then
   	log_info "C Public Headers"
   	printf "%s\n" "${text_hdr}"
   	return 0
   fi

   MULLE_MATCH_TO_C_C_HEADERS_FILE="${MULLE_MATCH_TO_C_C_HEADERS_FILE:-${PROJECT_SOURCE_DIR:-src}/reflect/_${projectname}-provide.h}"

   log_fluff "Create public C header files (${PWD})"

   write_header_file "${MULLE_MATCH_TO_C_C_HEADERS_FILE}" \
                     "${text_hdr}" \
                     "${projectname}" \
                     'MULLE_MATCH_TO_C_C_HEADERS_FILE'
}


create_objc_headers_file()
{
   log_entry "create_objc_headers_file" "$@"

   local categorized_files="$1"
   local projectname="$2"

   local text_hdr

   case "${MULLE_MATCH_TO_C_OBJC_HEADERS_FILE}" in
      DISABLE*)
         log_verbose "Objective-C Header file generation disabled by MULLE_MATCH_TO_C_OBJC_HEADERS_FILE=DISABLE"
         return
      ;;

      NONE)
         log_verbose "Objective-C Header output disabled by MULLE_MATCH_TO_C_OBJC_HEADERS_FILE=NONE"
         text_hdr="# Objective-C Header output disabled by MULLE_MATCH_TO_C_OBJC_HEADERS_FILE=NONE"
         MULLE_MATCH_TO_C_OBJC_HEADERS_FILE=""
      ;;

      *)
         r_statements_for_matching_headers "${categorized_files}" \
                                           "PUBLIC_HEADERS" \
                                           "objc" \
                                           "${projectname}"
         text_hdr="${RVAL}"

         if [ -z "${text_hdr}" ]
         then
            text_hdr="// no headers"
         fi
      ;;
   esac

   if [ ! -z "${MULLE_MATCH_TO_C_IGNORE_HEADERS}" ]
   then
      text_hdr="${text_hdr}
//
// MULLE_MATCH_TO_C_IGNORE_HEADERS=${MULLE_MATCH_TO_C_IGNORE_HEADERS}"
   fi
   if [ ! -z "${MULLE_MATCH_TO_C_OBJC_HEADERS}" ]
   then
      text_hdr="${text_hdr}
//
// MULLE_MATCH_TO_C_OBJC_HEADERS=${MULLE_MATCH_TO_C_OBJC_HEADERS}"
   fi

   if [ "${MULLE_MATCH_TO_C_OBJC_HEADERS_FILE}" = '-' ]
   then
      log_info "Objective-C Public Headers"
      printf "%s\n" "${text_hdr}"
      return 0
   fi

   MULLE_MATCH_TO_C_OBJC_HEADERS_FILE="${MULLE_MATCH_TO_C_OBJC_HEADERS_FILE:-${PROJECT_SOURCE_DIR:-src}/reflect/_${projectname}-export.h}"

   log_fluff "Create public Objective-C header files (${PWD})"

   write_header_file "${MULLE_MATCH_TO_C_OBJC_HEADERS_FILE}" \
                     "${text_hdr}" \
                     "${projectname}" \
                     'MULLE_MATCH_TO_C_OBJC_HEADERS_FILE'
}


main()
{
   log_entry "main" "$@"

   # technical flags
   local MULLE_TRACE
   local MULLE_FLAG_DONT_DEFER='NO'
   local MULLE_FLAG_EXEKUTOR_DRY_RUN='NO'
   local MULLE_FLAG_FOLLOW_SYMLINKS='YES'
   local MULLE_FLAG_LOG_CACHE='NO'
   local MULLE_FLAG_LOG_DEBUG='NO'
   local MULLE_FLAG_LOG_EXEKUTOR='NO'
   local MULLE_FLAG_LOG_FLUFF='NO'
   local MULLE_FLAG_LOG_MERGE='NO'
   local MULLE_FLAG_LOG_SCRIPTS='NO'
   local MULLE_FLAG_LOG_SETTINGS='NO'
   local MULLE_FLAG_LOG_VERBOSE='NO'
   local MULLE_TRACE_PATHS_FLIP_X='NO'
   local MULLE_TRACE_POSTPONE='NO'
   local MULLE_TRACE_RESOLVER_FLIP_X='NO'
   local MULLE_TRACE_SETTINGS_FLIP_X='NO'

   local OPTION_PARALLEL='YES'
   local OPTION_C_PUBLIC_HEADERS='DEFAULT'
   local OPTION_OBJC_PUBLIC_HEADERS='DEFAULT'

   MULLE_MATCH_TO_C_PATTERNFILETYPE="${MULLE_MATCH_TO_C_PATTERNFILETYPE:-header}"
   MULLE_MATCH_TO_C_UNDERSCORE_HEADERS="${MULLE_MATCH_TO_C_UNDERSCORE_HEADERS:-NO}"

   while [ $# -ne 0 ]
   do
      if options_technical_flags "$1"
      then
         shift
         continue
      fi

      case "$1" in
         -h*|--help|help)
            usage
         ;;

         --parallel|--no-serial)
            OPTION_PARALLEL='YES'
         ;;

         --serial|--no-parallel)
            OPTION_PARALLEL='NO'
         ;;

         --c-headers)
            OPTION_C_PUBLIC_HEADERS='YES'
         ;;

         --no-c-headers)
				OPTION_C_PUBLIC_HEADERS='NO'
			;;

         --objc-headers)
            OPTION_OBJC_PUBLIC_HEADERS='YES'
         ;;

         --no-objc-headers)
            OPTION_OBJC_PUBLIC_HEADERS='NO'
         ;;

         --underscore-headers)
            MULLE_MATCH_TO_C_UNDERSCORE_HEADERS='YES'
         ;;

         --no-underscore-headers)
            MULLE_MATCH_TO_C_UNDERSCORE_HEADERS='NO'
         ;;

         -H|--c-headers-file)
            [ $# -eq 1 ] && usage "missing argument to $1"
            shift

				MULLE_MATCH_TO_C_C_HEADERS_FILE="$1"
			;;

         --objc-headers-file)
            [ $# -eq 1 ] && usage "missing argument to $1"
            shift

            MULLE_MATCH_TO_C_OBJC_HEADERS_FILE="$1"
         ;;

         --header-filter-type)
            [ $# -eq 1 ] && usage "missing argument to $1"
            shift

            MULLE_MATCH_TO_C_PATTERNFILETYPE="$1"
         ;;

         --stdout)
            OPTION_PARALLEL='NO'

            MULLE_MATCH_TO_C_C_HEADERS_FILE="-"
            MULLE_MATCH_TO_C_OBJC_HEADERS_FILE="-"
         ;;

         --version)
            printf "%s\n" "${MULLE_EXECUTABLE_VERSION}"
            return 0
         ;;

         -*)
            usage "Unknown option \"$1\""
         ;;

         *)
            break
         ;;
      esac

      shift
   done

   options_setup_trace "${MULLE_TRACE}" && set -x

   [ $# -ne 0 ] && usage "superflous arguments $*"

   MULLE_MATCH="${MULLE_MATCH:-`command -v mulle-match`}"
   [ -z "${MULLE_MATCH}" ] && fail "mulle-match not in PATH"

   include "case"

   if [ -z "${PROJECT_NAME}" ]
   then
      r_basename "${PWD}"
      PROJECT_NAME="${RVAL}" # could be nicer
   fi

   if [ -z "${PROJECT_IDENTIFIER}" ]
   then
      r_identifier "${PROJECT_NAME}"
      PROJECT_IDENTIFIER="${RVAL}"
   fi

   if [ -z "${PROJECT_DOWNCASE_IDENTIFIER}" ]
   then
      r_tweaked_de_camel_case "${PROJECT_IDENTIFIER}"
      r_lowercase "${RVAL}"
      PROJECT_DOWNCASE_IDENTIFIER="${RVAL}"
   fi

   PROJECT_SOURCE_DIR="${PROJECT_SOURCE_DIR:-.}"
   # default to objc here
   PROJECT_DIALECT="${PROJECT_DIALECT:-objc}"

   if [ "${OPTION_C_PUBLIC_HEADERS}" = 'DEFAULT' ]
   then
      OPTION_C_PUBLIC_HEADERS='YES'
   fi

   # if nothing set use objc as default
   if [ "${OPTION_OBJC_PUBLIC_HEADERS}" = 'DEFAULT' -a "${PROJECT_DIALECT}" = "objc" ]
   then
      OPTION_OBJC_PUBLIC_HEADERS='YES'
   fi

   #
   # With 1000 header and 1000 source files, a full update takes ~7s on
   # my machine. It certainly would be interesting to make this properly
   # incremental.
   #
   local categorized_headers

   if ! categorized_headers="`rexekutor "${MULLE_MATCH}" \
                                          ${MULLE_TECHNICAL_FLAGS} \
                                       find --format "%C;%f\\n" \
                                            --qualifier "TYPE_MATCHES ${MULLE_MATCH_TO_C_PATTERNFILETYPE}"`"
   then
      return 1
   fi

   categorized_headers="`LC_ALL=C rexekutor sort -d -t';' -k 1,2 <<< "${categorized_headers}" `"

   log_setting "categorized_headers=${categorized_headers}"

   if [ "${OPTION_PARALLEL}" = 'YES' ]
   then
   	if [ "${OPTION_C_PUBLIC_HEADERS}" = 'YES' ]
   	then
      	create_c_headers_file "${categorized_headers}" "${PROJECT_NAME}" &
      fi
      if [ "${OPTION_OBJC_PUBLIC_HEADERS}" = 'YES' ]
      then
         create_objc_headers_file "${categorized_headers}" "${PROJECT_NAME}" &
      fi

      log_fluff "waiting..."
      wait
      log_fluff 'done!'
   else
      if [ "${OPTION_C_PUBLIC_HEADERS}" = 'YES' ]
      then
         create_c_headers_file "${categorized_headers}" "${PROJECT_NAME}"
      fi

      if [ "${OPTION_OBJC_PUBLIC_HEADERS}" = 'YES' ]
      then
         create_objc_headers_file "${categorized_headers}" "${PROJECT_NAME}"
      fi
   fi
}


call_with_flags "main" "${MULLE_MATCH_TO_C_FLAGS}" "$@"