#!/usr/bin/gawk -f

############################################################################
#
# Script that removes preprocessor checks on the kernel version. Somewhat
# related to the v4l-scripts-gentree.pl script.
#
# Copyright (C) 2008-2009 Bart Van Assche <bvanassche@acm.org>
#
# 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, version 2
# of the License.
#
# 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.
#
############################################################################

# Usage:
# * Specify the kernel version code and optionally the RHEL version as follows:
#   -v kernel_version=... -vRHEL_MAJOR=... -vRHEL_MINOR=...
# * Provide the patch to be processed to stdin.
#
# The output of this script will be a patch that is specialized for the
# specified kernel version.


# Convert a kernel version in the x.y.z format into numeric form, just like
# the KERNEL_VERSION() macro.

function version_number(a, b, c) {
  return a * 65536 + b * 256 + (c > 255 ? 255 : c);
}

function version_code(kver, array) {
  if (!match(kver, "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$", array))
    match(kver, "^([0-9]+)\\.([0-9]+)$", array)
  return version_number(array[1], array[2], array[3]);
}


# Evaluate a preprocessor statement via repeated substitutions.
# Mathematicians call this algorithm 'term rewriting'.
# Note: the order in which the substitutions appear below is important --
# it is the same order as the order of operators in C.

function evaluate(stmnt, pattern, arg, op, result) {

  if (debug)
    printf "/* debug specialize-patch: (a) %s */\n", stmnt

  # Remove C-style comments.
  gsub("[[:blank:]]*\\/\\*[^*]*\\*\\/[[:blank:]]*", "", stmnt)

  # Remove the spaces before the #-sign.
  gsub("^+[[:blank:]]*#[[:blank:]]*", "+#", stmnt)

  if (match(stmnt, "^+#ifdef (.*)$", arg))
  {
    stmnt = "+#if defined(" arg[1] ")"
  }

  if (match(stmnt, "^+#ifndef (.*)$", arg))
  {
    stmnt = "+#if !defined(" arg[1] ")"
  }

  # See also commit c9c9762d4d44 ("block: return the correct bvec when checking
  # for gaps"; v5.14-rc1).
  gsub("defined\\(bio_multiple_segments\\)",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(5, 13, 0))", stmnt)

  gsub("defined\\(REGISTER_MAD_AGENT_HAS_FLAGS_ARG\\)",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(3, 17, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 6 * 256 + 9)", stmnt)

  gsub("SOCK_RECVMSG_HAS_FOUR_ARGS",
       "(LINUX_VERSION_CODE < KERNEL_VERSION(4, 7, 0) \\&\\& " \
       "!defined(UEK_KABI_RENAME))", stmnt)

  gsub("defined\\(USE_PRE_440_WR_STRUCTURE\\)",
       "(LINUX_VERSION_CODE < KERNEL_VERSION(4, 4, 0) \\&\\& " \
       "RHEL_RELEASE_CODE -0 < 7 * 256 + 5)", stmnt)

  gsub("defined\\(IB_CREATE_CQ_HAS_INIT_ATTR\\)",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)

  gsub("defined\\(CREATE_SEND_MAD_HAS_AH_ARG\\)",
       "(LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16))", stmnt)

  gsub("defined\\(CREATE_SEND_MAD_HAS_BASE_ARG\\)",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)

  gsub("defined\\(IB_CM_LISTEN_TAKES_FOURTH_ARG\\)",
       "(LINUX_VERSION_CODE < KERNEL_VERSION(4, 3, 0) \\&\\& " \
       "RHEL_RELEASE_CODE -0 < 7 * 256 + 5)", stmnt)

  gsub("defined\\(IB_CM_LISTEN_TAKES_THIRD_ARG\\)",
       "(LINUX_VERSION_CODE < KERNEL_VERSION(6, 1, 0))", stmnt)

  gsub("IB_CLIENT_ADD_ONE_RETURNS_INT",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 8 * 256 + 4)", stmnt)

  gsub("defined\\(IB_CLIENT_REMOVE_TAKES_TWO_ARGS\\)",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 3, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)

  gsub("defined\\(IB_QUERY_GID_HAS_ATTR_ARG\\)",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)

  gsub("RDMA_CREATE_ID_TAKES_NET_ARG",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)

  gsub("defined\\(HAVE_DEV_ATTR_MAX_RECV_SGE\\)",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 7 * 256 + 7)", stmnt)

  gsub("HAVE_DEV_ATTR_MAX_SEND_SGE",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 7 * 256 + 7)", stmnt)

  gsub("HAVE_RDMA_DESTROY_AH_WITH_FLAGS",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 21, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 8 * 256 + 1)", stmnt)

  gsub("HAVE_RDMA_DESTROY_AH",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 12, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)

  gsub("HAVE_RDMA_QUERY_GID",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 8 * 256 + 1)", stmnt)

  gsub("HAVE_SRP_DATA_DESC_IMM",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 21, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 8 * 256 + 1)", stmnt)

  gsub("HAVE_STRUCT_SRP_LOGIN_REQ_RDMA",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 16, 0))", stmnt)

  gsub("defined\\(HAVE_IB_EVENT_GID_CHANGE\\)",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(3, 1, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 6 * 256 + 9)", stmnt)

  gsub("defined\\(HAVE_IB_QUERY_DEVICE\\)",
       "(LINUX_VERSION_CODE < KERNEL_VERSION(4, 5, 0) \\&\\& " \
       "RHEL_RELEASE_CODE -0 < 7 * 256 + 5)", stmnt)

  gsub("defined\\(MAD_HANDLER_TAKES_SEND_BUF\\)",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 5, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)

  gsub("defined\\(HAVE_IB_SET_CPI_RESP_TIME\\)",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 7, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)

  gsub("defined\\(IB_PD_HAS_LOCAL_DMA_LKEY\\)",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 7 * 256 + 5)", stmnt)

  gsub("defined\\(HAVE_IB_DMA_MAP_OPS\\)",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(0, 0, 0))", stmnt)

  gsub("HAVE_IB_SG_DMA_LEN",
       "(LINUX_VERSION_CODE < KERNEL_VERSION(5, 1, 0) \\&\\& " \
       "RHEL_RELEASE_CODE -0 < 8 * 256 + 2)", stmnt)

  gsub("RDMA_REJECT_HAS_FOUR_ARGS",
       "(LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0) || " \
       "RHEL_RELEASE_CODE -0 >= 8 * 256 + 4)", stmnt)

  gsub("defined(ENABLE_NPIV)", 0, stmnt)

  gsub("defined(FC_VPORT_CREATE_DEFINED)", 0, stmnt)

  gsub("LINUX_VERSION_CODE", LINUX_VERSION_CODE, stmnt)

  pattern="KERNEL_VERSION\\([[:blank:]]*([0-9]+)[[:blank:]]*,[[:blank:]]*([0-9]+)[[:blank:]]*,[[:blank:]]*([0-9]+)[[:blank:]]*\\)"
  while (match(stmnt, pattern, op) != 0)
  {
    sub(pattern, version_number(op[1], op[2], op[3]), stmnt)
  }

  gsub("defined\\(INSIDE_KERNEL_TREE\\)", "1", stmnt)

  gsub("defined\\(BACKPORT_LINUX_WORKQUEUE_TO_2_6_19\\)", "0", stmnt)

  gsub("defined\\(CONFIG_SUSE_KERNEL\\)", "0", stmnt)

  gsub("defined\\(CONFIG_SCST_STRICT_SERIALIZING\\)", "0", stmnt)

  if (RHEL_MAJOR == "")
  {
    gsub("defined\\(RHEL_MAJOR\\)", "0", stmnt)
    gsub("RHEL_MAJOR", "", stmnt)
  }
  else
  {
    gsub("defined\\(RHEL_MAJOR\\)", "1", stmnt)
    gsub("RHEL_MAJOR", RHEL_MAJOR, stmnt)
  }

  if (RHEL_MINOR == "")
  {
    gsub("defined\\(RHEL_MINOR\\)", "0", stmnt)
    gsub("RHEL_MINOR", "0", stmnt)
  }
  else
  {
    gsub("defined\\(RHEL_MINOR\\)", "1", stmnt)
    gsub("RHEL_MINOR", RHEL_MINOR, stmnt)
  }

  gsub("defined\\(RHEL_RELEASE_VERSION\\)", "1", stmnt)
  if (RHEL_MAJOR == "" || RHEL_MINOR == "")
  {
    gsub("defined\\(RHEL_RELEASE_CODE\\)", "0", stmnt)
    gsub("RHEL_RELEASE_CODE", "", stmnt)
    gsub("RHEL_RELEASE_VERSION\\([^,)]*,[ 	]*[^,)]*\\)", "0", stmnt)
  }
  else
  {
    gsub("defined\\(RHEL_RELEASE_CODE\\)", "1", stmnt)
    gsub("RHEL_RELEASE_CODE", RHEL_MAJOR * 256 + RHEL_MINOR, stmnt)
    stmnt = gensub("RHEL_RELEASE_VERSION\\(([^,)]*),[ 	]*([^,)]*)\\)",
                   "(\\1) * 256 + (\\2)", "g", stmnt)
  }

  if (MOFED_MAJOR == "") {
    gsub("defined\\(MOFED_MAJOR\\)", "0", stmnt)
    gsub("MOFED_MAJOR", "", stmnt)
  } else {
    gsub("defined\\(MOFED_MAJOR\\)", "1", stmnt)
    gsub("MOFED_MAJOR", MOFED_MAJOR, stmnt)
  }

  if (MOFED_MINOR == "") {
    gsub("defined\\(MOFED_MINOR\\)", "0", stmnt)
    gsub("MOFED_MINOR", "", stmnt)
  } else {
    gsub("defined\\(MOFED_MINOR\\)", "1", stmnt)
    gsub("MOFED_MINOR", MOFED_MINOR, stmnt)
  }

  gsub("defined\\(_COMPAT_LINUX_MM_H\\)", "0", stmnt)
  gsub("defined\\(UEK_KABI_RENAME\\)", UEK_KABI_RENAME ? "1" : "0", stmnt)
  gsub("defined\\(UEK_RELEASE\\)", UEK_RELEASE ? "1" : "0", stmnt)
  gsub("UEK_RELEASE", UEK_RELEASE ? UEK_RELEASE : "0", stmnt)

  if (SCST_IO_CONTEXT != "")
  {
    gsub("defined[[:blank:]]+SCST_IO_CONTEXT", SCST_IO_CONTEXT, stmnt)
    gsub("defined[[:blank:]]*\\([[:blank:]]*SCST_IO_CONTEXT[[:blank:]]*\\)", SCST_IO_CONTEXT, stmnt)
  }

  if (generating_upstream_patch_defined)
  {
    gsub("defined[[:blank:]]+GENERATING_UPSTREAM_PATCH", 1, stmnt)
    gsub("defined[[:blank:]]*\\([[:blank:]]*GENERATING_UPSTREAM_PATCH[[:blank:]]*\\)", 1, stmnt)
  }

  if (config_tcp_zero_copy_transfer_completion_notification_undefined)
  {
    gsub("defined[[:blank:]]+CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION", 0, stmnt)
    gsub("defined[[:blank:]]*\\([[:blank:]]*CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION[[:blank:]]*\\)", 0, stmnt)
  }

  gsub("defined[[:blank:]]+CONFIG_SCST_PROC", !config_scst_proc_undefined, stmnt)
  gsub("defined[[:blank:]]*\\([[:blank:]]*CONFIG_SCST_PROC[[:blank:]]*\\)", !config_scst_proc_undefined,
       stmnt)

  if (debug)
    printf "/* debug specialize-patch: (b) %s */\n", stmnt

  do
  {
    last_stmnt = stmnt

    pattern = "![[:blank:]]*(-*[0-9]+)"
    while (match(stmnt, pattern, op) != 0)
    {
      sub(pattern, op[1] == 0, stmnt)
    }

    pattern = "![[:blank:]]*\\([[:blank:]]*(-*[0-9]+)[[:blank:]]*\\)"
    while (match(stmnt, pattern, op) != 0)
    {
      sub(pattern, op[1] == 0, stmnt)
    }

    pattern = "\\([[:blank:]]*(-*[0-9]+)[[:blank:]]*\\)"
    while (match(stmnt, pattern, op) != 0)
    {
      sub(pattern, op[1], stmnt)
    }

    pattern="(-*[0-9]+)[[:blank:]]*(\\*|/)[[:blank:]]*(-*[0-9]+)"
    while (match(stmnt, pattern, op) != 0)
    {
      result="error"
      if      (op[2] == "*") result = op[1] * op[3]
      else if (op[2] == "/" && op[3] != 0) result = op[1] / op[3]
      sub(pattern, result, stmnt)
    }

    pattern="(-*[0-9]+)[[:blank:]]*(\\+|-)[[:blank:]]*(-*[0-9]+)"
    while (match(stmnt, pattern, op) != 0)
    {
      result="error"
      if      (op[2] == "+") result = op[1] + op[3]
      else if (op[2] == "-") result = op[1] - op[3]
      sub(pattern, result, stmnt)
    }

    pattern="(-*[0-9]+)[[:blank:]]*(<<|>>)[[:blank:]]*(-*[0-9]+)"
    while (match(stmnt, pattern, op) != 0)
    {
      result="error"
      if      (op[2] == "<<") result = int(op[1] * (2**op[3]))
      else if (op[2] == ">>") result = int(op[1] / (2**op[3]))
      sub(pattern, result, stmnt)
    }

    pattern="(-*[0-9]+)[[:blank:]]*(<|<=|>|>=|==|!=)[[:blank:]]*(-*[0-9]+)"
    while (match(stmnt, pattern, op) != 0)
    {
      result="error"
      if      (op[2] == "<" ) result = op[1] <  op[3]
      else if (op[2] == "<=") result = op[1] <= op[3]
      else if (op[2] == ">" ) result = op[1] >  op[3]
      else if (op[2] == ">=") result = op[1] >= op[3]
      else if (op[2] == "==") result = op[1] == op[3]
      else if (op[2] == "!=") result = op[1] != op[3]
      sub(pattern, result, stmnt)
    }

    pattern="(-*[0-9]+)[[:blank:]]*&&[[:blank:]]*\\([[:blank:]]*(-*[0-9]+)[[:blank:]]*\\)"
    while (match(stmnt, pattern, op) != 0)
    {
      sub(pattern, (op[1] != 0) && (op[2] != 0), stmnt)
    }

    pattern="(-*[0-9]+)[[:blank:]]*&&[[:blank:]]*(-*[0-9]+)"
    while (match(stmnt, pattern, op) != 0)
    {
      sub(pattern, (op[1] != 0) && (op[2] != 0), stmnt)
    }

    pattern="0[[:blank:]]*&&[[:blank:]]*defined\\([A-Za-z0-9_]*\\)"
    while (match(stmnt, pattern, op) != 0)
    {
      sub(pattern, 0, stmnt)
    }

    pattern="^+#(if|elif)[[:blank:]]*([01])[[:blank:]]*&&[[:blank:]]*(!*[[:blank:]]*defined[[:blank:]]*\\([[:blank:]]*[A-Za-z0-9_]*[[:blank:]]*\\))$"
    while (match(stmnt, pattern, op) != 0)
    {
      stmnt = "+#" op[1] " " (op[2] != 0 ? op[3] : op[2])
    }

    pattern="^+#(if|elif)[[:blank:]]*(!*[[:blank:]]*defined[[:blank:]]*\\([[:blank:]]*[A-Za-z0-9_]*[[:blank:]]*\\))&&[[:blank:]]*([01])[[:blank:]]*$"
    while (match(stmnt, pattern, op) != 0)
    {
      stmnt = "+#" op[1] " " (op[3] != 0 ? op[2] : op[3])
    }

    pattern="^+#(if|elif)[[:blank:]]*(!*[[:blank:]]*[A-Za-z0-9_]*)[[:blank:]]*&&[[:blank:]]*([01])[[:blank:]]*$"
    while (match(stmnt, pattern, op) != 0)
    {
      stmnt = "+#" op[1] " " (op[3] != 0 ? op[2] : op[3])
    }

    pattern="(-*[0-9]+)[[:blank:]]*\\|\\|[[:blank:]]*(-*[0-9]+)"
    while (match(stmnt, pattern, op) != 0)
    {
      sub(pattern, (op[1] != 0) || (op[2] != 0), stmnt)
    }

    pattern="^+#(if|elif)[[:blank:]]*([01])[[:blank:]]*\\|\\|[[:blank:]]*(!*[[:blank:]]*defined[[:blank:]]*\\([[:blank:]]*[A-Za-z0-9_]*[[:blank:]]*\\))$"
    while (match(stmnt, pattern, op) != 0)
    {
      stmnt = "+#" op[1] " " (op[2] == 0 ? op[3] : op[2])
    }

    pattern="\\(([01])[[:blank:]]*\\|\\|[[:blank:]]*(!*[[:blank:]]*defined[[:blank:]]*\\([[:blank:]]*[A-Za-z0-9_]*[[:blank:]]*\\))\\)"
    while (match(stmnt, pattern, op) != 0)
    {
      sub(pattern, op[1] == 0 ? op[2] : op[1], stmnt)
    }

    pattern="\\([[:blank:]]*(-*[0-9]+)[[:blank:]]*\\)"
    while (match(stmnt, pattern, op) != 0)
    {
      sub(pattern, op[1], stmnt)
    }

    if (debug)
      printf "/* debug specialize-patch: (c) %s -> %s */\n", last_stmnt, stmnt

  } while (stmnt != last_stmnt)

  return stmnt
}


# Evaluate !stmnt
function invert(stmnt) {
  return evaluate(gensub("^+#if (.*)$", "+#if !(\\1)", "g", stmnt))
}


# Handle #if or #elif

function handle_if(evaluated)
{
  # Only act on preprocessor conditional expressions with regard to the Linux
  # kernel version, and do not interpret other expressions.
  if ($0 ~ "LINUX_VERSION_CODE"						\
      || $0 ~ "CONFIG_SCST_PROC"					\
      || $0 ~ "CONFIG_SCST_STRICT_SERIALIZING"				\
      || $0 ~ "CREATE_SEND_MAD_HAS_AH_ARG"				\
      || $0 ~ "CREATE_SEND_MAD_HAS_BASE_ARG"				\
      || $0 ~ "ENABLE_NPIV"						\
      || $0 ~ "FC_VPORT_CREATE_DEFINED"					\
      || $0 ~ "HAVE_DEV_ATTR_MAX_RECV_SGE"				\
      || $0 ~ "HAVE_DEV_ATTR_MAX_SEND_SGE"				\
      || $0 ~ "HAVE_IB_DMA_MAP_OPS"					\
      || $0 ~ "HAVE_IB_QUERY_DEVICE"					\
      || $0 ~ "HAVE_IB_SET_CPI_RESP_TIME"				\
      || $0 ~ "HAVE_IB_SG_DMA_LEN"					\
      || $0 ~ "HAVE_RDMA_DESTROY_AH"					\
      || $0 ~ "HAVE_RDMA_DESTROY_AH_WITH_FLAGS"				\
      || $0 ~ "HAVE_RDMA_QUERY_GID"					\
      || $0 ~ "HAVE_SRP_DATA_DESC_IMM"					\
      || $0 ~ "HAVE_STRUCT_SRP_LOGIN_REQ_RDMA"				\
      || $0 ~ "IB_CLIENT_ADD_ONE_RETURNS_INT"                           \
      || $0 ~ "IB_CLIENT_REMOVE_TAKES_TWO_ARGS"				\
      || $0 ~ "IB_CM_LISTEN_TAKES_FOURTH_ARG"				\
      || $0 ~ "IB_CM_LISTEN_TAKES_THIRD_ARG"				\
      || $0 ~ "IB_CREATE_CQ_HAS_INIT_ATTR"				\
      || $0 ~ "IB_PD_HAS_LOCAL_DMA_LKEY"				\
      || $0 ~ "IB_QUERY_GID_HAS_ATTR_ARG"				\
      || $0 ~ "INSIDE_KERNEL_TREE"					\
      || $0 ~ "MAD_HANDLER_TAKES_SEND_BUF"				\
      || $0 ~ "MOFED_MAJOR"						\
      || $0 ~ "MOFED_MINOR"						\
      || $0 ~ "RDMA_CREATE_ID_TAKES_NET_ARG"				\
      || $0 ~ "RDMA_REJECT_HAS_FOUR_ARGS"                               \
      || $0 ~ "REGISTER_MAD_AGENT_HAS_FLAGS_ARG"			\
      || $0 ~ "RHEL_MAJOR"						\
      || $0 ~ "RHEL_MINOR"						\
      || $0 ~ "RHEL_RELEASE_CODE"					\
      || $0 ~ "SOCK_RECVMSG_HAS_FOUR_ARGS"				\
      || $0 ~ "UEK_KABI_RENAME"						\
      || $0 ~ "UEK_RELEASE"						\
      || $0 ~ "USE_PRE_440_WR_STRUCTURE"				\
      || $0 ~ "_COMPAT_LINUX_MM_H"					\
      || $0 ~ "bio_multiple_segments"                                   \
      || generating_upstream_patch_defined				\
         && $0 ~ "GENERATING_UPSTREAM_PATCH"				\
      || $0 ~ "CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION"	\
      || ($0 ~ "CONFIG_SCST_PROC" && config_scst_proc_undefined)	\
      || ($0 ~ "SCST_IO_CONTEXT" && SCST_IO_CONTEXT != ""))
  {
  }
  else
  {
    evaluated = "+#if undecided"
  }

  if (debug)
    printf "/* debug specialize-patch: (d) %s -> %s */\n", $0, evaluated

  if (evaluated ~ "^+#if")
  {
    if_stmnt[if_nesting_level] = evaluated
    any_section_output[if_nesting_level] = 0
    decision[if_nesting_level] = evaluated
    inv_decision[if_nesting_level] = evaluate(sprintf("+#if !%s", substr(evaluated, 6)))
    if (debug)
      printf "/* debug specialize-patch: (f) %s / %s */\n", \
        decision[if_nesting_level], inv_decision[if_nesting_level]
  }
  else
  {
    sub("^+#elif ",
        sprintf("+#if %s \\&\\& ", substr(inv_decision[if_nesting_level], 6)),
        evaluated)
    if (debug)
      printf "/* debug specialize-patch: (e) %s */\n", evaluated
    evaluated = evaluate(evaluated)
    sub("^+#if", "+#elif", evaluated);
    decision[if_nesting_level] = evaluated
    inv_decision[if_nesting_level] \
      = evaluate(sprintf("+#if %s && !%s", \
                         substr(inv_decision[if_nesting_level], 6), \
                         substr(evaluated, 8)))
    if (debug)
      printf "/* debug specialize-patch: (f) %s / %s */\n", \
        decision[if_nesting_level], inv_decision[if_nesting_level]
  }
  return evaluated
}


# Decide whether or not to print the preprocessor statement $0.

function process_preprocessor_statement(evaluated, condition) {
  evaluated = evaluate($0)
  condition = 1
  ei = evaluated_if_stmnt[if_nesting_level];
  if (evaluated ~ "^+#if")
  {
    if_nesting_level++
    evaluated_if_stmnt[if_nesting_level] = evaluated
    evaluated = handle_if(evaluated)
  }
  else if (evaluated ~ "^+#elif")
  {
    if (if_discarded[if_nesting_level]) {
      sub("^+#elif", "+#if", input_line[0])
      if (debug)
        printf "/* debug specialize-patch: (g0) -> %s */\n", evaluated
    }
    evaluated = handle_if(evaluated)
  }
  else if (evaluated ~ "^+#else")
  {
    decision[if_nesting_level] = inv_decision[if_nesting_level]
  }
  else if (evaluated ~ "^+#endif")
  {
    if_nesting_level--
  }
  else
  {
    condition = 0
  }
  if (condition)
  {
    output = 1
    if (debug)
      printf "/* debug specialize-patch: (g1a) if_nesting_level = %d */\n", \
          if_nesting_level
    for (i = if_nesting_level; i >= 0; i--) {
      if (debug)
        printf "/* debug specialize-patch: (g1b) %s: decision[%d] = %s */\n", \
          evaluated, i, decision[i]
      output = output && decision[i] != "+#if 0" && decision[i] != "+#elif 0"
    }
    if (output)
      any_section_output[if_nesting_level] = 1
    if (debug)
      printf "/* debug specialize-patch: (g2) %s: output = %d */\n", \
        evaluated, output
  }
  if (output && (!condition || \
                 decision[if_nesting_level + (evaluated ~ "^+#endif$")] \
                 !~ "^+#(el|)if [01]"))
  {
    if (evaluated == "+#if undecided"                           \
        || (evaluated !~ "^+#if"                                \
            && evaluated !~ "^+#elif"                           \
            && evaluated !~ "^+#endif"))
    {
      for (i = 0; i < input_line_count; i++)
        line[lines++] = input_line[i]
    } else {
      # If the statement being processed is an #else or #endif that is not a
      # header file include guard and if that statement has a trailing comment,
      # replace that comment by the partially evaluated matching #if expression.
      if (evaluated ~ "^+#else" || evaluated ~ "^+#endif") {
        if ($0 ~ "\\*/") {
          if ($0 ~ "_H_* \\*/$") {
            evaluated = $0
          } else {
            if (ei ~ "^+#if ")
              ei = substr(ei, 6)
            else if (ei ~ "^+#ifdef")
              ei = substr(ei, 9)
            match($0, "([^/ ]*)[[:blank:]]*/\\*[^*]*\\*/[[:blank:]]*", arg)
            evaluated = sprintf("%s /* %s */", arg[1], ei);
            if (match(evaluated, "([^/ ]*) */\\* defined\\(([^()]*)\\) \\*/",
                      arg))
            {
              evaluated = sprintf("%s /* %s */", arg[1], arg[2])
            }
          }
        } else {
          evaluated = $0
        }
        if (debug)
          printf "/* debug specialize-patch: (h) %s */\n", evaluated
      }
      line[lines++] = evaluated
      lines_less_added += input_line_count - 1
    }
  }
  else
  {
    discard = 1
    if (lines >= 1 && line[lines - 1] == "+")
      delete_next_blank_line = 1
  }

  if (evaluated ~ "^+#if")
    if_discarded[if_nesting_level] = discard
}

function reset_hunk_state_variables() {
  lines                  =  0
  lines_less_added       =  0
  lines_less_deleted     =  0
  output                 =  1
  if_nesting_level       = -1
  delete_next_blank_line =  0
  h[0]                   = ""
}

function dump_lines() {
  # Detect empty hunks
  first_modif = -1
  for (i = 0; i < lines; i++)
  {
    if (line[i] ~ "^[+-]")
    {
      first_modif = i
      break
    }
  }

  # Dump line[] as a hunk, but only if the hunk is not empty.
  if (first_modif >= 0)
  {
    if (h[0] != "")
      printf "@@ -%d,%d +%d,%d @@%s\n",h[1],h[2]-lines_less_deleted,h[3],h[4]-lines_less_added,h[5]
    for (i = 0; i < lines; i++) {
      modifier = (LINUX_VERSION_CODE < version_code("4.19.0") &&
                  (RHEL_MAJOR == "" ||
                   RHEL_MAJOR * 256 + RHEL_MINOR < 7 * 256 + 7 ||
                   RHEL_MAJOR * 256 + RHEL_MINOR == 8 * 256 + 0) ?
                  "" : "const");
      gsub("BAD_WR_MODIFIER", modifier, line[i])
      gsub("CM_HANDLER_EVENT_MODIFIER", modifier, line[i])
      print line[i]
    }
  }
}

BEGIN {
  # Verify arguments.
  if (kernel_version == "")
  {
    printf "Error: kernel_version was not specified.\n"
    exit 1
  }
  LINUX_VERSION_CODE = version_code(kernel_version)
  if (LINUX_VERSION_CODE < 2*65536)
  {
    printf "Error: kernel version (%s) is out of range.\n", kernel_version
    exit 1
  }
  if (blank_deleted_code != 0 && blank_deleted_code != 1)
    blank_deleted_code = 0
  if (generating_upstream_patch_defined != 0 && generating_upstream_patch_defined != 1)
    generating_upstream_patch_defined = 0
  if (config_tcp_zero_copy_transfer_completion_notification_undefined != 0 && config_tcp_zero_copy_transfer_completion_notification_undefined != 1)
    config_tcp_zero_copy_transfer_completion_notification_undefined = 0
  if (config_scst_proc_undefined != 0 && config_scst_proc_undefined != 1)
    config_scst_proc_undefined = 0

  # Variable initialization.
  process_file = 0
  reset_hunk_state_variables()
}


{
  if (match($0, "^diff[ \t]+[^ \t]+[ \t]+[^ \t]+[ \t]+([^ \t]+)$", filename) \
      || match($0, "^\\+\\+\\+[ \t]+([^ \t]+)[ \t]+", filename))
  {
    # Start of new file.
    dump_lines()
    reset_hunk_state_variables()
    process_file = match(filename[1], "\\.[ch]$") != 0 &&
      match(filename[1], "drivers/scsi/qla2xxx/") == 0
  }

  if (!process_file)
  {
    sub("^+#ifdef INSIDE_KERNEL_TREE$", "+#if 1")
    print
    next
  }

  if (!config_scst_proc_undefined)
  {
    gsub("^+/\\* #define CONFIG_SCST_PROC \\*/$", "+#define CONFIG_SCST_PROC")
  }
  else
  {
    gsub("^+/\\* #define CONFIG_SCST_PROC \\*/$", "+")
  }
  input_line[0] = $0
  input_line_count = 1
  # Join continued lines before processing these.
  while (match($0, "\\\\$"))
  {
    previous_line = $0
    sub("[ \t]*\\\\$", "", previous_line)
    getline
    input_line[input_line_count++] = $0
    sub("^+[ \t]*", "", $0)
    $0 = previous_line " " $0
  }

  discard = 0
  # If the line currently being processed is a hunk header, print all lines
  # that were stored in the array line[] since the last hunk header was read.
  if (match($0, "^@@ -([0-9]*),([0-9]*) \\+([0-9]*),([0-9]*) @@(.*)$"))
  {
    /* print h[1], h[2], h[3], h[4], h[5] */
    dump_lines()
    reset_hunk_state_variables()
    match($0, "^@@ -([0-9]*),([0-9]*) \\+([0-9]*),([0-9]*) @@(.*)$", h)
  }
  else if (delete_next_blank_line && $0 == "+")
  {
    discard = 1
    delete_next_blank_line = 0
  }
  else if (lines >= 2 && !match(line[lines-2], ":$") &&
           line[lines-1] == "+\x9return;" && $0 == "+}")
  {
    # Delete "return;" statements at the end of a function that are not
    # preceded by a label.
    line[lines-1] = $0
    lines_less_added++
  }
  else
  {
    delete_next_blank_line = 0
    if (match($0, "^+ *#"))
    {
      if (debug)
        printf "/* debug specialize-patch: line %d: %s*/\n", NR, $0
      process_preprocessor_statement()
    }
    else if (output)
    {
      # Store the lines that were just read.
      for (i = 0; i < input_line_count; i++)
        line[lines++] = input_line[i]
      # Convert double blank lines into a single blank line.
      if (line[lines-1] == "+")
        delete_next_blank_line = 1
    }
    else
    {
      discard = 1
      if (lines >= 1 && line[lines-1] == "+")
        delete_next_blank_line = 1
    }
  }
  if (discard)
  {
    for (i = 0; i < input_line_count; i++)
    {
      if (blank_deleted_code)
      {
        if (input_line[i] ~ "^+")
          line[lines++] = "+"
        else
          line[lines++] = input_line[i]
      }
      else
      {
        if (input_line[i] ~ "^+")
          lines_less_added++
        else if (input_line[i] ~ "^-")
          lines_less_deleted++
      }
    }
  }
}

END {
  # Dump processed contents of the last read hunk.
  dump_lines()
}

# Local variables:
# indent-tabs-mode: nil
# c-basic-offset: 2
# End: