
# ------------------------------------------------------------------------------
# Define the QAC strings
# ------------------------------------------------------------------------------
QAC_NAME_AND_VAR    = $(TYP_NAME)
QAC_PLATFORM        = Asr6

# ------------------------------------------------------------------------------
# Define the QAC FlexLM license manager timeout
# ------------------------------------------------------------------------------
QAC_FLEXLM_TIMEOUT  = 2000000000

# ------------------------------------------------------------------------------
# Define the QAC usage of cross module analysis (0 or 1)
# ------------------------------------------------------------------------------
QAC_WITH_CMA        = ^0

# ------------------------------------------------------------------------------
# Define the QAC version and configuration information
# ------------------------------------------------------------------------------
ifeq ($(TYP_CC),ARM_GHS)
QAC_PERS_COMPILER   = Misra2004_CompilerGHS_ARM.p_c
endif
ifeq ($(TYP_CC),ARM_GCC)
QAC_PERS_COMPILER   = Misra2004_CompilerGCC_ARM.p_c
endif
ifeq ($(TYP_CC),WIN_VC)
QAC_PERS_COMPILER   = Misra2004_CompilerWIN_VC.p_c
endif
ifeq ($(TYP_CC),WIN_VC)
QAC_PERS_COMPILER   = Misra2004_CompilerWIN_GCC.p_c
endif

QAC_PERS_MISRA                         = misra_2012_subset_dc.p_s
QAC_PERS_METRICS                       = Misra2004_Metrics.p_s
QAC_PERS_STYLE                         = Misra2004_Style.p_a

FILES_QAC_CFG                          = $(QAC_PERS_STYLE) $(QAC_PERS_COMPILER) $(QAC_PERS_MISRA) $(QAC_PERS_METRICS)

QAC_VERSION_TAG                        = QAC-8.1.2-R
QAR_VERSION_TAG                        = QAR-2.1.1-x64

PATH_TOOLS_QAC_BASE                    = $(PATH_TOOLS_STATIC_ANALYSIS)/QAC
PATH_TOOLS_QAC                         = $(PATH_TOOLS_QAC_BASE)/$(QAC_VERSION_TAG)
PATH_TOOLS_QAC_CFG                     = $(PATH_TOOLS_QAC_BASE)/cfg
PATH_TOOLS_QAR                         = $(PATH_TOOLS_QAC_BASE)/$(QAR_VERSION_TAG)

QAC_INC_NAKED                          = $(C_INCLUDES)                                                  \
                                         $(C_INCLUDES_TOOL_INTERNAL)

# ------------------------------------------------------------------------------
# Note: Add the QAC internal standard ANSI include path for the WIN_VC
# compiler because it can be sometimes difficult for QAC to find VC headers.
# ------------------------------------------------------------------------------
ifeq ($(TYP_CC),WIN_VC)
QAC_INC_NAKED                         := $(QAC_INC_NAKED)                                               \
                                         $(PATH_TOOLS_QAC)/include/ansi
endif

# ------------------------------------------------------------------------------
# Note: Add the QAC internal standard ANSI include path for the WIN_GCC
# compiler because it can be sometimes difficult for QAC to find VC headers.
# ------------------------------------------------------------------------------
ifeq ($(TYP_CC),WIN_GCC)
QAC_INC_NAKED                         := $(PATH_TOOLS_QAC)/include/ansi                                 \
                                         $(QAC_INC_NAKED)
endif

QAC_INCLUDES                           = $(addprefix -i\", $(addsuffix \", $(QAC_INC_NAKED)))

QAC_EXCLUDES                           =
QAC_DEFINES                            = $(subst -d,\n-d ,$(addprefix -d, $(C_DEFINES) $(C_DEFINES_TOOL_INTERNAL)))
QAC_VIA                                = $(addprefix \n-via \"$(PATH_TOOLS_QAC_CFG)/, $(addsuffix \", $(FILES_QAC_CFG)))
QAC_UP                                 = -up \"$(PATH_TOOLS_QAC_CFG)\"

BUILD_CONFIG_FILE                      = $(PATH_BIN_NAME)/BuildConfig.txt
BUILD_TYP_NAME_FILE                    = $(PATH_BIN_NAME)/../BuildTypName.txt

QAC_CFG_FILE                           = $(PATH_TMP_NAME_QAC)/_qac_cfg.txt
QAC_LST_FILE                           = $(PATH_TMP_NAME_QAC)/_qac_list.txt
QAC_PRJ_FILE                           = $(PATH_TMP_NAME_QAC)/_qac_gui.prj

QAC_ARCHIVE_FILE_REPORT                = $(TYP_NAME)_qac_$(QAC_VERSION_TAG)_MISRA_report.zip

QAC_ARCHIVE_FILE_REPORT_PATH_REVIEW    = $(subst /,\\,$(PATH_TMP_NAME_QAC)/review_report)
QAC_ARCHIVE_FILE_REPORT_PATH_COMPLY    = $(subst /,\\,$(PATH_TMP_NAME_QAC)/compliance_report)
QAC_ARCHIVE_FILE_REPORT_PATH_QUALITY   = $(subst /,\\,$(PATH_TMP_NAME_QAC)/quality_report)
QAC_ARCHIVE_FILE_REPORT_PATH_SUPPRESS  = $(subst /,\\,$(PATH_TMP_NAME_QAC)/suppression_report)

QAC_ARCHIVE_FILE_REPORT_PATHS_TO_ZIP   = $(QAC_ARCHIVE_FILE_REPORT_PATH_REVIEW)                              \
                                         $(QAC_ARCHIVE_FILE_REPORT_PATH_COMPLY)                              \
                                         $(QAC_ARCHIVE_FILE_REPORT_PATH_QUALITY)                             \
                                         $(QAC_ARCHIVE_FILE_REPORT_PATH_SUPPRESS)

QAC_BATCH_FILE_README                  = $(PATH_TOOLS_QAC_BASE)/_doc/_qac__readme.pdf
QAC_BATCH_FILE_ANALYSIS                = $(PATH_TMP_NAME_QAC)/_$(QAC_NAME_AND_VAR)_qac_$(QAC_VERSION_TAG)_analyze.bat
QAC_BATCH_FILE_REPORT                  = $(PATH_TMP_NAME_QAC)/_$(QAC_NAME_AND_VAR)_qac_$(QAC_VERSION_TAG)_report.bat
QAC_BATCH_FILE_VIEW                    = $(PATH_TMP_NAME_QAC)/_$(QAC_NAME_AND_VAR)_qac_$(QAC_VERSION_TAG)_view.bat
QAC_BATCH_FILE_ANALYSIS_RESULT_ALL     = $(PATH_BIN_NAME)/$(QAC_NAME_AND_VAR)_qac_$(QAC_VERSION_TAG)_analyze_all.txt
QAC_BATCH_FILE_ANALYSIS_RESULT_OUTPUT  = $(PATH_BIN_NAME)/$(QAC_NAME_AND_VAR)_qac_$(QAC_VERSION_TAG)_analyze_all_report.txt

QAC_BATCH_FILE_BATCH_LIST              =
QAC_BATCH_FILE_BATCH_LIST             := $(wildcard $(PATH_TMP_NAME_OBJ)/*.rule_misra_c.bat)

GIT_COMMIT_HASH_VALUE                  =
GIT_COMMIT_HASH_VALUE                 := $(shell $(GIT) rev-parse HEAD)

TEST_TYP                               = Unit
PARSER_TYP                             = QAC_full_report

AL_QAC_RESULT_PARAMS                   = --input=$(subst /,\\,$(QAC_BATCH_FILE_ANALYSIS_RESULT_ALL))         \
                                         --output=$(subst /,\\,$(QAC_BATCH_FILE_ANALYSIS_RESULT_OUTPUT))     \
                                         --platform=$(QAC_PLATFORM)                                          \
                                         --project_name=$(QAC_NAME_AND_VAR)                                  \
                                         --test_type=$(TEST_TYP)                                             \
                                         --parser_type=$(PARSER_TYP)                                         \
                                         --hash_value=$(GIT_COMMIT_HASH_VALUE)

QAC_REPORT_FLAGS                       = -po qar::report_format=xhtml                                        \
                                         -po qar::user_reports_dir="%%QACREPORTTEMPL%%"                      \
                                         -po qar::viewing_program=none                                       \
                                         -via "%%QACWORKINGPATH%%\_qac_cfg.txt"                              \
                                         -cmaf "%%QACWORKINGPATH%%"                                          \
                                         -list "%%QACWORKINGPATH%%\_qac_list.txt"

QAC_REPORT_FLAGS_COMPLIANCE            = $(QAC_REPORT_FLAGS)                                                 \
                                         -po $(DQUOTE)qar::report_type=Compliance Report$(DQUOTE)            \
                                         -po qar::output_path="%%QACCOMPLIANCEREPORTPATH%%"

QAC_REPORT_FLAGS_SUPPRESSION           = $(QAC_REPORT_FLAGS)                                                 \
                                         -po $(DQUOTE)qar::report_type=Suppression Report$(DQUOTE)           \
                                         -po qar::output_path="%%QACSUPPRESSIONREPORTPATH%%"

QAC_REPORT_FLAGS_QUALITY               = $(QAC_REPORT_FLAGS)                                                 \
                                         -po $(DQUOTE)qar::report_type=Quality Report$(DQUOTE)               \
                                         -po qar::output_path="%%QACQUALITYREPORTPATH%%"

QAC_REPORT_FLAGS_CODE_REVIEW           = $(QAC_REPORT_FLAGS)                                                 \
                                         -po $(DQUOTE)qar::report_type=Code Review Report$(DQUOTE)           \
                                         -po $(DQUOTE)qar::title=Code Review $(QAC_NAME_AND_VAR)$(DQUOTE)    \
                                         -po qar::output_path="%%QACREVIEWREPORTPATH%%"

# ------------------------------------------------------------------------------
# QA-C/MISRA prepare specific rules
# ------------------------------------------------------------------------------
ifeq ($(TYP_SPECIAL_BUILD_OR_REBUILD),TYP_SPECIAL_BUILD_OR_REBUILD_DEVELOPER)
DoMisraPrepareSpecific :
	@$(GNUECHO) +++ QA-C/MISRA finished (do nothing) +++
	@$(GNUECHO)
else
DoMisraPrepareSpecific : MisraQacPrepare MisraQacConfig
	@$(GNUECHO) +++ QA-C/MISRA finished prepare specific rules +++
	@$(GNUECHO)
endif

# ------------------------------------------------------------------------------
# QA-C/MISRA finalize specific rules
# ------------------------------------------------------------------------------
ifeq ($(TYP_SPECIAL_BUILD_OR_REBUILD),TYP_SPECIAL_BUILD_OR_REBUILD_DEVELOPER)
DoMisraFinalizeSpecific :
	@$(GNUECHO) +++ QA-C/MISRA finished finalize (do nothing) +++
	@$(GNUECHO)
else
DoMisraFinalizeSpecific : MisraQacProject
	@$(GNUECHO) +++ QA-C/MISRA finished finalize specific rules +++
	@$(GNUECHO)
ifeq ($(TYP_SPECIAL_BUILD_OR_REBUILD),TYP_SPECIAL_BUILD_OR_REBUILD_DELIVERY)
	@$(GNUECHO) +++ QA-C/MISRA run MISRA batch files for rebuild_delivery
	@$(GNUECHO) +++ QA-C/MISRA run $(QAC_BATCH_FILE_ANALYSIS)
	@$(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO)
	@$(GNUECHO) +++ QA-C/MISRA run $(QAC_BATCH_FILE_REPORT)
	@$(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO)
endif
endif

# ------------------------------------------------------------------------------
# QA-C/MISRA analysis preparation
# ------------------------------------------------------------------------------
MisraQacPrepare:
	@$(GNUECHO)
	@$(GNUECHO) +++ QA-C/MISRA analysis preparation +++
	@$(GNUECHO) +++ QA-C/MISRA generate $(subst \,/,$(BUILD_TYP_NAME_FILE)) +++
	@$(GNUECHO) $(QAC_NAME_AND_VAR)>                                              $(BUILD_TYP_NAME_FILE)
	@$(GNUECHO)
	@$(GNUECHO) +++ QA-C/MISRA generate $(subst \,/,$(BUILD_CONFIG_FILE)) +++
	@$(GNUECHO) "# Al Power Tools Support File">                                  $(BUILD_CONFIG_FILE)
	@$(GNUECHO) "">>                                                              $(BUILD_CONFIG_FILE)
	@$(GNUECHO) "# QAC, Doxygen: relative path to temporary directory">>          $(BUILD_CONFIG_FILE)
	@$(GNUECHO) tmp=$(subst /,\\,$(PATH_TMP_NAME))>>                              $(BUILD_CONFIG_FILE)
	@$(GNUECHO) qac_bin=$(subst /,\\,$(PATH_TOOLS_QAC)/bin)>>                     $(BUILD_CONFIG_FILE)
	@$(GNUECHO) qac_help_messages=$(subst /,\\,$(PATH_TOOLS_QAC)/help/messages)>> $(BUILD_CONFIG_FILE)
	@$(GNUECHO) qac_option_with_cma=$(QAC_WITH_CMA)>>                             $(BUILD_CONFIG_FILE)


# ------------------------------------------------------------------------------
# QA-C/MISRA analysis configuration
# ------------------------------------------------------------------------------
MisraQacConfig:
	@$(GNUECHO) +++ QA-C/MISRA analysis create $(subst \,/,$(QAC_CFG_FILE)) +++
	@$(GNUECHO)>                                                                      $(QAC_CFG_FILE)
	@$(GNUECHO) $(addsuffix \n,$(subst \,/,$(addprefix -i,$(QAC_INC_NAKED))))>>       $(QAC_CFG_FILE)
	@$(GNUECHO) $(QAC_EXCLUDES)>>                                                     $(QAC_CFG_FILE)
	@$(GNUECHO) $(QAC_DEFINES)>>                                                      $(QAC_CFG_FILE)
	@$(GNUECHO) $(QAC_VIA)>>                                                          $(QAC_CFG_FILE)
	@$(GNUECHO) $(QAC_UP)>>                                                           $(QAC_CFG_FILE)
	@$(GNUECHO) -po comply_report::no_viewer>>                                        $(QAC_CFG_FILE)
	@$(GNUECHO) -po quality_report::no_viewer>>                                       $(QAC_CFG_FILE)
	@$(GNUECHO) -po suppress_report::no_viewer>>                                      $(QAC_CFG_FILE)


# ------------------------------------------------------------------------------
# In the following section, we implement a long echo rule
# for creating single file QAC analysis batch files.
# Note: Be sure that no extra spaces are placed at
# the ends of the lines after \n.
# ------------------------------------------------------------------------------
QAC_FLAGS   = -ppmetrics+                                             \
              -pplist+                                                \
              -ppfilename+                                            \
              -via $(DQUOTE)$(QAC_CFG_FILE)$(DQUOTE)$(SPACE)

RULE_CREATE_BATCH_FOR_SINGLE_FILE_MISRA_C_ANALYSIS = \
$(GNUECHO) \
echo off\n\
set FLEXLM_TIMEOUT=$(QAC_FLEXLM_TIMEOUT)\n\
set /a cnt +=1\n\
set QACBIN=$(subst /,\\,$(PATH_TOOLS_QAC)/bin)\n\
set QACPATH=$(subst /,\\,$(PATH_TOOLS_QAC))\n\
if not $(DQUOTE)%%QACINPATH%%$(DQUOTE)==$(DQUOTE)TRUE$(DQUOTE) set PATH=$(DQUOTE)%%QACBIN%%$(DQUOTE);$(DQUOTE)%%PATH%%$(DQUOTE)\n\
set QACINPATH=TRUE\n\
echo Performing QAC analysis\n\
echo analyzing %%cnt%% of %%TOTAL_COUNT%% $(DQUOTE)$(subst /,\\,$<)$(DQUOTE)\n\
$(DQUOTE)$(subst /,\\,$(PATH_TOOLS_QAC)/bin/qac.exe)$(DQUOTE) $(QAC_FLAGS) $(DQUOTE)$<$(DQUOTE)\n\
$(DQUOTE)$(subst /,\\,$(PATH_TOOLS_QAC)/bin/errdsp.exe)$(DQUOTE) QAC -via $(DQUOTE)$(QAC_CFG_FILE)$(DQUOTE) -list $(DQUOTE)$(QAC_LST_FILE)$(DQUOTE) -op $(DQUOTE)$(PATH_TMP_NAME_QAC)$(DQUOTE) -file $(notdir $<).txt $(DQUOTE)$<$(DQUOTE)\n\
echo finished single file\n> $(PATH_TMP_NAME_OBJ)/$(basename $(@F)).rule_misra_c.bat

# ------------------------------------------------------------------------------
# QA-C/MISRA GUI project
# ------------------------------------------------------------------------------
MisraQacProject:
  # QA-C/MISRA create GUI project

	@$(GNUECHO) +++ QA-C/MISRA create GUI project $(subst \,/,$(QAC_PRJ_FILE)) +++
	@$(GNUECHO)  VersionTag45>                                                                                    $(QAC_PRJ_FILE)
	@$(GNUECHO)  StartProjectMarker>>                                                                             $(QAC_PRJ_FILE)
	@$(GNUECHO)  FolderName=$(QAC_NAME_AND_VAR)>>                                                                 $(QAC_PRJ_FILE)
	@$(GNUECHO)  SourcePath=$(CURDIR)>>                                                                           $(QAC_PRJ_FILE)
	@$(GNUECHO)  OutputPath=$(PATH_TMP_NAME_QAC)>>                                                                $(QAC_PRJ_FILE)
	@$(GNUECHO)  SubsPers=$(QAC_CFG_FILE)>>                                                                       $(QAC_PRJ_FILE)
	@$(GNUECHO)  AnalPers=$(QAC_CFG_FILE)>>                                                                       $(QAC_PRJ_FILE)
	@$(GNUECHO)  CompPers=$(PATH_TOOLS_QAC_CFG)/$(QAC_PERS_COMPILER)>>                                            $(QAC_PRJ_FILE)
	@-if exist $(PATH_TMP_NAME_OBJ)/*.fname_c $(CAT) $(PATH_TMP_NAME_OBJ)/*.fname_c>>                             $(QAC_PRJ_FILE)
	@$(GNUECHO)  EndContainedFilesMarker>>                                                                        $(QAC_PRJ_FILE)
	@$(GNUECHO)  EndSubProjectMarker>>                                                                            $(QAC_PRJ_FILE)
	@$(GNUECHO)
	@$(GNUECHO) +++ QA-C/MISRA analysis create $(subst \,/,$(QAC_LST_FILE)) +++
	@$(GNUECHO) -op$(DQUOTE)$(subst /,\\,$(PATH_TMP_NAME_QAC))$(DQUOTE)>                                          $(QAC_LST_FILE)
	@$(GNUECHO) -cmaf $(DQUOTE)$(subst /,\\,$(PATH_TMP_NAME_QAC)/$(QAC_NAME_AND_VAR))$(DQUOTE)>>                  $(QAC_LST_FILE)
	@-if exist $(PATH_TMP_NAME_OBJ)/*.fname_c $(CAT) $(PATH_TMP_NAME_OBJ)/*.fname_c>>                             $(QAC_LST_FILE)

  # QA-C/MISRA copy readme file

	@$(GNUECHO) +++ QA-C/MISRA copy readme file $(subst \,/,$(QAC_BATCH_FILE_README)) +++
	@-copy $(subst /,\,$(QAC_BATCH_FILE_README)) $(subst /,\,$(PATH_TMP_NAME_QAC))

  # QA-C/MISRA create analysis batch file

	@$(GNUECHO)
	@$(GNUECHO) +++ QA-C/MISRA create analysis batch file $(subst \,/,$(QAC_BATCH_FILE_ANALYSIS)) +++
	@$(GNUECHO) echo off>                                                                                         $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) -e "\n">>                                                                                         $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) cd $(PATH_TMP_NAME_QAC)>>                                                                         $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo Deleting previous temporary files>>                                                          $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) if exist *.c.err del /Q *.c.err>>                                                                 $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) if exist *.c.met del /Q *.c.met>>                                                                 $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) if exist *.c.txt del /Q *.c.txt>>                                                                 $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) if exist *.c.i   del /Q *.c.i>>                                                                   $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) -e "\n">>                                                                                         $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) set QACINPATH=FALSE>>                                                                             $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) set cnt=^0>>                                                                                      $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) set TOTAL_COUNT=^$(words $(wildcard $(PATH_TMP_NAME_OBJ)/*.rule_misra_c.bat))>>                   $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo Analyzing %%TOTAL_COUNT%% files...>>                                                         $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) -e "\n">>                                                                                         $(QAC_BATCH_FILE_ANALYSIS)
	@-if exist $(PATH_TMP_NAME_OBJ)/*.rule_misra_c.bat $(CAT) $(PATH_TMP_NAME_OBJ)/*.rule_misra_c.bat>>           $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) -e "\n">>                                                                                         $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo finished all files>>                                                                         $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo concatenate all files to $(QAC_BATCH_FILE_ANALYSIS_RESULT_ALL)>>                             $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) type $(subst /,\\,$(PATH_TMP_NAME_QAC)/*.c.txt)^>$(QAC_BATCH_FILE_ANALYSIS_RESULT_ALL)>>          $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) -e "\n">>                                                                                         $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo Running $(basename $(notdir $(subst \,/,$(AL_TEST_RESULT))))>>                               $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) $(AL_TEST_RESULT) $(AL_QAC_RESULT_PARAMS)>>                                                       $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_ANALYSIS)
	@$(GNUECHO) echo Finished>>                                                                                   $(QAC_BATCH_FILE_ANALYSIS)

  # QA-C/MISRA create report generator batch file

	@$(GNUECHO)
	@$(GNUECHO) +++ QA-C/MISRA create report generator batch file $(subst \,/,$(QAC_BATCH_FILE_REPORT)) +++
	@$(GNUECHO) echo off>                                                                                         $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) echo Creating QAC reports>>                                                                       $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) cd $(PATH_TMP_NAME_QAC)>>                                                                         $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) echo Cleaning any already existing archive ZIP files>>                                            $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) if exist *.zip   del /Q *.zip>>                                                                   $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) if exist *.zip.* del /Q *.zip.*>>                                                                 $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) echo Creating QAC report generator batch>>                                                        $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) set FLEXLM_TIMEOUT=$(QAC_FLEXLM_TIMEOUT)>>                                                        $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) set QACBIN=$(subst /,\\,$(PATH_TOOLS_QAC)/bin)>>                                                  $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) set QACREPORTBIN=$(subst /,\\,$(PATH_TOOLS_QAR)/bin)>>                                            $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) set QACREPORTTEMPL=$(subst /,\\,$(PATH_TOOLS_QAR)/bin/../standard_reports)>>                      $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) set QACWORKINGPATH=$(subst /,\\,$(PATH_TMP_NAME_QAC))>>                                           $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) set QACREVIEWREPORTPATH=$(subst /,\\,$(QAC_ARCHIVE_FILE_REPORT_PATH_REVIEW))>>                    $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) set QACCOMPLIANCEREPORTPATH=$(subst /,\\,$(QAC_ARCHIVE_FILE_REPORT_PATH_COMPLY))>>                $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) set QACQUALITYREPORTPATH=$(subst /,\\,$(QAC_ARCHIVE_FILE_REPORT_PATH_QUALITY))>>                  $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) set QACSUPPRESSIONREPORTPATH=$(subst /,\\,$(QAC_ARCHIVE_FILE_REPORT_PATH_SUPPRESS))>>             $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) if not exist "%%QACREVIEWREPORTPATH%%" $(MKDIR) "%%QACREVIEWREPORTPATH%%">>                       $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) if not exist "%%QACCOMPLIANCEREPORTPATH%%" $(MKDIR) "%%QACCOMPLIANCEREPORTPATH%%">>               $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) if not exist "%%QACQUALITYREPORTPATH%%" $(MKDIR) "%%QACQUALITYREPORTPATH%%">>                     $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) if not exist "%%QACSUPPRESSIONREPORTPATH%%" $(MKDIR) "%%QACSUPPRESSIONREPORTPATH%%">>             $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) "%%QACREPORTBIN%%\qar.exe" QAC $(QAC_REPORT_FLAGS_COMPLIANCE)>>                                   $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) "%%QACREPORTBIN%%\qar.exe" QAC $(QAC_REPORT_FLAGS_SUPPRESSION)>>                                  $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) "%%QACREPORTBIN%%\qar.exe" QAC $(QAC_REPORT_FLAGS_QUALITY)>>                                      $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) "%%QACREPORTBIN%%\qar.exe" QAC $(QAC_REPORT_FLAGS_CODE_REVIEW)>>                                  $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) echo Archive the QAC reports with 7z. Limit volumes to 8MB with flag -v8M>>                       $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) $(ZIP) -v8M a $(subst /,\\,$(QAC_ARCHIVE_FILE_REPORT)) \
      $(subst /,\\,$(QAC_ARCHIVE_FILE_REPORT_PATHS_TO_ZIP)) -y -r ^> NUL  ^2^> NUL>>                              $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) echo Copy the the QAC report archives to bin:>>                                                   $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) if exist *.zip   copy /y *.zip   $(subst /,\\,$(PATH_BIN_NAME))>>                                 $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) if exist *.zip.* copy /y *.zip.* $(subst /,\\,$(PATH_BIN_NAME))>>                                 $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) echo.>>                                                                                           $(QAC_BATCH_FILE_REPORT)
	@$(GNUECHO) echo Finished>>                                                                                   $(QAC_BATCH_FILE_REPORT)

  # QA-C/MISRA create view misra batch file

	@$(GNUECHO)
	@$(GNUECHO) +++ QA-C/MISRA create view misra batch file $(subst \,/,$(QAC_BATCH_FILE_VIEW)) +++
	@$(GNUECHO) echo off>                                                                                         $(QAC_BATCH_FILE_VIEW)
	@$(GNUECHO) echo Calling QAC viewer>>                                                                         $(QAC_BATCH_FILE_VIEW)
	@$(GNUECHO) set FLEXLM_TIMEOUT=$(QAC_FLEXLM_TIMEOUT)>>                                                        $(QAC_BATCH_FILE_VIEW)
	@$(GNUECHO) set QACBIN=$(subst /,\\,$(PATH_TOOLS_QAC)/bin)>>                                                  $(QAC_BATCH_FILE_VIEW)
	@$(GNUECHO) set QACPATH=$(subst /,\\,$(PATH_TOOLS_QAC))>>                                                     $(QAC_BATCH_FILE_VIEW)
	@$(GNUECHO) set QACHELPFILES=$(subst /,\\,$(PATH_TOOLS_QAC)/help)>>                                           $(QAC_BATCH_FILE_VIEW)
	@$(GNUECHO) set PATH=%%QACBIN%%;%%PATH%%>>                                                                    $(QAC_BATCH_FILE_VIEW)
	@$(GNUECHO) echo Calling viewer...>>                                                                          $(QAC_BATCH_FILE_VIEW)
	@$(GNUECHO) $(DQUOTE)$(subst /,\\,$(PATH_TOOLS_QAC)/bin/viewer.exe)$(DQUOTE) \
      QAC -via $(DQUOTE)$(QAC_CFG_FILE)$(DQUOTE) -list $(DQUOTE)$(QAC_LST_FILE)$(DQUOTE)>>                        $(QAC_BATCH_FILE_VIEW)
	@$(GNUECHO) echo Finished>>                                                                                   $(QAC_BATCH_FILE_VIEW)
