patch, 8 partsCMake build system for git

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> 
> This patch implements the placeholder substitution to generate, say,
> `git-request-pull` from `git-request-pull.sh`.
> 
> The shell/perl/python scripts and template are generated using CMake
> (very similar to what sed does).
> 
> The text translations are only build if `msgfmt` is found in your path.
> 
> NOTE: The scripts and templates are generated during configuration.
> 
> Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> ---
>  CMakeLists.txt | 107 ++++++++++++++++++++++++++++++++++++++++++++++++-
>  1 file changed, 106 insertions(+), 1 deletion(-)
> 
> diff --git a/CMakeLists.txt b/CMakeLists.txt
> index 73703bd321f..788b53be873 100644
> --- a/CMakeLists.txt
> +++ b/CMakeLists.txt
> @@ -51,6 +51,11 @@ endif()
>  
>  find_program(SH_EXE sh)
>  
> +find_program(MSGFMT_EXE msgfmt)

> +if(NOT MSGFMT_EXE)
> +	message(WARNING "Text Translations won't be build")
> +endif()
> +
>  #default behaviour
>  include_directories(${CMAKE_SOURCE_DIR})
>  add_compile_definitions(GIT_HOST_CPU="${CMAKE_SYSTEM_PROCESSOR}")
> @@ -525,4 +530,104 @@ endif()
>  add_custom_command(OUTPUT ${git_links} ${git_http_links}
>  		COMMAND ${CMAKE_COMMAND} -P ${CMAKE_BINARY_DIR}/CreateLinks.cmake
>  		DEPENDS git git-remote-http)
> -add_custom_target(git-links ALL DEPENDS ${git_links} ${git_http_links})
> \ No newline at end of file

> +add_custom_target(git-links ALL DEPENDS ${git_links} ${git_http_links})
> +
> +
> +#creating required scripts
> +set(SHELL_PATH /bin/sh)
> +set(PERL_PATH /usr/bin/perl)

> +set(LOCALEDIR ${FALLBACK_RUNTIME_PREFIX}/share/locale)
> +set(GITWEBDIR ${FALLBACK_RUNTIME_PREFIX}/share/locale)
> +set(INSTLIBDIR ${FALLBACK_RUNTIME_PREFIX}/share/perl5)
> +
> +#shell scripts
> +set(git_shell_scripts
> +	git-bisect git-difftool--helper git-filter-branch
> +	git-merge-octopus git-merge-one-file git-merge-resolve
> +	git-mergetool git-quiltimport
> +	git-request-pull git-submodule git-web--browse
> +	git-mergetool--lib git-parse-remote git-rebase--preserve-merges
> +	git-sh-setup git-sh-i18n git-instaweb)
> +
> +foreach(script ${git_shell_scripts})
> +	file(STRINGS ${CMAKE_SOURCE_DIR}/${script}.sh content NEWLINE_CONSUME)
> +	string(REPLACE "@SHELL_PATH@" "${SHELL_PATH}" content "${content}")
> +	string(REPLACE "@@DIFF@@" "diff" content "${content}")
> +	string(REPLACE "@LOCALEDIR@" "${LOCALEDIR}" content "${content}")
> +	string(REPLACE "@GITWEBDIR@" "${GITWEBDIR}" content "${content}")
> +	string(REPLACE "@@NO_CURL@@" "" content "${content}")
> +	string(REPLACE "@@USE_GETTEXT_SCHEME@@" "" content "${content}")
> +	string(REPLACE "# @@BROKEN_PATH_FIX@@" "" content "${content}")
> +	string(REPLACE "@@PERL@@" "${PERL_PATH}" content "${content}")
> +	string(REPLACE "@@SANE_TEXT_GREP@@" "-a" content "${content}")
> +	string(REPLACE "@@PAGER_ENV@@" "LESS=FRX LV=-c" content "${content}")
> +	file(WRITE ${CMAKE_BINARY_DIR}/${script} ${content})
> +endforeach()

> +
> +#perl scripts
> +set(git_perl_scripts
> +	git-add--interactive git-archimport git-cvsexportcommit
> +	git-cvsimport git-cvsserver git-send-email git-svn)
> +
> +#create perl header
> +file(STRINGS ${CMAKE_SOURCE_DIR}/perl/header_templates/fixed_prefix.template.pl perl_header )
> +string(REPLACE "@@PATHSEP@@" ":" perl_header "${perl_header}")
> +string(REPLACE "@@INSTLIBDIR@@" "${INSTLIBDIR}" perl_header "${perl_header}")
> +
> +foreach(script ${git_perl_scripts})
> +	file(STRINGS ${CMAKE_SOURCE_DIR}/${script}.perl content NEWLINE_CONSUME)
> +	string(REPLACE "#!/usr/bin/perl" "#!/usr/bin/perl\n${perl_header}\n" content "${content}")

> +	string(REPLACE "@@GIT_VERSION@@" "${PROJECT_VERSION}" content "${content}")
> +	file(WRITE ${CMAKE_BINARY_DIR}/${script} ${content})
> +endforeach()
> +
> +#python script
> +file(STRINGS ${CMAKE_SOURCE_DIR}/git-p4.py content NEWLINE_CONSUME)
> +string(REPLACE "#!/usr/bin/env python" "#!/usr/bin/python" content "${content}")
> +file(WRITE ${CMAKE_BINARY_DIR}/git-p4 ${content})
> +
> +#perl modules
> +file(GLOB_RECURSE perl_modules "${CMAKE_SOURCE_DIR}/perl/*.pm")
> +
> +foreach(pm ${perl_modules})
> +	string(REPLACE "${CMAKE_SOURCE_DIR}/perl/" "" file_path ${pm})

> +	file(STRINGS ${pm} content NEWLINE_CONSUME)
> +	string(REPLACE "@@LOCALEDIR@@" "${LOCALEDIR}" content "${content}")
> +	string(REPLACE "@@NO_PERL_CPAN_FALLBACKS@@" "" content "${content}")
> +	file(WRITE ${CMAKE_BINARY_DIR}/perl/build/lib/${file_path} ${content})
> +#test-lib.sh requires perl/build/lib to be the build directory of perl modules
> +endforeach()
> +
> +
> +#templates
> +file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/templates/blt/branches) #create branches
> +set(hooks_templates
> +	applypatch-msg.sample pre-applypatch.sample pre-push.sample
> +	commit-msg.sample pre-commit.sample pre-rebase.sample
> +	fsmonitor-watchman.sample pre-merge-commit.sample pre-receive.sample
> +	post-update.sample prepare-commit-msg.sample update.sample)

> +
> +#templates have @.*@ replacement so use configure_file instead
> +#hooks
> +foreach(tm ${hooks_templates})
> +	configure_file(${CMAKE_SOURCE_DIR}/templates/hooks--${tm} ${CMAKE_BINARY_DIR}/templates/blt/hooks/${tm} @ONLY)
> +endforeach()

> +
> +#info
> +configure_file(${CMAKE_SOURCE_DIR}/templates/info--exclude ${CMAKE_BINARY_DIR}/templates/blt/info/exclude @ONLY)
> +
> +#this
> +configure_file(${CMAKE_SOURCE_DIR}/templates/this--description ${CMAKE_BINARY_DIR}/templates/blt/description @ONLY)
> +
> +
> +#translations
> +if(MSGFMT_EXE)
> +	set(po_files bg  ca  de  el  es  fr  is  it  ko  pt_PT  ru  sv  tr  vi  zh_CN  zh_TW)

> +		list(APPEND po_gen ${CMAKE_BINARY_DIR}/po/build/locale/${po}/LC_MESSAGES/git.mo)
> +	endforeach()
> +	add_custom_target(po-gen ALL DEPENDS ${po_gen})
> +endif()
> -- 
> gitgitgadget
> 

>
> On 2020-04-24 04:01:31+0000, Sibi Siddharthan via GitGitGadget <gitgitgadget@gmail.com> wrote:
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >
> > This patch implements the placeholder substitution to generate, say,
> > `git-request-pull` from `git-request-pull.sh`.
> >
> > The shell/perl/python scripts and template are generated using CMake
> > (very similar to what sed does).
> >
> > The text translations are only build if `msgfmt` is found in your path.
> >
> > NOTE: The scripts and templates are generated during configuration.
> >
> > Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > ---
> >  CMakeLists.txt | 107 ++++++++++++++++++++++++++++++++++++++++++++++++-
> >  1 file changed, 106 insertions(+), 1 deletion(-)
> >
> > diff --git a/CMakeLists.txt b/CMakeLists.txt
> > index 73703bd321f..788b53be873 100644
> > --- a/CMakeLists.txt
> > +++ b/CMakeLists.txt
> > @@ -51,6 +51,11 @@ endif()
> >
> >  find_program(SH_EXE sh)
> >
> > +find_program(MSGFMT_EXE msgfmt)
>
> I suppose find_package(Gettext) can do most of this work?
>

> > +if(NOT MSGFMT_EXE)
> > +     message(WARNING "Text Translations won't be build")
> > +endif()
> > +
> >  #default behaviour
> >  include_directories(${CMAKE_SOURCE_DIR})
> >  add_compile_definitions(GIT_HOST_CPU="${CMAKE_SYSTEM_PROCESSOR}")
> > @@ -525,4 +530,104 @@ endif()
> >  add_custom_command(OUTPUT ${git_links} ${git_http_links}
> >               COMMAND ${CMAKE_COMMAND} -P ${CMAKE_BINARY_DIR}/CreateLinks.cmake
> >               DEPENDS git git-remote-http)
> > -add_custom_target(git-links ALL DEPENDS ${git_links} ${git_http_links})
> > \ No newline at end of file
>
> No newline at end of file?
>
> > +add_custom_target(git-links ALL DEPENDS ${git_links} ${git_http_links})
> > +
> > +
> > +#creating required scripts
> > +set(SHELL_PATH /bin/sh)
> > +set(PERL_PATH /usr/bin/perl)
>
> Really?
> Have you tried on, let's say FreeBSD?
>
> > +set(LOCALEDIR ${FALLBACK_RUNTIME_PREFIX}/share/locale)
> > +set(GITWEBDIR ${FALLBACK_RUNTIME_PREFIX}/share/locale)
> > +set(INSTLIBDIR ${FALLBACK_RUNTIME_PREFIX}/share/perl5)
> > +
> > +#shell scripts
> > +set(git_shell_scripts
> > +     git-bisect git-difftool--helper git-filter-branch
> > +     git-merge-octopus git-merge-one-file git-merge-resolve
> > +     git-mergetool git-quiltimport
> > +     git-request-pull git-submodule git-web--browse
> > +     git-mergetool--lib git-parse-remote git-rebase--preserve-merges
> > +     git-sh-setup git-sh-i18n git-instaweb)
> > +
> > +foreach(script ${git_shell_scripts})
> > +     file(STRINGS ${CMAKE_SOURCE_DIR}/${script}.sh content NEWLINE_CONSUME)
> > +     string(REPLACE "@SHELL_PATH@" "${SHELL_PATH}" content "${content}")
> > +     string(REPLACE "@@DIFF@@" "diff" content "${content}")
> > +     string(REPLACE "@LOCALEDIR@" "${LOCALEDIR}" content "${content}")
> > +     string(REPLACE "@GITWEBDIR@" "${GITWEBDIR}" content "${content}")
> > +     string(REPLACE "@@NO_CURL@@" "" content "${content}")
> > +     string(REPLACE "@@USE_GETTEXT_SCHEME@@" "" content "${content}")
> > +     string(REPLACE "# @@BROKEN_PATH_FIX@@" "" content "${content}")
> > +     string(REPLACE "@@PERL@@" "${PERL_PATH}" content "${content}")
> > +     string(REPLACE "@@SANE_TEXT_GREP@@" "-a" content "${content}")
> > +     string(REPLACE "@@PAGER_ENV@@" "LESS=FRX LV=-c" content "${content}")
> > +     file(WRITE ${CMAKE_BINARY_DIR}/${script} ${content})
> > +endforeach()
>
> I assume this do most of sed magic?
>

> > +
> > +#perl scripts
> > +set(git_perl_scripts
> > +     git-add--interactive git-archimport git-cvsexportcommit
> > +     git-cvsimport git-cvsserver git-send-email git-svn)
> > +
> > +#create perl header
> > +file(STRINGS ${CMAKE_SOURCE_DIR}/perl/header_templates/fixed_prefix.template.pl perl_header )
> > +string(REPLACE "@@PATHSEP@@" ":" perl_header "${perl_header}")
> > +string(REPLACE "@@INSTLIBDIR@@" "${INSTLIBDIR}" perl_header "${perl_header}")
> > +
> > +foreach(script ${git_perl_scripts})
> > +     file(STRINGS ${CMAKE_SOURCE_DIR}/${script}.perl content NEWLINE_CONSUME)
> > +     string(REPLACE "#!/usr/bin/perl" "#!/usr/bin/perl\n${perl_header}\n" content "${content}")
>
> Hoped that this is tried on BSD?
>
> > +     string(REPLACE "@@GIT_VERSION@@" "${PROJECT_VERSION}" content "${content}")
> > +     file(WRITE ${CMAKE_BINARY_DIR}/${script} ${content})
> > +endforeach()
> > +
> > +#python script
> > +file(STRINGS ${CMAKE_SOURCE_DIR}/git-p4.py content NEWLINE_CONSUME)
> > +string(REPLACE "#!/usr/bin/env python" "#!/usr/bin/python" content "${content}")
> > +file(WRITE ${CMAKE_BINARY_DIR}/git-p4 ${content})
> > +
> > +#perl modules
> > +file(GLOB_RECURSE perl_modules "${CMAKE_SOURCE_DIR}/perl/*.pm")
> > +
> > +foreach(pm ${perl_modules})
> > +     string(REPLACE "${CMAKE_SOURCE_DIR}/perl/" "" file_path ${pm})
>
> So, the real source code have reference to CMAKE_SOURCE_DIR?
> I don't think so? It's purely my guess from previous patch, this
> function will do
> string(REPLACE from to file something_I_have_not_checked)
>

> > +     file(STRINGS ${pm} content NEWLINE_CONSUME)
> > +     string(REPLACE "@@LOCALEDIR@@" "${LOCALEDIR}" content "${content}")
> > +     string(REPLACE "@@NO_PERL_CPAN_FALLBACKS@@" "" content "${content}")
> > +     file(WRITE ${CMAKE_BINARY_DIR}/perl/build/lib/${file_path} ${content})
> > +#test-lib.sh requires perl/build/lib to be the build directory of perl modules
> > +endforeach()
> > +
> > +
> > +#templates
> > +file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/templates/blt/branches) #create branches
> > +set(hooks_templates
> > +     applypatch-msg.sample pre-applypatch.sample pre-push.sample
> > +     commit-msg.sample pre-commit.sample pre-rebase.sample
> > +     fsmonitor-watchman.sample pre-merge-commit.sample pre-receive.sample
> > +     post-update.sample prepare-commit-msg.sample update.sample)
>
> Too much things merged into one line, I hate it.
>

> > +
> > +#templates have @.*@ replacement so use configure_file instead
> > +#hooks
> > +foreach(tm ${hooks_templates})
> > +     configure_file(${CMAKE_SOURCE_DIR}/templates/hooks--${tm} ${CMAKE_BINARY_DIR}/templates/blt/hooks/${tm} @ONLY)
> > +endforeach()
>
> What does this really means?
>

> > +
> > +#info
> > +configure_file(${CMAKE_SOURCE_DIR}/templates/info--exclude ${CMAKE_BINARY_DIR}/templates/blt/info/exclude @ONLY)
> > +
> > +#this
> > +configure_file(${CMAKE_SOURCE_DIR}/templates/this--description ${CMAKE_BINARY_DIR}/templates/blt/description @ONLY)
> > +
> > +
> > +#translations
> > +if(MSGFMT_EXE)
> > +     set(po_files bg  ca  de  el  es  fr  is  it  ko  pt_PT  ru  sv  tr  vi  zh_CN  zh_TW)
>
> hard coded, so this is a regression, compared to old Makefile?
>
> > +     foreach(po ${po_files})
> > +             file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/po/build/locale/${po}/LC_MESSAGES)
> > +             add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/po/build/locale/${po}/LC_MESSAGES/git.mo
> > +                             COMMAND ${MSGFMT_EXE} --check --statistics -o ${CMAKE_BINARY_DIR}/po/build/locale/${po}/LC_MESSAGES/git.mo ${CMAKE_SOURCE_DIR}/po/${po}.po)
>
> find_package(Gettext) defines MSGFMT_EXECUTABLE, I think.
> Have you check Solaris option?
> Or is this tranlated from current Makefile?
> I haven't checked current source code!
>
> > +             list(APPEND po_gen ${CMAKE_BINARY_DIR}/po/build/locale/${po}/LC_MESSAGES/git.mo)
> > +     endforeach()
> > +     add_custom_target(po-gen ALL DEPENDS ${po_gen})
> > +endif()
> > --
> > gitgitgadget
> >
>
> --
> Danh

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> 
> This patch provides the facility to install the built binaries and
> scripts.
> 
> This is very similar to `make install`.
> By default the destination directory(DESTDIR) is /usr/local/ on Linux
> To set a custom installation path do this:
> cmake `relative-path-to-srcdir`
> 	-DCMAKE_INSTALL_PREFIX=`preferred-install-path`
> 
> Then run `make install`
> 
> Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> ---
>  CMakeLists.txt | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 49 insertions(+)
> 
> diff --git a/CMakeLists.txt b/CMakeLists.txt
> index 788b53be873..25de5b5bc35 100644
> --- a/CMakeLists.txt
> +++ b/CMakeLists.txt
> @@ -13,6 +13,8 @@ project(git
>  	VERSION ${git_version}
>  	LANGUAGES C)
>  
> +#TODO gitk git-gui gitweb
> +#TODO Add pcre support
>  
>  include(CheckTypeSize)
>  include(CheckCSourceRuns)
> @@ -631,3 +633,50 @@ if(MSGFMT_EXE)
>  	endforeach()
>  	add_custom_target(po-gen ALL DEPENDS ${po_gen})
>  endif()
> +
> +
> +#to help with the install
> +list(TRANSFORM git_shell_scripts PREPEND "${CMAKE_BINARY_DIR}/")
> +list(TRANSFORM git_perl_scripts PREPEND "${CMAKE_BINARY_DIR}/")
> +
> +#install
> +install(TARGETS git git-shell
> +	RUNTIME DESTINATION bin)
> +install(PROGRAMS ${CMAKE_BINARY_DIR}/git-cvsserver  #${CMAKE_SOURCE_DIR}/gitk-git/gitk check

> +	DESTINATION bin)
> +
> +list(REMOVE_ITEM PROGRAMS_BUILT git git-shell)
> +install(TARGETS ${PROGRAMS_BUILT}
> +	RUNTIME DESTINATION libexec/git-core)

> +
> +set(bin_links
> +	git-receive-pack git-upload-archive git-upload-pack)
> +
> +foreach(b ${bin_links})
> +install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git ${CMAKE_INSTALL_PREFIX}/bin/${b})")
> +endforeach()
> +
> +install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git)")
> +install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git-shell ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git-shell)")
> +
> +foreach(b ${git_links})
> +	string(REPLACE "${CMAKE_BINARY_DIR}" "" b ${b})
> +	install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git ${CMAKE_INSTALL_PREFIX}/libexec/git-core/${b})")
> +endforeach()
> +
> +foreach(b ${git_http_links})
> +	string(REPLACE "${CMAKE_BINARY_DIR}" "" b ${b})
> +	install(CODE "file(CREATE_LINK  ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git-remote-http ${CMAKE_INSTALL_PREFIX}/libexec/git-core/${b})")
> +endforeach()
> +
> +install(PROGRAMS ${git_shell_scripts} ${git_perl_scripts} ${CMAKE_BINARY_DIR}/git-p4
> +	DESTINATION libexec/git-core)
> +
> +install(DIRECTORY mergetools DESTINATION libexec/git-core)
> +install(DIRECTORY ${CMAKE_BINARY_DIR}/perl/build/lib/ DESTINATION share/perl5
> +	FILES_MATCHING PATTERN "*.pm")

> +install(DIRECTORY ${CMAKE_BINARY_DIR}/templates/blt/ DESTINATION share/git-core/templates)
> +
> +if(MSGFMT_EXE)
> +	install(DIRECTORY ${CMAKE_BINARY_DIR}/po/build/locale DESTINATION share)
> +endif()

>
> On 2020-04-24 04:01:32+0000, Sibi Siddharthan via GitGitGadget <gitgitgadget@gmail.com> wrote:
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >
> > This patch provides the facility to install the built binaries and
> > scripts.
> >
> > This is very similar to `make install`.
> > By default the destination directory(DESTDIR) is /usr/local/ on Linux
> > To set a custom installation path do this:
> > cmake `relative-path-to-srcdir`
> >       -DCMAKE_INSTALL_PREFIX=`preferred-install-path`
> >
> > Then run `make install`
> >
> > Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > ---
> >  CMakeLists.txt | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
> >  1 file changed, 49 insertions(+)
> >
> > diff --git a/CMakeLists.txt b/CMakeLists.txt
> > index 788b53be873..25de5b5bc35 100644
> > --- a/CMakeLists.txt
> > +++ b/CMakeLists.txt
> > @@ -13,6 +13,8 @@ project(git
> >       VERSION ${git_version}
> >       LANGUAGES C)
> >
> > +#TODO gitk git-gui gitweb
> > +#TODO Add pcre support
> >
> >  include(CheckTypeSize)
> >  include(CheckCSourceRuns)
> > @@ -631,3 +633,50 @@ if(MSGFMT_EXE)
> >       endforeach()
> >       add_custom_target(po-gen ALL DEPENDS ${po_gen})
> >  endif()
> > +
> > +
> > +#to help with the install
> > +list(TRANSFORM git_shell_scripts PREPEND "${CMAKE_BINARY_DIR}/")
> > +list(TRANSFORM git_perl_scripts PREPEND "${CMAKE_BINARY_DIR}/")
> > +
> > +#install
> > +install(TARGETS git git-shell
> > +     RUNTIME DESTINATION bin)
> > +install(PROGRAMS ${CMAKE_BINARY_DIR}/git-cvsserver  #${CMAKE_SOURCE_DIR}/gitk-git/gitk check
>
> check? What does it mean?
>

> > +     DESTINATION bin)
> > +
> > +list(REMOVE_ITEM PROGRAMS_BUILT git git-shell)
> > +install(TARGETS ${PROGRAMS_BUILT}
> > +     RUNTIME DESTINATION libexec/git-core)
>
> Ubuntu install exec file to /usr/lib/git-core?
>

> > +
> > +set(bin_links
> > +     git-receive-pack git-upload-archive git-upload-pack)
> > +
> > +foreach(b ${bin_links})
> > +install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git ${CMAKE_INSTALL_PREFIX}/bin/${b})")
> > +endforeach()
> > +
> > +install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git)")
> > +install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git-shell ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git-shell)")
> > +
> > +foreach(b ${git_links})
> > +     string(REPLACE "${CMAKE_BINARY_DIR}" "" b ${b})
> > +     install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git ${CMAKE_INSTALL_PREFIX}/libexec/git-core/${b})")
> > +endforeach()
> > +
> > +foreach(b ${git_http_links})
> > +     string(REPLACE "${CMAKE_BINARY_DIR}" "" b ${b})
> > +     install(CODE "file(CREATE_LINK  ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git-remote-http ${CMAKE_INSTALL_PREFIX}/libexec/git-core/${b})")
> > +endforeach()
> > +
> > +install(PROGRAMS ${git_shell_scripts} ${git_perl_scripts} ${CMAKE_BINARY_DIR}/git-p4
> > +     DESTINATION libexec/git-core)
> > +
> > +install(DIRECTORY mergetools DESTINATION libexec/git-core)
> > +install(DIRECTORY ${CMAKE_BINARY_DIR}/perl/build/lib/ DESTINATION share/perl5
> > +     FILES_MATCHING PATTERN "*.pm")
>
> I think distro gonna complans about this pattern!
>

> > +install(DIRECTORY ${CMAKE_BINARY_DIR}/templates/blt/ DESTINATION share/git-core/templates)
> > +
> > +if(MSGFMT_EXE)
> > +     install(DIRECTORY ${CMAKE_BINARY_DIR}/po/build/locale DESTINATION share)
> > +endif()
>
> I thought we want to check for NO_GETTEXT?
>
> --
> Danh

> To make this a little less awkward, the Git for Windows project offers
> the `vs/master` branch which has a full Visual Studio solution generated
> and committed. This branch can therefore be used to tinker with Git in
> Visual Studio _without_ having to download the full Git for Windows SDK.
> Unfortunatly, that branch is auto-generated from Git for Windows'
> `master`. If a developer wants to tinker, say, with `pu`, they are out
> of luck.

> With a working support CMake, developers on Windows need only install
> CMake, configure their build, load the generated Visual Studio solution
> and immediately start modifying the code and build their own version of
> Git. Likewise, developers on other platforms can use the convenient GUI
> tools provided by CMake to configure their build.

> So let's start building CMake support for Git.
> 
> This is only the first step, and to make it easier to review, it only
> allows for configuring builds on the platform that is easiest to
> configure for: Linux.
> 
> The CMake script checks whether the headers are present(eg. libgen.h),
> whether the functions are present(eg. memmem), whether the funtions work
> properly (eg. snprintf) and generate the required compile definitions
> for the platform. The script also searches for the required libraries,
> if it fails to find the required libraries the respective executables
> won't be built.(eg. If libcurl is not found then git-remote-http won't
> be built). This will help building Git easier.
> 
> With a CMake script an out of source build of git is possible resulting
> in a clean source tree.
> 
> Note: earlier endeavors on the Git mailing list to introduce CMake ended
> up in dead water. The primary reason for that was that reviewers
> _expected_ CMake support to fall out of maintenance, unless the
> contributor would promise to keep an eye on keeping CMake support up to
> date. However, in the meantime, support for automated testing has been
> introduced in Git's source code, and a later patch will modify the
> (still experimental) GitHub workflow to continually verify that CMake
> support is still complete. That will make maintenance reasonably easy.
> 
> Note: this patch asks for the minimum version v3.14 of CMake (which is
> not all that old as of time of writing) because that is the first

> version to offer a platform-independent way to generate hardlinks as
> part of the build. This is needed to generate all those hardlinks for
> the built-in commands of Git.
> 
> Instructions to run CMake:
> 
> cmake `relative-path-to-srcdir` -DCMAKE_BUILD_TYPE=Release
> 
> Possible build configurations(-DCMAKE_BUILD_TYPE) with corresponding
> compiler flags
> Debug : -g
> Release: -O3

> RelWithDebInfo : -O2 -g
> MinSizeRel : -Os
> empty(default) :
> 
> NOTE: -DCMAKE_BUILD_TYPE is optional
> 
> This process generates a Makefile.
> Then run `make` to build Git.
> 
> NOTE: By default CMake uses Makefile as the build tool on Linux, to use
> another tool say `ninja` add this to the command line when configuring.
> `-G Ninja`
> 
> Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> ---
>  CMakeLists.txt | 528 +++++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 528 insertions(+)
>  create mode 100644 CMakeLists.txt
> 
> diff --git a/CMakeLists.txt b/CMakeLists.txt
> new file mode 100644
> index 00000000000..73703bd321f
> --- /dev/null
> +++ b/CMakeLists.txt
> @@ -0,0 +1,528 @@
> +#
> +#	Copyright (c) 2020 Sibi Siddharthan
> +#
> +
> +cmake_minimum_required(VERSION 3.14)
> +
> +#Parse GIT-VERSION-GEN to get the version
> +file(STRINGS ${CMAKE_SOURCE_DIR}/GIT-VERSION-GEN git_version REGEX "DEF_VER=v(.*)")
> +string(REPLACE "DEF_VER=v" "" git_version ${git_version})
> +string(REPLACE ".GIT" ".0" git_version ${git_version})#for building from a snapshot

> +
> +project(git
> +	VERSION ${git_version}
> +	LANGUAGES C)
> +
> +
> +include(CheckTypeSize)
> +include(CheckCSourceRuns)
> +include(CheckCSourceCompiles)
> +include(CheckIncludeFile)
> +include(CheckFunctionExists)
> +include(CheckSymbolExists)
> +include(CheckStructHasMember)
> +
> +find_package(ZLIB REQUIRED)
> +find_package(CURL)

> +
> +include_directories(SYSTEM ${ZLIB_INCLUDE_DIRS})
> +if(CURL_FOUND)
> +	include_directories(SYSTEM ${CURL_INCLUDE_DIRS})
> +endif()
> +if(EXPAT_FOUND)
> +	include_directories(SYSTEM ${EXPAT_INCLUDE_DIRS})
> +endif()
> +if(Iconv_FOUND)
> +	include_directories(SYSTEM ${Iconv_INCLUDE_DIRS})
> +endif()
> +if(Intl_FOUND)
> +	include_directories(SYSTEM ${Intl_INCLUDE_DIRS})
> +endif()
> +
> +find_program(SH_EXE sh)

> +
> +#default behaviour
> +include_directories(${CMAKE_SOURCE_DIR})
> +add_compile_definitions(GIT_HOST_CPU="${CMAKE_SYSTEM_PROCESSOR}")
> +add_compile_definitions(SHA256_BLK INTERNAL_QSORT RUNTIME_PREFIX)
> +add_compile_definitions(NO_OPENSSL SHA1_DC SHA1DC_NO_STANDARD_INCLUDES
> +			SHA1DC_INIT_SAFE_HASH_DEFAULT=0
> +			SHA1DC_CUSTOM_INCLUDE_SHA1_C="cache.h"
> +			SHA1DC_CUSTOM_INCLUDE_UBC_CHECK_C="git-compat-util.h" )
> +list(APPEND compat_SOURCES sha1dc_git.c sha1dc/sha1.c sha1dc/ubc_check.c block-sha1/sha1.c sha256/block/sha256.c compat/qsort_s.c)
> +
> +
> +add_compile_definitions(PAGER_ENV="LESS=FRX LV=-c"
> +			ETC_GITATTRIBUTES="etc/gitattributes"
> +			ETC_GITCONFIG="etc/gitconfig"
> +			GIT_EXEC_PATH="libexec/git-core"
> +			GIT_LOCALE_PATH="share/locale"
> +			GIT_MAN_PATH="share/man"
> +			GIT_INFO_PATH="share/info"
> +			GIT_HTML_PATH="share/doc/git-doc"
> +			DEFAULT_HELP_FORMAT="html"
> +			DEFAULT_GIT_TEMPLATE_DIR="share/git-core/templates"
> +			GIT_VERSION="${PROJECT_VERSION}.GIT"
> +			GIT_USER_AGENT="git/${PROJECT_VERSION}.GIT"
> +			BINDIR="bin"
> +			GIT_BUILT_FROM_COMMIT="")

> +
> +set(FALLBACK_RUNTIME_PREFIX /home/$ENV{USER})
> +add_compile_definitions(FALLBACK_RUNTIME_PREFIX="${FALLBACK_RUNTIME_PREFIX}")
> +
> +add_compile_definitions(PROCFS_EXECUTABLE_PATH="/proc/self/exe" HAVE_DEV_TTY )

> +list(APPEND compat_SOURCES unix-socket.c)
> +
> +#header checks
> +check_include_file(libgen.h HAVE_LIBGEN_H)
> +if(NOT HAVE_LIBGEN_H)
> +	add_compile_definitions(NO_LIBGEN_H)
> +	list(APPEND compat_SOURCES compat/basename.c)
> +endif()
> +
> +check_include_file(sys/sysinfo.h HAVE_SYSINFO)
> +if(HAVE_SYSINFO)
> +	add_compile_definitions(HAVE_SYSINFO)
> +endif()
> +
> +check_c_source_compiles("
> +#include <alloca.h>
> +int
> +main ()
> +{
> +char *p = (char *) alloca (2 * sizeof (int));
> +	if (p) return 0;
> +	return 0;

> +}"
> +HAVE_ALLOCA_H)
> +if(HAVE_ALLOCA_H)
> +	add_compile_definitions(HAVE_ALLOCA_H)
> +endif()
> +
> +check_include_file(strings.h HAVE_STRINGS_H)
> +if(HAVE_STRINGS_H)
> +	add_compile_definitions(HAVE_STRINGS_H)
> +endif()
> +
> +check_include_file(sys/select.h HAVE_SYS_SELECT_H)
> +if(NOT HAVE_SYS_SELECT_H)
> +	add_compile_definitions(NO_SYS_SELECT_H)
> +endif()
> +
> +check_include_file(sys/poll.h HAVE_SYS_POLL_H)
> +if(NOT HAVE_SYS_POLL_H)
> +	add_compile_definitions(NO_SYS_POLL_H)
> +endif()
> +
> +check_include_file(poll.h HAVE_POLL_H)

> +if(NOT HAVE_POLL_H)
> +	add_compile_definitions(NO_POLL_H)
> +endif()
> +
> +check_include_file(inttypes.h HAVE_INTTYPES_H)
> +if(NOT HAVE_INTTYPES_H)
> +	add_compile_definitions(NO_INTTYPES_H)
> +endif()
> +
> +check_include_file(paths.h HAVE_PATHS_H)
> +if(HAVE_PATHS_H)
> +	add_compile_definitions(HAVE_PATHS_H)
> +endif()
> +
> +#function checks
> +set(function_checks
> +	strcasestr memmem strlcpy strtoimax strtoumax strtoull
> +	setenv  mkdtemp poll pread  memmem unsetenv hstrerror)
> +
> +foreach(f ${function_checks})
> +	string(TOUPPER ${f} uf)
> +	check_function_exists(${f} HAVE_${uf})
> +	if(NOT HAVE_${uf})
> +		add_compile_definitions(NO_${uf})
> +	endif()
> +endforeach()
> +
> +if(NOT HAVE_POLL_H OR NOT HAVE_SYS_POLL_H OR NOT HAVE_POLL)
> +	include_directories(compat/poll)
> +	add_compile_definitions(NO_POLL)
> +	list(APPEND compat_SOURCES compat/poll/poll.c)
> +endif()
> +
> +if(NOT HAVE_STRCASESTR)
> +	list(APPEND compat_SOURCES compat/strcasestr.c)
> +endif()
> +
> +if(NOT HAVE_STRLCPY)
> +	list(APPEND compat_SOURCES compat/strlcpy.c)
> +endif()
> +
> +if(NOT HAVE_STRTOUMAX)
> +	list(APPEND compat_SOURCES compat/strtoumax.c compat/strtoimax.c)
> +endif()
> +
> +if(NOT HAVE_SETENV)
> +	list(APPEND compat_SOURCES compat/setenv.c)
> +endif()
> +
> +if(NOT HAVE_MKDTEMP)
> +	list(APPEND compat_SOURCES compat/mkdtemp.c)
> +endif()
> +
> +if(NOT HAVE_PREAD)
> +	list(APPEND compat_SOURCES compat/pread.c)
> +endif()
> +
> +if(NOT HAVE_MEMMEM)
> +	list(APPEND compat_SOURCES compat/memmem.c)
> +endif()
> +
> +if(NOT WIN32)
> +	if(NOT HAVE_UNSETENV)
> +		list(APPEND compat_SOURCES compat/unsetenv.c)
> +	endif()
> +
> +	if(NOT HAVE_HSTRERROR)
> +		list(APPEND compat_SOURCES compat/hstrerror.c)
> +	endif()
> +endif()
> +
> +check_function_exists(getdelim HAVE_GETDELIM)
> +if(HAVE_GETDELIM)
> +	add_compile_definitions(HAVE_GETDELIM)
> +endif()
> +
> +check_function_exists(clock_gettime HAVE_CLOCK_GETTIME)
> +check_symbol_exists(CLOCK_MONOTONIC "time.h" HAVE_CLOCK_MONOTONIC)
> +if(HAVE_CLOCK_GETTIME)
> +	add_compile_definitions(HAVE_CLOCK_GETTIME)
> +endif()
> +if(HAVE_CLOCK_MONOTONIC)
> +	add_compile_definitions(HAVE_CLOCK_MONOTONIC)
> +endif()
> +
> +
> +#compile checks
> +check_c_source_runs("
> +#include<stdio.h>
> +#include<stdarg.h>
> +#include<string.h>
> +#include<stdlib.h>
> +int test_vsnprintf(char *str, size_t maxsize, const char *format, ...)
> +{
> +	int ret;
> +	va_list ap;
> +
> +	va_start(ap, format);
> +	ret = vsnprintf(str, maxsize, format, ap);
> +	va_end(ap);
> +	return ret;
> +}
> +
> +int
> +main ()
> +{
> +	char buf[6];
> +	if (test_vsnprintf(buf, 3, \"%s\", \"12345\") != 5
> +		|| strcmp(buf, \"12\")) return 1;
> +	if (snprintf(buf, 3, \"%s\", \"12345\") != 5
> +		|| strcmp(buf, \"12\")) return 1;
> +
> +	return 0;
> +}"
> +SNPRINTF_OK)
> +if(NOT SNPRINTF_OK)
> +	add_compile_definitions(SNPRINTF_RETURNS_BOGUS)
> +	list(APPEND compat_SOURCES compat/snprintf.c)
> +endif()
> +
> +check_c_source_runs("
> +#include<stdio.h>
> +int
> +main ()
> +{
> +	FILE *f = fopen(\".\", \"r\");
> +	return f != NULL;
> +
> +	return 0;
> +}"
> +FREAD_READS_DIRECTORIES_NO)
> +if(NOT FREAD_READS_DIRECTORIES_NO)
> +	add_compile_definitions(FREAD_READS_DIRECTORIES)
> +	list(APPEND compat_SOURCES compat/fopen.c)
> +endif()
> +
> +check_c_source_compiles("
> +#include <regex.h>
> +#ifndef REG_STARTEND
> +#error oops we dont have it
> +#endif
> +int main(){return 0;}"
> +HAVE_REGEX)
> +if(NOT HAVE_REGEX)
> +	include_directories(compat/regex )
> +	list(APPEND compat_SOURCES compat/regex/regex.c )
> +	add_compile_definitions(NO_REGEX NO_MBSUPPORT GAWK)
> +endif()
> +
> +
> +check_c_source_compiles("
> +#include <stddef.h>
> +#include <sys/types.h>
> +#include <sys/sysctl.h>
> +
> +int
> +main ()
> +{
> +	int val, mib[2];
> +	size_t len;
> +
> +	mib[0] = CTL_HW;
> +	mib[1] = 1;
> +	len = sizeof(val);
> +	return sysctl(mib, 2, &val, &len, NULL, 0) ? 1 : 0;
> +
> +	return 0;
> +}"
> +HAVE_BSD_SYSCTL)
> +if(HAVE_BSD_SYSCTL)
> +	add_compile_definitions(HAVE_BSD_SYSCTL)
> +endif()
> +
> +#programs
> +set(PROGRAMS_BUILT
> +	git git-bugreport git-credential-store git-daemon git-fast-import git-http-backend git-sh-i18n--envsubst
> +	git-shell git-remote-testsvn git-credential-cache git-credential-cache--daemon)
> +
> +if(NOT CURL_FOUND)
> +	list(APPEND excluded_progs git-http-fetch git-http-push)
> +	add_compile_definitions(NO_CURL)
> +	message(WARNING "git-http-push and git-http-fetch will not be built")
> +else()
> +	list(APPEND PROGRAMS_BUILT git-http-fetch git-http-push git-imap-send git-remote-http)
> +	if(CURL_VERSION_STRING VERSION_GREATER_EQUAL 7.34.0)
> +		add_compile_definitions(USE_CURL_FOR_IMAP_SEND)
> +	endif()
> +endif()
> +
> +if(NOT EXPAT_FOUND)
> +	list(APPEND excluded_progs git-http-push)
> +	add_compile_definitions(NO_EXPAT)
> +else()
> +	list(APPEND PROGRAMS_BUILT git-http-push)
> +	if(EXPAT_VERSION_STRING VERSION_LESS_EQUAL 1.2)
> +		add_compile_definitions(EXPAT_NEEDS_XMLPARSE_H)
> +	endif()
> +endif()
> +
> +list(REMOVE_DUPLICATES excluded_progs)
> +list(REMOVE_DUPLICATES PROGRAMS_BUILT)
> +
> +
> +foreach(p ${excluded_progs})
> +	list(APPEND EXCLUSION_PROGS --exclude-program ${p} )
> +endforeach()
> +
> +#for comparing null values
> +list(APPEND EXCLUSION_PROGS empty)
> +set(EXCLUSION_PROGS_CACHE ${EXCLUSION_PROGS} CACHE STRING "Programs not built" FORCE)
> +
> +if(NOT EXISTS ${CMAKE_SOURCE_DIR}/command-list.h OR NOT EXCLUSION_PROGS_CACHE STREQUAL EXCLUSION_PROGS)
> +	list(REMOVE_ITEM EXCLUSION_PROGS empty)
> +	message("Generating command-list.h")
> +	execute_process(COMMAND ${SH_EXE} ${CMAKE_SOURCE_DIR}/generate-cmdlist.sh ${EXCLUSION_PROGS} command-list.txt
> +			WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
> +			OUTPUT_FILE ${CMAKE_SOURCE_DIR}/command-list.h)
> +endif()
> +
> +if(NOT EXISTS ${CMAKE_SOURCE_DIR}/config-list.h)
> +	message("Generating config-list.h")
> +	execute_process(COMMAND ${SH_EXE} ${CMAKE_SOURCE_DIR}/generate-configlist.sh
> +			WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
> +			OUTPUT_FILE ${CMAKE_SOURCE_DIR}/config-list.h)
> +endif()
> +
> +
> +#build
> +set(libgit_SOURCES
> +	abspath.c add-interactive.c add-patch.c advice.c alias.c
> +	alloc.c apply.c archive.c archive-tar.c archive-zip.c argv-array.c
> +	attr.c base85.c bisect.c blame.c blob.c bloom.c branch.c bulk-checkin.c
> +	bundle.c cache-tree.c chdir-notify.c checkout.c color.c column.c
> +	combine-diff.c commit.c commit-graph.c commit-reach.c compat/obstack.c
> +	compat/terminal.c config.c connect.c connected.c convert.c copy.c credential.c
> +	csum-file.c ctype.c date.c decorate.c delta-islands.c diffcore-break.c
> +	diffcore-delta.c diffcore-order.c diffcore-pickaxe.c diffcore-rename.c
> +	diff-delta.c diff-lib.c diff-no-index.c diff.c dir.c dir-iterator.c editor.c
> +	entry.c environment.c ewah/bitmap.c ewah/ewah_bitmap.c ewah/ewah_io.c
> +	ewah/ewah_rlw.c exec-cmd.c fetch-negotiator.c fetch-pack.c fmt-merge-msg.c fsck.c fsmonitor.c
> +	gettext.c gpg-interface.c graph.c grep.c hashmap.c linear-assignment.c help.c hex.c
> +	ident.c interdiff.c json-writer.c kwset.c levenshtein.c line-log.c line-range.c list-objects.c
> +	list-objects-filter.c list-objects-filter-options.c ll-merge.c lockfile.c
> +	log-tree.c ls-refs.c mailinfo.c mailmap.c match-trees.c mem-pool.c merge.c merge-blobs.c
> +	merge-recursive.c mergesort.c midx.c name-hash.c negotiator/default.c
> +	negotiator/skipping.c notes.c notes-cache.c notes-merge.c notes-utils.c object.c oidmap.c
> +	oidset.c oid-array.c packfile.c pack-bitmap.c pack-bitmap-write.c pack-check.c pack-objects.c
> +	pack-revindex.c pack-write.c pager.c parse-options.c parse-options-cb.c patch-delta.c
> +	patch-ids.c path.c pathspec.c pkt-line.c preload-index.c pretty.c prio-queue.c progress.c
> +	promisor-remote.c prompt.c protocol.c prune-packed.c quote.c range-diff.c reachable.c read-cache.c rebase.c
> +	rebase-interactive.c reflog-walk.c refs.c refs/files-backend.c refs/iterator.c
> +	refs/packed-backend.c refs/ref-cache.c refspec.c ref-filter.c remote.c replace-object.c
> +	repo-settings.c repository.c rerere.c reset.c resolve-undo.c revision.c run-command.c
> +	send-pack.c sequencer.c serve.c server-info.c setup.c sha1-lookup.c
> +	sha1-file.c sha1-name.c shallow.c sideband.c sigchain.c split-index.c
> +	stable-qsort.c strbuf.c streaming.c string-list.c submodule.c submodule-config.c
> +	sub-process.c symlinks.c tag.c tempfile.c thread-utils.c tmp-objdir.c
> +	trace.c trace2.c trace2/tr2_cfg.c trace2/tr2_cmd_name.c trace2/tr2_dst.c
> +	trace2/tr2_sid.c trace2/tr2_sysenv.c trace2/tr2_tbuf.c trace2/tr2_tgt_event.c
> +	trace2/tr2_tgt_normal.c trace2/tr2_tgt_perf.c trace2/tr2_tls.c trailer.c transport.c
> +	transport-helper.c tree-diff.c tree.c tree-walk.c unpack-trees.c upload-pack.c url.c
> +	urlmatch.c usage.c userdiff.c utf8.c varint.c version.c versioncmp.c walker.c wildmatch.c
> +	worktree.c wrapper.c write-or-die.c ws.c wt-status.c xdiff-interface.c
> +	zlib.c)
> +
> +add_library(libgit ${libgit_SOURCES} ${compat_SOURCES})
> +
> +set(libxdiff_SOURCES
> +	xdiff/xdiffi.c xdiff/xprepare.c xdiff/xutils.c xdiff/xemit.c
> +	xdiff/xmerge.c xdiff/xpatience.c xdiff/xhistogram.c)
> +add_library(xdiff STATIC ${libxdiff_SOURCES})
> +
> +set(libvcs-svn_SOURCES
> +	vcs-svn/line_buffer.c vcs-svn/sliding_window.c vcs-svn/fast_export.c
> +	vcs-svn/svndiff.c vcs-svn/svndump.c)
> +add_library(vcs-svn STATIC ${libvcs-svn_SOURCES})
> +
> +#link all required libraries to common-main
> +add_library(common-main OBJECT common-main.c)
> +target_link_libraries(common-main libgit xdiff ${ZLIB_LIBRARIES} pthread rt)
> +if(Intl_FOUND)
> +	target_link_libraries(common-main ${Intl_LIBRARIES})
> +endif()
> +if(Iconv_FOUND)
> +	target_link_libraries(common-main ${Iconv_LIBRARIES})
> +endif()
> +
> +
> +set(git_SOURCES
> +	builtin/add.c builtin/am.c builtin/annotate.c builtin/apply.c
> +	builtin/archive.c builtin/bisect--helper.c builtin/blame.c
> +	builtin/branch.c builtin/bundle.c builtin/cat-file.c builtin/check-attr.c
> +	builtin/check-ignore.c builtin/check-mailmap.c builtin/check-ref-format.c
> +	builtin/checkout-index.c builtin/checkout.c builtin/clean.c
> +	builtin/clone.c builtin/column.c builtin/commit-tree.c
> +	builtin/commit.c builtin/commit-graph.c builtin/config.c
> +	builtin/count-objects.c builtin/credential.c builtin/describe.c
> +	builtin/diff-files.c builtin/diff-index.c builtin/diff-tree.c
> +	builtin/diff.c builtin/difftool.c builtin/env--helper.c
> +	builtin/fast-export.c builtin/fetch-pack.c builtin/fetch.c builtin/fmt-merge-msg.c
> +	builtin/for-each-ref.c builtin/fsck.c builtin/gc.c
> +	builtin/get-tar-commit-id.c builtin/grep.c builtin/hash-object.c
> +	builtin/help.c builtin/index-pack.c builtin/init-db.c
> +	builtin/interpret-trailers.c builtin/log.c builtin/ls-files.c
> +	builtin/ls-remote.c builtin/ls-tree.c builtin/mailinfo.c builtin/mailsplit.c
> +	builtin/merge.c builtin/merge-base.c builtin/merge-file.c builtin/merge-index.c
> +	builtin/merge-ours.c builtin/merge-recursive.c builtin/merge-tree.c
> +	builtin/mktag.c builtin/mktree.c builtin/multi-pack-index.c builtin/mv.c
> +	builtin/name-rev.c builtin/notes.c builtin/pack-objects.c builtin/pack-redundant.c
> +	builtin/pack-refs.c builtin/patch-id.c builtin/prune-packed.c builtin/prune.c
> +	builtin/pull.c builtin/push.c builtin/range-diff.c builtin/read-tree.c
> +	builtin/rebase.c builtin/receive-pack.c builtin/reflog.c builtin/remote.c
> +	builtin/remote-ext.c builtin/remote-fd.c builtin/repack.c builtin/replace.c
> +	builtin/rerere.c builtin/reset.c builtin/rev-list.c builtin/rev-parse.c
> +	builtin/revert.c builtin/rm.c builtin/send-pack.c builtin/shortlog.c
> +	builtin/show-branch.c builtin/show-index.c builtin/show-ref.c
> +	builtin/sparse-checkout.c builtin/stash.c builtin/stripspace.c
> +	builtin/submodule--helper.c builtin/symbolic-ref.c builtin/tag.c
> +	builtin/unpack-file.c builtin/unpack-objects.c builtin/update-index.c
> +	builtin/update-ref.c builtin/update-server-info.c builtin/upload-archive.c
> +	builtin/upload-pack.c builtin/var.c builtin/verify-commit.c builtin/verify-pack.c
> +	builtin/verify-tag.c builtin/worktree.c builtin/write-tree.c)
> +
> +add_executable(git git.c ${git_SOURCES})
> +target_link_libraries(git common-main )
> +
> +add_executable(git-bugreport bugreport.c)
> +target_link_libraries(git-bugreport common-main)
> +
> +add_executable(git-credential-store credential-store.c)
> +target_link_libraries(git-credential-store common-main)
> +
> +add_executable(git-daemon daemon.c)
> +target_link_libraries(git-daemon common-main)
> +
> +add_executable(git-fast-import fast-import.c)
> +target_link_libraries(git-fast-import common-main)
> +
> +add_executable(git-http-backend http-backend.c)
> +target_link_libraries(git-http-backend common-main)
> +
> +add_executable(git-sh-i18n--envsubst sh-i18n--envsubst.c)
> +target_link_libraries(git-sh-i18n--envsubst common-main)
> +
> +add_executable(git-shell shell.c)
> +target_link_libraries(git-shell common-main)
> +
> +if(CURL_FOUND)
> +	add_library(http_obj OBJECT http.c)
> +
> +	add_executable(git-imap-send imap-send.c)
> +	target_link_libraries(git-imap-send http_obj common-main ${CURL_LIBRARIES})
> +
> +	add_executable(git-http-fetch http-walker.c http-fetch.c)
> +	target_link_libraries(git-http-fetch http_obj common-main ${CURL_LIBRARIES})
> +
> +	add_executable(git-remote-http http-walker.c remote-curl.c)
> +	target_link_libraries(git-remote-http http_obj common-main ${CURL_LIBRARIES} )
> +
> +	if(EXPAT_FOUND)
> +		add_executable(git-http-push http-push.c)
> +		target_link_libraries(git-http-push http_obj common-main ${CURL_LIBRARIES} ${EXPAT_LIBRARIES})
> +	endif()
> +endif()
> +
> +add_executable(git-remote-testsvn remote-testsvn.c)
> +target_link_libraries(git-remote-testsvn common-main vcs-svn)
> +
> +add_executable(git-credential-cache credential-cache.c)
> +target_link_libraries(git-credential-cache common-main)
> +
> +add_executable(git-credential-cache--daemon credential-cache--daemon.c)
> +target_link_libraries(git-credential-cache--daemon common-main)
> +
> +
> +set(git_builtin_extra
> +	cherry cherry-pick format-patch fsck-objects
> +	init merge-subtree restore show
> +	stage status switch whatchanged)
> +
> +#Creating hardlinks
> +foreach(s ${git_SOURCES} ${git_builtin_extra})
> +	string(REPLACE "builtin/" "" s ${s})
> +	string(REPLACE ".c" "" s ${s})
> +	file(APPEND ${CMAKE_BINARY_DIR}/CreateLinks.cmake "file(CREATE_LINK git git-${s})\n")
> +	list(APPEND git_links ${CMAKE_BINARY_DIR}/git-${s})
> +endforeach()
> +
> +if(CURL_FOUND)
> +	set(remote_exes
> +		git-remote-https git-remote-ftp git-remote-ftps)
> +	foreach(s ${remote_exes})
> +		file(APPEND ${CMAKE_BINARY_DIR}/CreateLinks.cmake "file(CREATE_LINK git-remote-http ${s})\n")
> +		list(APPEND git_http_links ${CMAKE_BINARY_DIR}/${s})
> +	endforeach()
> +endif()
> +
> +add_custom_command(OUTPUT ${git_links} ${git_http_links}
> +		COMMAND ${CMAKE_COMMAND} -P ${CMAKE_BINARY_DIR}/CreateLinks.cmake
> +		DEPENDS git git-remote-http)
> +add_custom_target(git-links ALL DEPENDS ${git_links} ${git_http_links})
> \ No newline at end of file

>
> On 2020-04-24 04:01:30+0000, Sibi Siddharthan via GitGitGadget <gitgitgadget@gmail.com> wrote:
>
> Please excuse my hatred for CMake.
>
> I guess it's my own fault for not learning how to write CMake
> properly, or is it too hard to write correct CMake?
>
> > To make this a little less awkward, the Git for Windows project offers
> > the `vs/master` branch which has a full Visual Studio solution generated
> > and committed. This branch can therefore be used to tinker with Git in
> > Visual Studio _without_ having to download the full Git for Windows SDK.
> > Unfortunatly, that branch is auto-generated from Git for Windows'
> > `master`. If a developer wants to tinker, say, with `pu`, they are out
> > of luck.
>
> I thought:
>         make NDEBUG=1 DEVELOPER=1 vcxproj
>
> was invented for this use case?
>

> > CMake was invented to make this sort of problem go away, by providing a
> > more standardized, cross-platform way to configure builds.
>
> There is something fun with that *cross*
> Is cmake able to cross-compile cmake by cmake now?
>
> > With a working support CMake, developers on Windows need only install
> > CMake, configure their build, load the generated Visual Studio solution
> > and immediately start modifying the code and build their own version of
> > Git. Likewise, developers on other platforms can use the convenient GUI
> > tools provided by CMake to configure their build.
>
> OK, that's fine if it works for you.
> Please don't drop support for autoconf and Makefile, though.
> (I haven't look into other patches)
>

> > So let's start building CMake support for Git.
> >
> > This is only the first step, and to make it easier to review, it only
> > allows for configuring builds on the platform that is easiest to
> > configure for: Linux.
> >
> > The CMake script checks whether the headers are present(eg. libgen.h),
> > whether the functions are present(eg. memmem), whether the funtions work
> > properly (eg. snprintf) and generate the required compile definitions
> > for the platform. The script also searches for the required libraries,
> > if it fails to find the required libraries the respective executables
> > won't be built.(eg. If libcurl is not found then git-remote-http won't
> > be built). This will help building Git easier.
> >
> > With a CMake script an out of source build of git is possible resulting
> > in a clean source tree.
> >
> > Note: earlier endeavors on the Git mailing list to introduce CMake ended
> > up in dead water. The primary reason for that was that reviewers
> > _expected_ CMake support to fall out of maintenance, unless the
> > contributor would promise to keep an eye on keeping CMake support up to
> > date. However, in the meantime, support for automated testing has been
> > introduced in Git's source code, and a later patch will modify the
> > (still experimental) GitHub workflow to continually verify that CMake
> > support is still complete. That will make maintenance reasonably easy.
> >
> > Note: this patch asks for the minimum version v3.14 of CMake (which is
> > not all that old as of time of writing) because that is the first
>
> Debian Buster (current stable) ships v3.13.4, I think I don't need to
> mention old-stable of Debian (Stretch or Jessie).
>
>
> > version to offer a platform-independent way to generate hardlinks as
> > part of the build. This is needed to generate all those hardlinks for
> > the built-in commands of Git.
> >
> > Instructions to run CMake:
> >
> > cmake `relative-path-to-srcdir` -DCMAKE_BUILD_TYPE=Release
> >
> > Possible build configurations(-DCMAKE_BUILD_TYPE) with corresponding
> > compiler flags
> > Debug : -g
> > Release: -O3
>
> IIRC, Linus and Junio used to said noone ever needs "-03"
>

> > RelWithDebInfo : -O2 -g
> > MinSizeRel : -Os
> > empty(default) :
> >
> > NOTE: -DCMAKE_BUILD_TYPE is optional
> >
> > This process generates a Makefile.
> > Then run `make` to build Git.
> >
> > NOTE: By default CMake uses Makefile as the build tool on Linux, to use
> > another tool say `ninja` add this to the command line when configuring.
> > `-G Ninja`
> >
> > Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > ---
> >  CMakeLists.txt | 528 +++++++++++++++++++++++++++++++++++++++++++++++++
> >  1 file changed, 528 insertions(+)
> >  create mode 100644 CMakeLists.txt
> >
> > diff --git a/CMakeLists.txt b/CMakeLists.txt
> > new file mode 100644
> > index 00000000000..73703bd321f
> > --- /dev/null
> > +++ b/CMakeLists.txt
> > @@ -0,0 +1,528 @@
> > +#
> > +#    Copyright (c) 2020 Sibi Siddharthan
> > +#
> > +
> > +cmake_minimum_required(VERSION 3.14)
> > +
> > +#Parse GIT-VERSION-GEN to get the version
> > +file(STRINGS ${CMAKE_SOURCE_DIR}/GIT-VERSION-GEN git_version REGEX "DEF_VER=v(.*)")
> > +string(REPLACE "DEF_VER=v" "" git_version ${git_version})
> > +string(REPLACE ".GIT" ".0" git_version ${git_version})#for building from a snapshot
>
> Does it work with e.g. 2.26.1?
>

> > +
> > +project(git
> > +     VERSION ${git_version}
> > +     LANGUAGES C)
> > +
> > +
> > +include(CheckTypeSize)
> > +include(CheckCSourceRuns)
> > +include(CheckCSourceCompiles)
> > +include(CheckIncludeFile)
> > +include(CheckFunctionExists)
> > +include(CheckSymbolExists)
> > +include(CheckStructHasMember)
> > +
> > +find_package(ZLIB REQUIRED)
> > +find_package(CURL)
>
> Right now, we should --with-zlib=/path/to/zlib/root
> Does this `find_package` support it?
>

> > +find_package(EXPAT)
> > +find_package(Iconv)
> > +find_package(Intl)
> > +
>
> > +if(NOT Intl_FOUND)
> > +     add_compile_definitions(NO_GETTEXT)
>
> find_package(Gettext)?
>

> > +     if(NOT Iconv_FOUND)
> > +             add_compile_definitions(NO_ICONV)
> > +     endif()
> > +endif()
>
> ICONV_OMITS_BOM?
>

> > +
> > +include_directories(SYSTEM ${ZLIB_INCLUDE_DIRS})
> > +if(CURL_FOUND)
> > +     include_directories(SYSTEM ${CURL_INCLUDE_DIRS})
> > +endif()
> > +if(EXPAT_FOUND)
> > +     include_directories(SYSTEM ${EXPAT_INCLUDE_DIRS})
> > +endif()
> > +if(Iconv_FOUND)
> > +     include_directories(SYSTEM ${Iconv_INCLUDE_DIRS})
> > +endif()
> > +if(Intl_FOUND)
> > +     include_directories(SYSTEM ${Intl_INCLUDE_DIRS})
> > +endif()
> > +
> > +find_program(SH_EXE sh)
>
> We want to find usable sh, not just sh, no?
>
> It's matter on Solaris, HP-UX
>

> > +
> > +#default behaviour
> > +include_directories(${CMAKE_SOURCE_DIR})
> > +add_compile_definitions(GIT_HOST_CPU="${CMAKE_SYSTEM_PROCESSOR}")
> > +add_compile_definitions(SHA256_BLK INTERNAL_QSORT RUNTIME_PREFIX)
> > +add_compile_definitions(NO_OPENSSL SHA1_DC SHA1DC_NO_STANDARD_INCLUDES
> > +                     SHA1DC_INIT_SAFE_HASH_DEFAULT=0
> > +                     SHA1DC_CUSTOM_INCLUDE_SHA1_C="cache.h"
> > +                     SHA1DC_CUSTOM_INCLUDE_UBC_CHECK_C="git-compat-util.h" )
> > +list(APPEND compat_SOURCES sha1dc_git.c sha1dc/sha1.c sha1dc/ubc_check.c block-sha1/sha1.c sha256/block/sha256.c compat/qsort_s.c)
> > +
> > +
> > +add_compile_definitions(PAGER_ENV="LESS=FRX LV=-c"
> > +                     ETC_GITATTRIBUTES="etc/gitattributes"
> > +                     ETC_GITCONFIG="etc/gitconfig"
> > +                     GIT_EXEC_PATH="libexec/git-core"
> > +                     GIT_LOCALE_PATH="share/locale"
> > +                     GIT_MAN_PATH="share/man"
> > +                     GIT_INFO_PATH="share/info"
> > +                     GIT_HTML_PATH="share/doc/git-doc"
> > +                     DEFAULT_HELP_FORMAT="html"
> > +                     DEFAULT_GIT_TEMPLATE_DIR="share/git-core/templates"
> > +                     GIT_VERSION="${PROJECT_VERSION}.GIT"
> > +                     GIT_USER_AGENT="git/${PROJECT_VERSION}.GIT"
> > +                     BINDIR="bin"
> > +                     GIT_BUILT_FROM_COMMIT="")
>
> I wish I could verify this.
> Have you check this part on a default build system for a Linux distro,
> FreeBSD? For things started with "etc/"
>

> > +
> > +set(FALLBACK_RUNTIME_PREFIX /home/$ENV{USER})
> > +add_compile_definitions(FALLBACK_RUNTIME_PREFIX="${FALLBACK_RUNTIME_PREFIX}")
> > +
> > +add_compile_definitions(PROCFS_EXECUTABLE_PATH="/proc/self/exe" HAVE_DEV_TTY )
>
> /proc/self/exe is Linux only, no?
>

> > +list(APPEND compat_SOURCES unix-socket.c)
> > +
> > +#header checks
> > +check_include_file(libgen.h HAVE_LIBGEN_H)
> > +if(NOT HAVE_LIBGEN_H)
> > +     add_compile_definitions(NO_LIBGEN_H)
> > +     list(APPEND compat_SOURCES compat/basename.c)
> > +endif()
> > +
> > +check_include_file(sys/sysinfo.h HAVE_SYSINFO)
> > +if(HAVE_SYSINFO)
> > +     add_compile_definitions(HAVE_SYSINFO)
> > +endif()
> > +
> > +check_c_source_compiles("
> > +#include <alloca.h>
> > +int
> > +main ()
> > +{
> > +char *p = (char *) alloca (2 * sizeof (int));
> > +     if (p) return 0;
> > +     return 0;
>
> All code path will return 0?
>

> > +}"
> > +HAVE_ALLOCA_H)
> > +if(HAVE_ALLOCA_H)
> > +     add_compile_definitions(HAVE_ALLOCA_H)
> > +endif()
> > +
> > +check_include_file(strings.h HAVE_STRINGS_H)
> > +if(HAVE_STRINGS_H)
> > +     add_compile_definitions(HAVE_STRINGS_H)
> > +endif()
> > +
> > +check_include_file(sys/select.h HAVE_SYS_SELECT_H)
> > +if(NOT HAVE_SYS_SELECT_H)
> > +     add_compile_definitions(NO_SYS_SELECT_H)
> > +endif()
> > +
> > +check_include_file(sys/poll.h HAVE_SYS_POLL_H)
> > +if(NOT HAVE_SYS_POLL_H)
> > +     add_compile_definitions(NO_SYS_POLL_H)
> > +endif()
> > +
> > +check_include_file(poll.h HAVE_POLL_H)
>
> POSIX defined poll.h instead of sys/poll.h
>
> > +if(NOT HAVE_POLL_H)
> > +     add_compile_definitions(NO_POLL_H)
> > +endif()
> > +
> > +check_include_file(inttypes.h HAVE_INTTYPES_H)
> > +if(NOT HAVE_INTTYPES_H)
> > +     add_compile_definitions(NO_INTTYPES_H)
> > +endif()
> > +
> > +check_include_file(paths.h HAVE_PATHS_H)
> > +if(HAVE_PATHS_H)
> > +     add_compile_definitions(HAVE_PATHS_H)
> > +endif()
> > +
> > +#function checks
> > +set(function_checks
> > +     strcasestr memmem strlcpy strtoimax strtoumax strtoull
> > +     setenv  mkdtemp poll pread  memmem unsetenv hstrerror)
> > +
> > +foreach(f ${function_checks})
> > +     string(TOUPPER ${f} uf)
> > +     check_function_exists(${f} HAVE_${uf})
> > +     if(NOT HAVE_${uf})
> > +             add_compile_definitions(NO_${uf})
> > +     endif()
> > +endforeach()
> > +
> > +if(NOT HAVE_POLL_H OR NOT HAVE_SYS_POLL_H OR NOT HAVE_POLL)
> > +     include_directories(compat/poll)
> > +     add_compile_definitions(NO_POLL)
> > +     list(APPEND compat_SOURCES compat/poll/poll.c)
> > +endif()
> > +
> > +if(NOT HAVE_STRCASESTR)
> > +     list(APPEND compat_SOURCES compat/strcasestr.c)
> > +endif()
> > +
> > +if(NOT HAVE_STRLCPY)
> > +     list(APPEND compat_SOURCES compat/strlcpy.c)
> > +endif()
> > +
> > +if(NOT HAVE_STRTOUMAX)
> > +     list(APPEND compat_SOURCES compat/strtoumax.c compat/strtoimax.c)
> > +endif()
> > +
> > +if(NOT HAVE_SETENV)
> > +     list(APPEND compat_SOURCES compat/setenv.c)
> > +endif()
> > +
> > +if(NOT HAVE_MKDTEMP)
> > +     list(APPEND compat_SOURCES compat/mkdtemp.c)
> > +endif()
> > +
> > +if(NOT HAVE_PREAD)
> > +     list(APPEND compat_SOURCES compat/pread.c)
> > +endif()
> > +
> > +if(NOT HAVE_MEMMEM)
> > +     list(APPEND compat_SOURCES compat/memmem.c)
> > +endif()
> > +
> > +if(NOT WIN32)
> > +     if(NOT HAVE_UNSETENV)
> > +             list(APPEND compat_SOURCES compat/unsetenv.c)
> > +     endif()
> > +
> > +     if(NOT HAVE_HSTRERROR)
> > +             list(APPEND compat_SOURCES compat/hstrerror.c)
> > +     endif()
> > +endif()
> > +
> > +check_function_exists(getdelim HAVE_GETDELIM)
> > +if(HAVE_GETDELIM)
> > +     add_compile_definitions(HAVE_GETDELIM)
> > +endif()
> > +
> > +check_function_exists(clock_gettime HAVE_CLOCK_GETTIME)
> > +check_symbol_exists(CLOCK_MONOTONIC "time.h" HAVE_CLOCK_MONOTONIC)
> > +if(HAVE_CLOCK_GETTIME)
> > +     add_compile_definitions(HAVE_CLOCK_GETTIME)
> > +endif()
> > +if(HAVE_CLOCK_MONOTONIC)
> > +     add_compile_definitions(HAVE_CLOCK_MONOTONIC)
> > +endif()
> > +
> > +
> > +#compile checks
> > +check_c_source_runs("
> > +#include<stdio.h>
> > +#include<stdarg.h>
> > +#include<string.h>
> > +#include<stdlib.h>
> > +int test_vsnprintf(char *str, size_t maxsize, const char *format, ...)
> > +{
> > +     int ret;
> > +     va_list ap;
> > +
> > +     va_start(ap, format);
> > +     ret = vsnprintf(str, maxsize, format, ap);
> > +     va_end(ap);
> > +     return ret;
> > +}
> > +
> > +int
> > +main ()
> > +{
> > +     char buf[6];
> > +     if (test_vsnprintf(buf, 3, \"%s\", \"12345\") != 5
> > +             || strcmp(buf, \"12\")) return 1;
> > +     if (snprintf(buf, 3, \"%s\", \"12345\") != 5
> > +             || strcmp(buf, \"12\")) return 1;
> > +
> > +     return 0;
> > +}"
> > +SNPRINTF_OK)
> > +if(NOT SNPRINTF_OK)
> > +     add_compile_definitions(SNPRINTF_RETURNS_BOGUS)
> > +     list(APPEND compat_SOURCES compat/snprintf.c)
> > +endif()
> > +
> > +check_c_source_runs("
> > +#include<stdio.h>
> > +int
> > +main ()
> > +{
> > +     FILE *f = fopen(\".\", \"r\");
> > +     return f != NULL;
> > +
> > +     return 0;
> > +}"
> > +FREAD_READS_DIRECTORIES_NO)
> > +if(NOT FREAD_READS_DIRECTORIES_NO)
> > +     add_compile_definitions(FREAD_READS_DIRECTORIES)
> > +     list(APPEND compat_SOURCES compat/fopen.c)
> > +endif()
> > +
> > +check_c_source_compiles("
> > +#include <regex.h>
> > +#ifndef REG_STARTEND
> > +#error oops we dont have it
> > +#endif
> > +int main(){return 0;}"
> > +HAVE_REGEX)
> > +if(NOT HAVE_REGEX)
> > +     include_directories(compat/regex )
> > +     list(APPEND compat_SOURCES compat/regex/regex.c )
> > +     add_compile_definitions(NO_REGEX NO_MBSUPPORT GAWK)
> > +endif()
> > +
> > +
> > +check_c_source_compiles("
> > +#include <stddef.h>
> > +#include <sys/types.h>
> > +#include <sys/sysctl.h>
> > +
> > +int
> > +main ()
> > +{
> > +     int val, mib[2];
> > +     size_t len;
> > +
> > +     mib[0] = CTL_HW;
> > +     mib[1] = 1;
> > +     len = sizeof(val);
> > +     return sysctl(mib, 2, &val, &len, NULL, 0) ? 1 : 0;
> > +
> > +     return 0;
> > +}"
> > +HAVE_BSD_SYSCTL)
> > +if(HAVE_BSD_SYSCTL)
> > +     add_compile_definitions(HAVE_BSD_SYSCTL)
> > +endif()
> > +
> > +#programs
> > +set(PROGRAMS_BUILT
> > +     git git-bugreport git-credential-store git-daemon git-fast-import git-http-backend git-sh-i18n--envsubst
> > +     git-shell git-remote-testsvn git-credential-cache git-credential-cache--daemon)
> > +
> > +if(NOT CURL_FOUND)
> > +     list(APPEND excluded_progs git-http-fetch git-http-push)
> > +     add_compile_definitions(NO_CURL)
> > +     message(WARNING "git-http-push and git-http-fetch will not be built")
> > +else()
> > +     list(APPEND PROGRAMS_BUILT git-http-fetch git-http-push git-imap-send git-remote-http)
> > +     if(CURL_VERSION_STRING VERSION_GREATER_EQUAL 7.34.0)
> > +             add_compile_definitions(USE_CURL_FOR_IMAP_SEND)
> > +     endif()
> > +endif()
> > +
> > +if(NOT EXPAT_FOUND)
> > +     list(APPEND excluded_progs git-http-push)
> > +     add_compile_definitions(NO_EXPAT)
> > +else()
> > +     list(APPEND PROGRAMS_BUILT git-http-push)
> > +     if(EXPAT_VERSION_STRING VERSION_LESS_EQUAL 1.2)
> > +             add_compile_definitions(EXPAT_NEEDS_XMLPARSE_H)
> > +     endif()
> > +endif()
> > +
> > +list(REMOVE_DUPLICATES excluded_progs)
> > +list(REMOVE_DUPLICATES PROGRAMS_BUILT)
> > +
> > +
> > +foreach(p ${excluded_progs})
> > +     list(APPEND EXCLUSION_PROGS --exclude-program ${p} )
> > +endforeach()
> > +
> > +#for comparing null values
> > +list(APPEND EXCLUSION_PROGS empty)
> > +set(EXCLUSION_PROGS_CACHE ${EXCLUSION_PROGS} CACHE STRING "Programs not built" FORCE)
> > +
> > +if(NOT EXISTS ${CMAKE_SOURCE_DIR}/command-list.h OR NOT EXCLUSION_PROGS_CACHE STREQUAL EXCLUSION_PROGS)
> > +     list(REMOVE_ITEM EXCLUSION_PROGS empty)
> > +     message("Generating command-list.h")
> > +     execute_process(COMMAND ${SH_EXE} ${CMAKE_SOURCE_DIR}/generate-cmdlist.sh ${EXCLUSION_PROGS} command-list.txt
> > +                     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
> > +                     OUTPUT_FILE ${CMAKE_SOURCE_DIR}/command-list.h)
> > +endif()
> > +
> > +if(NOT EXISTS ${CMAKE_SOURCE_DIR}/config-list.h)
> > +     message("Generating config-list.h")
> > +     execute_process(COMMAND ${SH_EXE} ${CMAKE_SOURCE_DIR}/generate-configlist.sh
> > +                     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
> > +                     OUTPUT_FILE ${CMAKE_SOURCE_DIR}/config-list.h)
> > +endif()
> > +
> > +
> > +#build
> > +set(libgit_SOURCES
> > +     abspath.c add-interactive.c add-patch.c advice.c alias.c
> > +     alloc.c apply.c archive.c archive-tar.c archive-zip.c argv-array.c
> > +     attr.c base85.c bisect.c blame.c blob.c bloom.c branch.c bulk-checkin.c
> > +     bundle.c cache-tree.c chdir-notify.c checkout.c color.c column.c
> > +     combine-diff.c commit.c commit-graph.c commit-reach.c compat/obstack.c
> > +     compat/terminal.c config.c connect.c connected.c convert.c copy.c credential.c
> > +     csum-file.c ctype.c date.c decorate.c delta-islands.c diffcore-break.c
> > +     diffcore-delta.c diffcore-order.c diffcore-pickaxe.c diffcore-rename.c
> > +     diff-delta.c diff-lib.c diff-no-index.c diff.c dir.c dir-iterator.c editor.c
> > +     entry.c environment.c ewah/bitmap.c ewah/ewah_bitmap.c ewah/ewah_io.c
> > +     ewah/ewah_rlw.c exec-cmd.c fetch-negotiator.c fetch-pack.c fmt-merge-msg.c fsck.c fsmonitor.c
> > +     gettext.c gpg-interface.c graph.c grep.c hashmap.c linear-assignment.c help.c hex.c
> > +     ident.c interdiff.c json-writer.c kwset.c levenshtein.c line-log.c line-range.c list-objects.c
> > +     list-objects-filter.c list-objects-filter-options.c ll-merge.c lockfile.c
> > +     log-tree.c ls-refs.c mailinfo.c mailmap.c match-trees.c mem-pool.c merge.c merge-blobs.c
> > +     merge-recursive.c mergesort.c midx.c name-hash.c negotiator/default.c
> > +     negotiator/skipping.c notes.c notes-cache.c notes-merge.c notes-utils.c object.c oidmap.c
> > +     oidset.c oid-array.c packfile.c pack-bitmap.c pack-bitmap-write.c pack-check.c pack-objects.c
> > +     pack-revindex.c pack-write.c pager.c parse-options.c parse-options-cb.c patch-delta.c
> > +     patch-ids.c path.c pathspec.c pkt-line.c preload-index.c pretty.c prio-queue.c progress.c
> > +     promisor-remote.c prompt.c protocol.c prune-packed.c quote.c range-diff.c reachable.c read-cache.c rebase.c
> > +     rebase-interactive.c reflog-walk.c refs.c refs/files-backend.c refs/iterator.c
> > +     refs/packed-backend.c refs/ref-cache.c refspec.c ref-filter.c remote.c replace-object.c
> > +     repo-settings.c repository.c rerere.c reset.c resolve-undo.c revision.c run-command.c
> > +     send-pack.c sequencer.c serve.c server-info.c setup.c sha1-lookup.c
> > +     sha1-file.c sha1-name.c shallow.c sideband.c sigchain.c split-index.c
> > +     stable-qsort.c strbuf.c streaming.c string-list.c submodule.c submodule-config.c
> > +     sub-process.c symlinks.c tag.c tempfile.c thread-utils.c tmp-objdir.c
> > +     trace.c trace2.c trace2/tr2_cfg.c trace2/tr2_cmd_name.c trace2/tr2_dst.c
> > +     trace2/tr2_sid.c trace2/tr2_sysenv.c trace2/tr2_tbuf.c trace2/tr2_tgt_event.c
> > +     trace2/tr2_tgt_normal.c trace2/tr2_tgt_perf.c trace2/tr2_tls.c trailer.c transport.c
> > +     transport-helper.c tree-diff.c tree.c tree-walk.c unpack-trees.c upload-pack.c url.c
> > +     urlmatch.c usage.c userdiff.c utf8.c varint.c version.c versioncmp.c walker.c wildmatch.c
> > +     worktree.c wrapper.c write-or-die.c ws.c wt-status.c xdiff-interface.c
> > +     zlib.c)
> > +
> > +add_library(libgit ${libgit_SOURCES} ${compat_SOURCES})
> > +
> > +set(libxdiff_SOURCES
> > +     xdiff/xdiffi.c xdiff/xprepare.c xdiff/xutils.c xdiff/xemit.c
> > +     xdiff/xmerge.c xdiff/xpatience.c xdiff/xhistogram.c)
> > +add_library(xdiff STATIC ${libxdiff_SOURCES})
> > +
> > +set(libvcs-svn_SOURCES
> > +     vcs-svn/line_buffer.c vcs-svn/sliding_window.c vcs-svn/fast_export.c
> > +     vcs-svn/svndiff.c vcs-svn/svndump.c)
> > +add_library(vcs-svn STATIC ${libvcs-svn_SOURCES})
> > +
> > +#link all required libraries to common-main
> > +add_library(common-main OBJECT common-main.c)
> > +target_link_libraries(common-main libgit xdiff ${ZLIB_LIBRARIES} pthread rt)
> > +if(Intl_FOUND)
> > +     target_link_libraries(common-main ${Intl_LIBRARIES})
> > +endif()
> > +if(Iconv_FOUND)
> > +     target_link_libraries(common-main ${Iconv_LIBRARIES})
> > +endif()
> > +
> > +
> > +set(git_SOURCES
> > +     builtin/add.c builtin/am.c builtin/annotate.c builtin/apply.c
> > +     builtin/archive.c builtin/bisect--helper.c builtin/blame.c
> > +     builtin/branch.c builtin/bundle.c builtin/cat-file.c builtin/check-attr.c
> > +     builtin/check-ignore.c builtin/check-mailmap.c builtin/check-ref-format.c
> > +     builtin/checkout-index.c builtin/checkout.c builtin/clean.c
> > +     builtin/clone.c builtin/column.c builtin/commit-tree.c
> > +     builtin/commit.c builtin/commit-graph.c builtin/config.c
> > +     builtin/count-objects.c builtin/credential.c builtin/describe.c
> > +     builtin/diff-files.c builtin/diff-index.c builtin/diff-tree.c
> > +     builtin/diff.c builtin/difftool.c builtin/env--helper.c
> > +     builtin/fast-export.c builtin/fetch-pack.c builtin/fetch.c builtin/fmt-merge-msg.c
> > +     builtin/for-each-ref.c builtin/fsck.c builtin/gc.c
> > +     builtin/get-tar-commit-id.c builtin/grep.c builtin/hash-object.c
> > +     builtin/help.c builtin/index-pack.c builtin/init-db.c
> > +     builtin/interpret-trailers.c builtin/log.c builtin/ls-files.c
> > +     builtin/ls-remote.c builtin/ls-tree.c builtin/mailinfo.c builtin/mailsplit.c
> > +     builtin/merge.c builtin/merge-base.c builtin/merge-file.c builtin/merge-index.c
> > +     builtin/merge-ours.c builtin/merge-recursive.c builtin/merge-tree.c
> > +     builtin/mktag.c builtin/mktree.c builtin/multi-pack-index.c builtin/mv.c
> > +     builtin/name-rev.c builtin/notes.c builtin/pack-objects.c builtin/pack-redundant.c
> > +     builtin/pack-refs.c builtin/patch-id.c builtin/prune-packed.c builtin/prune.c
> > +     builtin/pull.c builtin/push.c builtin/range-diff.c builtin/read-tree.c
> > +     builtin/rebase.c builtin/receive-pack.c builtin/reflog.c builtin/remote.c
> > +     builtin/remote-ext.c builtin/remote-fd.c builtin/repack.c builtin/replace.c
> > +     builtin/rerere.c builtin/reset.c builtin/rev-list.c builtin/rev-parse.c
> > +     builtin/revert.c builtin/rm.c builtin/send-pack.c builtin/shortlog.c
> > +     builtin/show-branch.c builtin/show-index.c builtin/show-ref.c
> > +     builtin/sparse-checkout.c builtin/stash.c builtin/stripspace.c
> > +     builtin/submodule--helper.c builtin/symbolic-ref.c builtin/tag.c
> > +     builtin/unpack-file.c builtin/unpack-objects.c builtin/update-index.c
> > +     builtin/update-ref.c builtin/update-server-info.c builtin/upload-archive.c
> > +     builtin/upload-pack.c builtin/var.c builtin/verify-commit.c builtin/verify-pack.c
> > +     builtin/verify-tag.c builtin/worktree.c builtin/write-tree.c)
> > +
> > +add_executable(git git.c ${git_SOURCES})
> > +target_link_libraries(git common-main )
> > +
> > +add_executable(git-bugreport bugreport.c)
> > +target_link_libraries(git-bugreport common-main)
> > +
> > +add_executable(git-credential-store credential-store.c)
> > +target_link_libraries(git-credential-store common-main)
> > +
> > +add_executable(git-daemon daemon.c)
> > +target_link_libraries(git-daemon common-main)
> > +
> > +add_executable(git-fast-import fast-import.c)
> > +target_link_libraries(git-fast-import common-main)
> > +
> > +add_executable(git-http-backend http-backend.c)
> > +target_link_libraries(git-http-backend common-main)
> > +
> > +add_executable(git-sh-i18n--envsubst sh-i18n--envsubst.c)
> > +target_link_libraries(git-sh-i18n--envsubst common-main)
> > +
> > +add_executable(git-shell shell.c)
> > +target_link_libraries(git-shell common-main)
> > +
> > +if(CURL_FOUND)
> > +     add_library(http_obj OBJECT http.c)
> > +
> > +     add_executable(git-imap-send imap-send.c)
> > +     target_link_libraries(git-imap-send http_obj common-main ${CURL_LIBRARIES})
> > +
> > +     add_executable(git-http-fetch http-walker.c http-fetch.c)
> > +     target_link_libraries(git-http-fetch http_obj common-main ${CURL_LIBRARIES})
> > +
> > +     add_executable(git-remote-http http-walker.c remote-curl.c)
> > +     target_link_libraries(git-remote-http http_obj common-main ${CURL_LIBRARIES} )
> > +
> > +     if(EXPAT_FOUND)
> > +             add_executable(git-http-push http-push.c)
> > +             target_link_libraries(git-http-push http_obj common-main ${CURL_LIBRARIES} ${EXPAT_LIBRARIES})
> > +     endif()
> > +endif()
> > +
> > +add_executable(git-remote-testsvn remote-testsvn.c)
> > +target_link_libraries(git-remote-testsvn common-main vcs-svn)
> > +
> > +add_executable(git-credential-cache credential-cache.c)
> > +target_link_libraries(git-credential-cache common-main)
> > +
> > +add_executable(git-credential-cache--daemon credential-cache--daemon.c)
> > +target_link_libraries(git-credential-cache--daemon common-main)
> > +
> > +
> > +set(git_builtin_extra
> > +     cherry cherry-pick format-patch fsck-objects
> > +     init merge-subtree restore show
> > +     stage status switch whatchanged)
> > +
> > +#Creating hardlinks
> > +foreach(s ${git_SOURCES} ${git_builtin_extra})
> > +     string(REPLACE "builtin/" "" s ${s})
> > +     string(REPLACE ".c" "" s ${s})
> > +     file(APPEND ${CMAKE_BINARY_DIR}/CreateLinks.cmake "file(CREATE_LINK git git-${s})\n")
> > +     list(APPEND git_links ${CMAKE_BINARY_DIR}/git-${s})
> > +endforeach()
> > +
> > +if(CURL_FOUND)
> > +     set(remote_exes
> > +             git-remote-https git-remote-ftp git-remote-ftps)
> > +     foreach(s ${remote_exes})
> > +             file(APPEND ${CMAKE_BINARY_DIR}/CreateLinks.cmake "file(CREATE_LINK git-remote-http ${s})\n")
> > +             list(APPEND git_http_links ${CMAKE_BINARY_DIR}/${s})
> > +     endforeach()
> > +endif()
> > +
> > +add_custom_command(OUTPUT ${git_links} ${git_http_links}
> > +             COMMAND ${CMAKE_COMMAND} -P ${CMAKE_BINARY_DIR}/CreateLinks.cmake
> > +             DEPENDS git git-remote-http)
> > +add_custom_target(git-links ALL DEPENDS ${git_links} ${git_http_links})
> > \ No newline at end of file
>
> No new line at end of line always leave a bad taste in my mount!
>
>
> --
> Danh

> > > +find_package(EXPAT)
> > > +find_package(Iconv)
> > > +find_package(Intl)
> > > +
> >
> > > +if(NOT Intl_FOUND)
> > > +     add_compile_definitions(NO_GETTEXT)
> >
> > find_package(Gettext)?
> >
> 
> find_package(Gettext) does not define libintl and libintl.h.
> If NO_GETTEXT is not defined, it means that libintl.h is present.
> So, we use find_package(Intl) for libintl

> 
> > > +     if(NOT Iconv_FOUND)
> > > +             add_compile_definitions(NO_ICONV)
> > > +     endif()
> > > +endif()
> >
> > ICONV_OMITS_BOM?
> >
> 
> Forgot about this, will add it.

> > > +
> > > +include_directories(SYSTEM ${ZLIB_INCLUDE_DIRS})
> > > +if(CURL_FOUND)
> > > +     include_directories(SYSTEM ${CURL_INCLUDE_DIRS})
> > > +endif()
> > > +if(EXPAT_FOUND)
> > > +     include_directories(SYSTEM ${EXPAT_INCLUDE_DIRS})
> > > +endif()
> > > +if(Iconv_FOUND)
> > > +     include_directories(SYSTEM ${Iconv_INCLUDE_DIRS})
> > > +endif()
> > > +if(Intl_FOUND)
> > > +     include_directories(SYSTEM ${Intl_INCLUDE_DIRS})
> > > +endif()
> > > +
> > > +find_program(SH_EXE sh)
> >
> > We want to find usable sh, not just sh, no?
> >
> > It's matter on Solaris, HP-UX
> >
> 
> How do I check for this, can you help?

> 
> > > +
> > > +#default behaviour
> > > +include_directories(${CMAKE_SOURCE_DIR})
> > > +add_compile_definitions(GIT_HOST_CPU="${CMAKE_SYSTEM_PROCESSOR}")
> > > +add_compile_definitions(SHA256_BLK INTERNAL_QSORT RUNTIME_PREFIX)
> > > +add_compile_definitions(NO_OPENSSL SHA1_DC SHA1DC_NO_STANDARD_INCLUDES
> > > +                     SHA1DC_INIT_SAFE_HASH_DEFAULT=0
> > > +                     SHA1DC_CUSTOM_INCLUDE_SHA1_C="cache.h"
> > > +                     SHA1DC_CUSTOM_INCLUDE_UBC_CHECK_C="git-compat-util.h" )
> > > +list(APPEND compat_SOURCES sha1dc_git.c sha1dc/sha1.c sha1dc/ubc_check.c block-sha1/sha1.c sha256/block/sha256.c compat/qsort_s.c)
> > > +
> > > +
> > > +add_compile_definitions(PAGER_ENV="LESS=FRX LV=-c"
> > > +                     ETC_GITATTRIBUTES="etc/gitattributes"
> > > +                     ETC_GITCONFIG="etc/gitconfig"
> > > +                     GIT_EXEC_PATH="libexec/git-core"
> > > +                     GIT_LOCALE_PATH="share/locale"
> > > +                     GIT_MAN_PATH="share/man"
> > > +                     GIT_INFO_PATH="share/info"
> > > +                     GIT_HTML_PATH="share/doc/git-doc"
> > > +                     DEFAULT_HELP_FORMAT="html"
> > > +                     DEFAULT_GIT_TEMPLATE_DIR="share/git-core/templates"
> > > +                     GIT_VERSION="${PROJECT_VERSION}.GIT"
> > > +                     GIT_USER_AGENT="git/${PROJECT_VERSION}.GIT"
> > > +                     BINDIR="bin"
> > > +                     GIT_BUILT_FROM_COMMIT="")
> >
> > I wish I could verify this.
> > Have you check this part on a default build system for a Linux distro,
> > FreeBSD? For things started with "etc/"
> >
> 
> These are the values I got when I looked at the build logs from the
> Makefile (make -n) in Linux and Windows.
> Don't know about FreeBSD

> 
> > > +
> > > +set(FALLBACK_RUNTIME_PREFIX /home/$ENV{USER})
> > > +add_compile_definitions(FALLBACK_RUNTIME_PREFIX="${FALLBACK_RUNTIME_PREFIX}")
> > > +
> > > +add_compile_definitions(PROCFS_EXECUTABLE_PATH="/proc/self/exe" HAVE_DEV_TTY )
> >
> > /proc/self/exe is Linux only, no?
> >
> 
> Yes, it is. This first patch only supports Linux build.
> 
> > > +list(APPEND compat_SOURCES unix-socket.c)
> > > +
> > > +#header checks
> > > +check_include_file(libgen.h HAVE_LIBGEN_H)
> > > +if(NOT HAVE_LIBGEN_H)
> > > +     add_compile_definitions(NO_LIBGEN_H)
> > > +     list(APPEND compat_SOURCES compat/basename.c)
> > > +endif()
> > > +
> > > +check_include_file(sys/sysinfo.h HAVE_SYSINFO)
> > > +if(HAVE_SYSINFO)
> > > +     add_compile_definitions(HAVE_SYSINFO)
> > > +endif()
> > > +
> > > +check_c_source_compiles("
> > > +#include <alloca.h>
> > > +int
> > > +main ()
> > > +{
> > > +char *p = (char *) alloca (2 * sizeof (int));
> > > +     if (p) return 0;
> > > +     return 0;
> >
> > All code path will return 0?
> >
> 
> This check is for a working alloca.h.
> Some systems define alloca in malloc.h (Windows)

> 
> > > +}"
> > > +HAVE_ALLOCA_H)
> > > +if(HAVE_ALLOCA_H)
> > > +     add_compile_definitions(HAVE_ALLOCA_H)
> > > +endif()
> > > +
> > > +
> > > +if(CURL_FOUND)
> > > +     set(remote_exes
> > > +             git-remote-https git-remote-ftp git-remote-ftps)
> > > +     foreach(s ${remote_exes})
> > > +             file(APPEND ${CMAKE_BINARY_DIR}/CreateLinks.cmake "file(CREATE_LINK git-remote-http ${s})\n")

> > > +             list(APPEND git_http_links ${CMAKE_BINARY_DIR}/${s})
> > > +     endforeach()
> > > +endif()
> > > +
> > > +add_custom_command(OUTPUT ${git_links} ${git_http_links}
> > > +             COMMAND ${CMAKE_COMMAND} -P ${CMAKE_BINARY_DIR}/CreateLinks.cmake
> > > +             DEPENDS git git-remote-http)
> > > +add_custom_target(git-links ALL DEPENDS ${git_links} ${git_http_links})
> > > \ No newline at end of file
> >
> > No new line at end of line always leave a bad taste in my mount!
> >

>
> On 2020-04-25 02:36:12+0530, Sibi Siddharthan <sibisiddharthan.github@gmail.com> wrote:
> > Yes it does,
> > all you have to do is -DZLIB_ROOT=/path/to/zlib/root
>
> OK, I need to learn this syntax
>
> > > > +find_package(EXPAT)
> > > > +find_package(Iconv)
> > > > +find_package(Intl)
> > > > +
> > >
> > > > +if(NOT Intl_FOUND)
> > > > +     add_compile_definitions(NO_GETTEXT)
> > >
> > > find_package(Gettext)?
> > >
> >
> > find_package(Gettext) does not define libintl and libintl.h.
> > If NO_GETTEXT is not defined, it means that libintl.h is present.
> > So, we use find_package(Intl) for libintl
>
> People do weird things.
>
> But, I bet that a lot of people have system that have libintl.h
> installed, but they don't install gettext tools. ;-)
>
> Anyway, can I override NO_GETTEXT from command line?
>
> Let's say, I want to bootstrap a new distro?
> In the boostrap step, I don't want to build any i18n things,
> because the bootstrap package will be thrown away and rebuild again.
> I don't want to waste time on building such translation things.
>

> >
> > > > +     if(NOT Iconv_FOUND)
> > > > +             add_compile_definitions(NO_ICONV)
> > > > +     endif()
> > > > +endif()
> > >
> > > ICONV_OMITS_BOM?
> > >
> >
> > Forgot about this, will add it.
>
> Thanks, my platform relies on this definition!
>
> > > > +
> > > > +include_directories(SYSTEM ${ZLIB_INCLUDE_DIRS})
> > > > +if(CURL_FOUND)
> > > > +     include_directories(SYSTEM ${CURL_INCLUDE_DIRS})
> > > > +endif()
> > > > +if(EXPAT_FOUND)
> > > > +     include_directories(SYSTEM ${EXPAT_INCLUDE_DIRS})
> > > > +endif()
> > > > +if(Iconv_FOUND)
> > > > +     include_directories(SYSTEM ${Iconv_INCLUDE_DIRS})
> > > > +endif()
> > > > +if(Intl_FOUND)
> > > > +     include_directories(SYSTEM ${Intl_INCLUDE_DIRS})
> > > > +endif()
> > > > +
> > > > +find_program(SH_EXE sh)
> > >
> > > We want to find usable sh, not just sh, no?
> > >
> > > It's matter on Solaris, HP-UX
> > >
> >
> > How do I check for this, can you help?
>
> Sorry, Please ask someone else, check Makefile to see who fixed build
> for Solaris and HP-UX.
>
> > Also, the script is not supported on Solaris and HP-UX.
>
> If Solaris or HP-UX is out of equation,
> I'll just write: SH_EXE=/bin/sh ;-)
>
>

> >
> > > > +
> > > > +#default behaviour
> > > > +include_directories(${CMAKE_SOURCE_DIR})
> > > > +add_compile_definitions(GIT_HOST_CPU="${CMAKE_SYSTEM_PROCESSOR}")
> > > > +add_compile_definitions(SHA256_BLK INTERNAL_QSORT RUNTIME_PREFIX)
> > > > +add_compile_definitions(NO_OPENSSL SHA1_DC SHA1DC_NO_STANDARD_INCLUDES
> > > > +                     SHA1DC_INIT_SAFE_HASH_DEFAULT=0
> > > > +                     SHA1DC_CUSTOM_INCLUDE_SHA1_C="cache.h"
> > > > +                     SHA1DC_CUSTOM_INCLUDE_UBC_CHECK_C="git-compat-util.h" )
> > > > +list(APPEND compat_SOURCES sha1dc_git.c sha1dc/sha1.c sha1dc/ubc_check.c block-sha1/sha1.c sha256/block/sha256.c compat/qsort_s.c)
> > > > +
> > > > +
> > > > +add_compile_definitions(PAGER_ENV="LESS=FRX LV=-c"
> > > > +                     ETC_GITATTRIBUTES="etc/gitattributes"
> > > > +                     ETC_GITCONFIG="etc/gitconfig"
> > > > +                     GIT_EXEC_PATH="libexec/git-core"
> > > > +                     GIT_LOCALE_PATH="share/locale"
> > > > +                     GIT_MAN_PATH="share/man"
> > > > +                     GIT_INFO_PATH="share/info"
> > > > +                     GIT_HTML_PATH="share/doc/git-doc"
> > > > +                     DEFAULT_HELP_FORMAT="html"
> > > > +                     DEFAULT_GIT_TEMPLATE_DIR="share/git-core/templates"
> > > > +                     GIT_VERSION="${PROJECT_VERSION}.GIT"
> > > > +                     GIT_USER_AGENT="git/${PROJECT_VERSION}.GIT"
> > > > +                     BINDIR="bin"
> > > > +                     GIT_BUILT_FROM_COMMIT="")
> > >
> > > I wish I could verify this.
> > > Have you check this part on a default build system for a Linux distro,
> > > FreeBSD? For things started with "etc/"
> > >
> >
> > These are the values I got when I looked at the build logs from the
> > Makefile (make -n) in Linux and Windows.
> > Don't know about FreeBSD
>
> Linux will install configuration to /etc, Windows (by using msys),
> will also do that.
>
> *BSD port installs git with /usr/local prefix, and install
> configuration to /usr/local/etc
>

> >
> > > > +
> > > > +set(FALLBACK_RUNTIME_PREFIX /home/$ENV{USER})
> > > > +add_compile_definitions(FALLBACK_RUNTIME_PREFIX="${FALLBACK_RUNTIME_PREFIX}")
> > > > +
> > > > +add_compile_definitions(PROCFS_EXECUTABLE_PATH="/proc/self/exe" HAVE_DEV_TTY )
> > >
> > > /proc/self/exe is Linux only, no?
> > >
> >
> > Yes, it is. This first patch only supports Linux build.
> >
> > > > +list(APPEND compat_SOURCES unix-socket.c)
> > > > +
> > > > +#header checks
> > > > +check_include_file(libgen.h HAVE_LIBGEN_H)
> > > > +if(NOT HAVE_LIBGEN_H)
> > > > +     add_compile_definitions(NO_LIBGEN_H)
> > > > +     list(APPEND compat_SOURCES compat/basename.c)
> > > > +endif()
> > > > +
> > > > +check_include_file(sys/sysinfo.h HAVE_SYSINFO)
> > > > +if(HAVE_SYSINFO)
> > > > +     add_compile_definitions(HAVE_SYSINFO)
> > > > +endif()
> > > > +
> > > > +check_c_source_compiles("
> > > > +#include <alloca.h>
> > > > +int
> > > > +main ()
> > > > +{
> > > > +char *p = (char *) alloca (2 * sizeof (int));
> > > > +     if (p) return 0;
> > > > +     return 0;
> > >
> > > All code path will return 0?
> > >
> >
> > This check is for a working alloca.h.
> > Some systems define alloca in malloc.h (Windows)
>
> Does CMake have a macro for check function in which include files?
>

> >
> > > > +}"
> > > > +HAVE_ALLOCA_H)
> > > > +if(HAVE_ALLOCA_H)
> > > > +     add_compile_definitions(HAVE_ALLOCA_H)
> > > > +endif()
> > > > +
> > > > +
> > > > +if(CURL_FOUND)
> > > > +     set(remote_exes
> > > > +             git-remote-https git-remote-ftp git-remote-ftps)
> > > > +     foreach(s ${remote_exes})
> > > > +             file(APPEND ${CMAKE_BINARY_DIR}/CreateLinks.cmake "file(CREATE_LINK git-remote-http ${s})\n")
>
> Now, I looked at this again.
> I didn't see the creatation of CreateLinks.cmake anywhere!
>
> > > > +             list(APPEND git_http_links ${CMAKE_BINARY_DIR}/${s})
> > > > +     endforeach()
> > > > +endif()
> > > > +
> > > > +add_custom_command(OUTPUT ${git_links} ${git_http_links}
> > > > +             COMMAND ${CMAKE_COMMAND} -P ${CMAKE_BINARY_DIR}/CreateLinks.cmake
> > > > +             DEPENDS git git-remote-http)
> > > > +add_custom_target(git-links ALL DEPENDS ${git_links} ${git_http_links})
> > > > \ No newline at end of file
> > >
> > > No new line at end of line always leave a bad taste in my mount!
> > >
>
> --
> Danh

> diff --git a/CMakeLists.txt b/CMakeLists.txt
> new file mode 100644
> index 00000000000..73703bd321f
> --- /dev/null
> +++ b/CMakeLists.txt
> @@ -0,0 +1,528 @@
> +#
> +#	Copyright (c) 2020 Sibi Siddharthan
> +#
> +
> +cmake_minimum_required(VERSION 3.14)

> On 2020-04-24 at 04:01:30, Sibi Siddharthan via GitGitGadget wrote:
> > diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644
> > index 00000000000..73703bd321f
> > --- /dev/null
> > +++ b/CMakeLists.txt
> > @@ -0,0 +1,528 @@
> > +#
> > +#	Copyright (c) 2020 Sibi Siddharthan
> > +#
> > +
> > +cmake_minimum_required(VERSION 3.14)
> 
> I don't plan a full review of this series, but I wanted to point out that this
> version is newer than what's in Debian 10, so this isn't practically buildable on
> many systems.

> On April 25, 2020 1:08 PM, brian m. carlson Wrote:
>> On 2020-04-24 at 04:01:30, Sibi Siddharthan via GitGitGadget wrote:
>>> diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644
>>> index 00000000000..73703bd321f
>>> --- /dev/null
>>> +++ b/CMakeLists.txt
>>> @@ -0,0 +1,528 @@
>>> +#
>>> +#	Copyright (c) 2020 Sibi Siddharthan
>>> +#
>>> +
>>> +cmake_minimum_required(VERSION 3.14)
>> I don't plan a full review of this series, but I wanted to point out that this
>> version is newer than what's in Debian 10, so this isn't practically buildable on
>> many systems.
> I am unsure about this, but are non-git-foundation copyrights consistent GPL v2? Just asking for curiosity.
>

>
> On 2020-04-24 at 04:01:30, Sibi Siddharthan via GitGitGadget wrote:
> > diff --git a/CMakeLists.txt b/CMakeLists.txt
> > new file mode 100644
> > index 00000000000..73703bd321f
> > --- /dev/null
> > +++ b/CMakeLists.txt
> > @@ -0,0 +1,528 @@
> > +#
> > +#    Copyright (c) 2020 Sibi Siddharthan
> > +#
> > +
> > +cmake_minimum_required(VERSION 3.14)
>
> I don't plan a full review of this series, but I wanted to point out
> that this version is newer than what's in Debian 10, so this isn't
> practically buildable on many systems.
>
> If we wanted to add CMake support, even just for Linux and Windows, I'd
> want to see it functional on the latest versions of the major distros,
> at the very least.  Ideally it would function using the system packages
> on all security-supported versions of the major distros, since our
> Makefile does right now.

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> 
> This patch allows git to be tested when performin out of source builds.
> 
> This involves changing GIT_BUILD_DIR in t/test-lib.sh to point to the
> build directory. Also some miscellaneous copies from the source directory
> to the build directory.
> The copies are:
> t/chainlint.sed needed by a bunch of test scripts
> po/is.po needed by t0204-gettext-rencode-sanity
> mergetools/tkdiff needed by t7800-difftool
> contrib/completion/git-prompt.sh needed by t9903-bash-prompt
> contrib/completion/git-completion.bash needed by t9902-completion
> contrib/svn-fe/svnrdump_sim.py needed by t9020-remote-svn
> 
> NOTE: t/test-lib.sh is only modified when tests are run not during
> the build or configure.
> The trash directory is still srcdir/t
> 
> Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> ---
>  CMakeLists.txt | 19 +++++++++++++++++++
>  1 file changed, 19 insertions(+)
> 
> diff --git a/CMakeLists.txt b/CMakeLists.txt
> index 141ccefa559..29a23eb11f7 100644
> --- a/CMakeLists.txt
> +++ b/CMakeLists.txt
> @@ -812,6 +812,25 @@ file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_GETTEXT='${NO_GETTEXT}'\n"
>  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "RUNTIME_PREFIX='${RUNTIME_PREFIX}'\n")
>  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_PYTHON='${NO_PYTHON}'\n")
>  
> +#Make the tests work when building out of the source tree
> +if(NOT ${CMAKE_BINARY_DIR} STREQUAL ${CMAKE_SOURCE_DIR})

> +	#Setting the build directory in test-lib.sh before running tests
> +	file(WRITE ${CMAKE_BINARY_DIR}/CTestCustom.cmake
> +		"file(STRINGS ${CMAKE_SOURCE_DIR}/t/test-lib.sh GIT_BUILD_DIR_REPL REGEX \"GIT_BUILD_DIR=(.*)\")\n"
> +		"file(STRINGS ${CMAKE_SOURCE_DIR}/t/test-lib.sh content NEWLINE_CONSUME)\n"
> +		"string(REPLACE \"\${GIT_BUILD_DIR_REPL}\" \"GIT_BUILD_DIR=\\\"$TEST_DIRECTORY\\\"/../${BUILD_DIR_RELATIVE}\" content \"\${content}\")\n"
> +		"file(WRITE ${CMAKE_SOURCE_DIR}/t/test-lib.sh \${content})")
> +	#misc copies
> +	file(COPY ${CMAKE_SOURCE_DIR}/t/chainlint.sed DESTINATION ${CMAKE_BINARY_DIR}/t/)

> +	file(COPY ${CMAKE_SOURCE_DIR}/po/is.po DESTINATION ${CMAKE_BINARY_DIR}/po/)
> +	file(COPY ${CMAKE_SOURCE_DIR}/mergetools/tkdiff DESTINATION ${CMAKE_BINARY_DIR}/mergetools/)
> +	file(COPY ${CMAKE_SOURCE_DIR}/contrib/completion/git-prompt.sh DESTINATION ${CMAKE_BINARY_DIR}/contrib/completion/)
> +	file(COPY ${CMAKE_SOURCE_DIR}/contrib/completion/git-completion.bash DESTINATION ${CMAKE_BINARY_DIR}/contrib/completion/)
> +	file(COPY ${CMAKE_SOURCE_DIR}/contrib/svn-fe/svnrdump_sim.py DESTINATION ${CMAKE_BINARY_DIR}/contrib/svn-fe/)
> +endif()
> +
>  file(GLOB test_scipts "${CMAKE_SOURCE_DIR}/t/t[0-9]*.sh")

>
> On 2020-04-24 04:01:34+0000, Sibi Siddharthan via GitGitGadget <gitgitgadget@gmail.com> wrote:
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >
> > This patch allows git to be tested when performin out of source builds.
> >
> > This involves changing GIT_BUILD_DIR in t/test-lib.sh to point to the
> > build directory. Also some miscellaneous copies from the source directory
> > to the build directory.
> > The copies are:
> > t/chainlint.sed needed by a bunch of test scripts
> > po/is.po needed by t0204-gettext-rencode-sanity
> > mergetools/tkdiff needed by t7800-difftool
> > contrib/completion/git-prompt.sh needed by t9903-bash-prompt
> > contrib/completion/git-completion.bash needed by t9902-completion
> > contrib/svn-fe/svnrdump_sim.py needed by t9020-remote-svn
> >
> > NOTE: t/test-lib.sh is only modified when tests are run not during
> > the build or configure.
> > The trash directory is still srcdir/t
> >
> > Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > ---
> >  CMakeLists.txt | 19 +++++++++++++++++++
> >  1 file changed, 19 insertions(+)
> >
> > diff --git a/CMakeLists.txt b/CMakeLists.txt
> > index 141ccefa559..29a23eb11f7 100644
> > --- a/CMakeLists.txt
> > +++ b/CMakeLists.txt
> > @@ -812,6 +812,25 @@ file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_GETTEXT='${NO_GETTEXT}'\n"
> >  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "RUNTIME_PREFIX='${RUNTIME_PREFIX}'\n")
> >  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_PYTHON='${NO_PYTHON}'\n")
> >
> > +#Make the tests work when building out of the source tree
> > +if(NOT ${CMAKE_BINARY_DIR} STREQUAL ${CMAKE_SOURCE_DIR})
>
> IIRC, CMake recommends _NOT_ expand variable inside if()
> This very inconsistent recommendation of CMake (when should I use
> ${var} and when should I use var?) is one of reason I hate CMake
>

> > +     file(RELATIVE_PATH BUILD_DIR_RELATIVE ${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR}/CMakeCache.txt)
> > +     string(REPLACE "/CMakeCache.txt" "" BUILD_DIR_RELATIVE ${BUILD_DIR_RELATIVE})
>
> I don't know what is going on here!
>

> > +     #Setting the build directory in test-lib.sh before running tests
> > +     file(WRITE ${CMAKE_BINARY_DIR}/CTestCustom.cmake
> > +             "file(STRINGS ${CMAKE_SOURCE_DIR}/t/test-lib.sh GIT_BUILD_DIR_REPL REGEX \"GIT_BUILD_DIR=(.*)\")\n"
> > +             "file(STRINGS ${CMAKE_SOURCE_DIR}/t/test-lib.sh content NEWLINE_CONSUME)\n"
> > +             "string(REPLACE \"\${GIT_BUILD_DIR_REPL}\" \"GIT_BUILD_DIR=\\\"$TEST_DIRECTORY\\\"/../${BUILD_DIR_RELATIVE}\" content \"\${content}\")\n"
> > +             "file(WRITE ${CMAKE_SOURCE_DIR}/t/test-lib.sh \${content})")
> > +     #misc copies
> > +     file(COPY ${CMAKE_SOURCE_DIR}/t/chainlint.sed DESTINATION ${CMAKE_BINARY_DIR}/t/)
>
> So, some sed will be used in Windows without POSIX-like system,
> interesting!
>
> > +     file(COPY ${CMAKE_SOURCE_DIR}/po/is.po DESTINATION ${CMAKE_BINARY_DIR}/po/)
> > +     file(COPY ${CMAKE_SOURCE_DIR}/mergetools/tkdiff DESTINATION ${CMAKE_BINARY_DIR}/mergetools/)
> > +     file(COPY ${CMAKE_SOURCE_DIR}/contrib/completion/git-prompt.sh DESTINATION ${CMAKE_BINARY_DIR}/contrib/completion/)
> > +     file(COPY ${CMAKE_SOURCE_DIR}/contrib/completion/git-completion.bash DESTINATION ${CMAKE_BINARY_DIR}/contrib/completion/)
> > +     file(COPY ${CMAKE_SOURCE_DIR}/contrib/svn-fe/svnrdump_sim.py DESTINATION ${CMAKE_BINARY_DIR}/contrib/svn-fe/)
> > +endif()
> > +
> >  file(GLOB test_scipts "${CMAKE_SOURCE_DIR}/t/t[0-9]*.sh")
>
> Remember cmake won't be re-run if nothing was changed in CMakeList.txt
> If I only change some code, and I decided the change I make should be
> tested by a-new-and-independent-test-script.
> I need to re-run cmake manually! I don't like it, at all.
>

> > >  file(GLOB test_scipts "${CMAKE_SOURCE_DIR}/t/t[0-9]*.sh")
> >
> > Remember cmake won't be re-run if nothing was changed in CMakeList.txt
> > If I only change some code, and I decided the change I make should be
> > tested by a-new-and-independent-test-script.
> > I need to re-run cmake manually! I don't like it, at all.
> >
> 
> No you don't have re-run CMake.

> Note
>
> We do not recommend using GLOB to collect a list of source files
> from your source tree. If no CMakeLists.txt file changes when
> a source is added or removed then the generated build system cannot
> know when to ask CMake to regenerate. The CONFIGURE_DEPENDS flag may
> not work reliably on all generators, or if a new generator is added
> in the future that cannot support it, projects using it will be
> stuck. Even if CONFIGURE_DEPENDS works reliably, there is still
> a cost to perform the check on every rebuild. 

>
> On 2020-04-25 03:02:49+0530, Sibi Siddharthan <sibisiddharthan.github@gmail.com> wrote:
> > > >  file(GLOB test_scipts "${CMAKE_SOURCE_DIR}/t/t[0-9]*.sh")
> > >
> > > Remember cmake won't be re-run if nothing was changed in CMakeList.txt
> > > If I only change some code, and I decided the change I make should be
> > > tested by a-new-and-independent-test-script.
> > > I need to re-run cmake manually! I don't like it, at all.
> > >
> >
> > No you don't have re-run CMake.
>
> Yes, you have to re-run CMake.
> https://cmake.org/cmake/help/v3.14/command/file.html#glob
>
> > Note
> >
> > We do not recommend using GLOB to collect a list of source files
> > from your source tree. If no CMakeLists.txt file changes when
> > a source is added or removed then the generated build system cannot
> > know when to ask CMake to regenerate. The CONFIGURE_DEPENDS flag may
> > not work reliably on all generators, or if a new generator is added
> > in the future that cannot support it, projects using it will be
> > stuck. Even if CONFIGURE_DEPENDS works reliably, there is still
> > a cost to perform the check on every rebuild.
>
> * Run CMake now.
> * Don't touch anything
> * Create new test-script, let's say t9904-just-for-cmake.sh
>
> * Check if it's run or not, I bet the answer is not
>

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> 
> This patch adds support for Visual Studio and Clang builds
> 
> The minimum required version of CMake is upgraded to 3.15 because
> this version offers proper support for Clang builds on Windows.
> 
> Libintl is not searched for when building with Visual Studio or Clang
> because there is no binary compatible version available yet.
> 
> NOTE: In the link options invalidcontinue.obj has to be included.
> The reason for this is because by default, Windows calls abort()'s
> instead of setting errno=EINVAL when invalid arguments are passed to
> standard functions.
> This commit explains it in detail:
> 4b623d80f73528a632576990ca51e34c333d5dd6
> 
> On Windows the default generator is Visual Studio,so for Visual Studio
> builds do this:
> 
> cmake `relative-path-to-srcdir`
> 
> NOTE: Visual Studio generator is a multi config generator, which means
> that Debug and Release builds can be done on the same build directory.
> 
> For Clang builds do this:
> 
> On bash
> CC=Clang cmake `relative-path-to-srcdir` -G Ninja
> 		-DCMAKE_BUILD_TYPE=[Debug or Release]
> 
> On cmd
> set CC=Clang
> cmake `relative-path-to-srcdir` -G Ninja
> 		-DCMAKE_BUILD_TYPE=[Debug or Release]
> 
> Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> ---
>  CMakeLists.txt | 57 ++++++++++++++++++++++++++++++++++++++++----------
>  1 file changed, 46 insertions(+), 11 deletions(-)
> 
> diff --git a/CMakeLists.txt b/CMakeLists.txt
> index d9eb1060390..5ad3a2557f7 100644
> --- a/CMakeLists.txt
> +++ b/CMakeLists.txt
> @@ -2,7 +2,7 @@
>  #	Copyright (c) 2020 Sibi Siddharthan
>  #
>  
> -cmake_minimum_required(VERSION 3.14)
> +cmake_minimum_required(VERSION 3.15)

>  
>  #Parse GIT-VERSION-GEN to get the version
>  file(STRINGS ${CMAKE_SOURCE_DIR}/GIT-VERSION-GEN git_version REGEX "DEF_VER=v(.*)")
> @@ -32,8 +32,11 @@ find_package(ZLIB REQUIRED)
>  find_package(CURL)
>  find_package(EXPAT)
>  find_package(Iconv)
> -find_package(Intl)
>  
> +#Don't use libintl on Windows Visual Studio and Clang builds
> +if(NOT (WIN32 AND (CMAKE_C_COMPILER_ID STREQUAL "MSVC" OR CMAKE_C_COMPILER_ID STREQUAL "Clang")))
> +	find_package(Intl)
> +endif()
>  
>  if(NOT Intl_FOUND)
>  	add_compile_definitions(NO_GETTEXT)
> @@ -61,7 +64,7 @@ if(NOT SH_EXE)
>  	message(FATAL_ERROR "sh interpreter was not found in your path, please install one. On Windows you can get it from here https://gitforwindows.org/")
>  endif()
>  
> -if(WIN32)
> +if(WIN32 AND NOT MSVC)#not required for visual studio builds
>  	find_program(WINDRES_EXE windres)
>  	if(NOT WINDRES_EXE)
>  		message(FATAL_ERROR "Install windres on Windows for resource files")
> @@ -73,6 +76,13 @@ if(NOT MSGFMT_EXE)
>  	message(WARNING "Text Translations won't be build")
>  endif()
>  
> +#Force all visual studio outputs to CMAKE_BINARY_DIR
> +if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
> +	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR})
> +	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR})
> +	add_compile_options(/MP)
> +endif()
> +
>  #default behaviour
>  include_directories(${CMAKE_SOURCE_DIR})
>  add_compile_definitions(GIT_HOST_CPU="${CMAKE_SYSTEM_PROCESSOR}")
> @@ -110,6 +120,10 @@ endif()
>  
>  #Platform Specific
>  if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
> +	if(CMAKE_C_COMPILER_ID STREQUAL "MSVC" OR CMAKE_C_COMPILER_ID STREQUAL "Clang")
> +		include_directories(compat/vcbuild/include)
> +		add_compile_definitions(_CRT_SECURE_NO_WARNINGS _CRT_NONSTDC_NO_DEPRECATE)

>
> On 2020-04-24 04:01:36+0000, Sibi Siddharthan via GitGitGadget <gitgitgadget@gmail.com> wrote:
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >
> > This patch adds support for Visual Studio and Clang builds
> >
> > The minimum required version of CMake is upgraded to 3.15 because
> > this version offers proper support for Clang builds on Windows.
> >
> > Libintl is not searched for when building with Visual Studio or Clang
> > because there is no binary compatible version available yet.
> >
> > NOTE: In the link options invalidcontinue.obj has to be included.
> > The reason for this is because by default, Windows calls abort()'s
> > instead of setting errno=EINVAL when invalid arguments are passed to
> > standard functions.
> > This commit explains it in detail:
> > 4b623d80f73528a632576990ca51e34c333d5dd6
> >
> > On Windows the default generator is Visual Studio,so for Visual Studio
> > builds do this:
> >
> > cmake `relative-path-to-srcdir`
> >
> > NOTE: Visual Studio generator is a multi config generator, which means
> > that Debug and Release builds can be done on the same build directory.
> >
> > For Clang builds do this:
> >
> > On bash
> > CC=Clang cmake `relative-path-to-srcdir` -G Ninja
> >               -DCMAKE_BUILD_TYPE=[Debug or Release]
> >
> > On cmd
> > set CC=Clang
> > cmake `relative-path-to-srcdir` -G Ninja
> >               -DCMAKE_BUILD_TYPE=[Debug or Release]
> >
> > Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > ---
> >  CMakeLists.txt | 57 ++++++++++++++++++++++++++++++++++++++++----------
> >  1 file changed, 46 insertions(+), 11 deletions(-)
> >
> > diff --git a/CMakeLists.txt b/CMakeLists.txt
> > index d9eb1060390..5ad3a2557f7 100644
> > --- a/CMakeLists.txt
> > +++ b/CMakeLists.txt
> > @@ -2,7 +2,7 @@
> >  #    Copyright (c) 2020 Sibi Siddharthan
> >  #
> >
> > -cmake_minimum_required(VERSION 3.14)
> > +cmake_minimum_required(VERSION 3.15)
>
> 3.14 is a step too far, and, now, we want CMake 3.15?
>
> >
> >  #Parse GIT-VERSION-GEN to get the version
> >  file(STRINGS ${CMAKE_SOURCE_DIR}/GIT-VERSION-GEN git_version REGEX "DEF_VER=v(.*)")
> > @@ -32,8 +32,11 @@ find_package(ZLIB REQUIRED)
> >  find_package(CURL)
> >  find_package(EXPAT)
> >  find_package(Iconv)
> > -find_package(Intl)
> >
> > +#Don't use libintl on Windows Visual Studio and Clang builds
> > +if(NOT (WIN32 AND (CMAKE_C_COMPILER_ID STREQUAL "MSVC" OR CMAKE_C_COMPILER_ID STREQUAL "Clang")))
> > +     find_package(Intl)
> > +endif()
> >
> >  if(NOT Intl_FOUND)
> >       add_compile_definitions(NO_GETTEXT)
> > @@ -61,7 +64,7 @@ if(NOT SH_EXE)
> >       message(FATAL_ERROR "sh interpreter was not found in your path, please install one. On Windows you can get it from here https://gitforwindows.org/")
> >  endif()
> >
> > -if(WIN32)
> > +if(WIN32 AND NOT MSVC)#not required for visual studio builds
> >       find_program(WINDRES_EXE windres)
> >       if(NOT WINDRES_EXE)
> >               message(FATAL_ERROR "Install windres on Windows for resource files")
> > @@ -73,6 +76,13 @@ if(NOT MSGFMT_EXE)
> >       message(WARNING "Text Translations won't be build")
> >  endif()
> >
> > +#Force all visual studio outputs to CMAKE_BINARY_DIR
> > +if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
> > +     set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR})
> > +     set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR})
> > +     add_compile_options(/MP)
> > +endif()
> > +
> >  #default behaviour
> >  include_directories(${CMAKE_SOURCE_DIR})
> >  add_compile_definitions(GIT_HOST_CPU="${CMAKE_SYSTEM_PROCESSOR}")
> > @@ -110,6 +120,10 @@ endif()
> >
> >  #Platform Specific
> >  if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
> > +     if(CMAKE_C_COMPILER_ID STREQUAL "MSVC" OR CMAKE_C_COMPILER_ID STREQUAL "Clang")
> > +             include_directories(compat/vcbuild/include)
> > +             add_compile_definitions(_CRT_SECURE_NO_WARNINGS _CRT_NONSTDC_NO_DEPRECATE)
>
> This is fair, I hate those warning, too.
>
> Is _CRT_NONSTDC_NO_DEPRECATE implied when _CRT_SECURE_NO_WARNINGS
> defined? Or otherwise around?
>
>

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> 
> This patch provides an alternate way to test git using ctest.
> CTest ships with CMake, so there is no additional dependency being
> introduced.
> 
> To perform the tests with ctest do this after building:
> ctest -j[number of jobs]
> 
> NOTE: -j is optional, the default number of jobs is 1
> 
> Each of the jobs does this:
> cd t/ && sh t[something].sh
> 
> The reason for using CTest is that it logs the output of the tests
> in a neat way, which can be helpful during diagnosis of failures.
> 
> After the tests have run ctest generates three log files located in
> `build-directory`/Testing/Temporary/
> 
> These log files are:
> 
> CTestCostData.txt:
> This file contains the time taken to complete each test.
> 
> LastTestsFailed.log:
> This log file contains the names of the tests that have failed in the
> run.
> 
> LastTest.log:
> This log file contains the log of all the tests that have run.
> A snippet of the file is given below.
> 
> 10/901 Testing: D:/my/git-master/t/t0009-prio-queue.sh
> 10/901 Test: D:/my/git-master/t/t0009-prio-queue.sh
> Command: "sh.exe" "D:/my/git-master/t/t0009-prio-queue.sh"
> Directory: D:/my/git-master/t
> "D:/my/git-master/t/t0009-prio-queue.sh"
> Output:
> ----------------------------------------------------------
> ok 1 - basic ordering
> ok 2 - mixed put and get
> ok 3 - notice empty queue
> ok 4 - stack order
> passed all 4 test(s)
> 1..4
> <end of output>
> Test time =   1.11 sec
> 
> NOTE: Testing only works when building in source for now.
> 
> Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> ---
>  CMakeLists.txt | 142 +++++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 142 insertions(+)
> 
> diff --git a/CMakeLists.txt b/CMakeLists.txt
> index 25de5b5bc35..141ccefa559 100644
> --- a/CMakeLists.txt
> +++ b/CMakeLists.txt
> @@ -23,6 +23,7 @@ include(CheckIncludeFile)
>  include(CheckFunctionExists)
>  include(CheckSymbolExists)
>  include(CheckStructHasMember)
> +include(CTest)
>  
>  find_package(ZLIB REQUIRED)
>  find_package(CURL)
> @@ -680,3 +681,144 @@ install(DIRECTORY ${CMAKE_BINARY_DIR}/templates/blt/ DESTINATION share/git-core/
>  if(MSGFMT_EXE)
>  	install(DIRECTORY ${CMAKE_BINARY_DIR}/po/build/locale DESTINATION share)
>  endif()
> +
> +
> +if(BUILD_TESTING)
> +
> +#tests-helpers
> +add_executable(test-fake-ssh t/helper/test-fake-ssh.c)
> +target_link_libraries(test-fake-ssh common-main)
> +
> +add_executable(test-line-buffer t/helper/test-line-buffer.c)
> +target_link_libraries(test-line-buffer common-main vcs-svn)
> +
> +add_executable(test-svn-fe t/helper/test-svn-fe.c)
> +target_link_libraries(test-svn-fe common-main vcs-svn)
> +
> +set(test_helper_sources
> +	t/helper/test-tool.c t/helper/test-advise.c t/helper/test-bloom.c t/helper/test-chmtime.c
> +	t/helper/test-config.c t/helper/test-ctype.c t/helper/test-date.c t/helper/test-delta.c
> +	t/helper/test-dir-iterator.c t/helper/test-drop-caches.c t/helper/test-dump-cache-tree.c
> +	t/helper/test-dump-fsmonitor.c t/helper/test-dump-split-index.c
> +	t/helper/test-dump-untracked-cache.c t/helper/test-example-decorate.c
> +	t/helper/test-genrandom.c t/helper/test-genzeros.c t/helper/test-hash.c
> +	t/helper/test-hashmap.c t/helper/test-hash-speed.c t/helper/test-index-version.c
> +	t/helper/test-json-writer.c t/helper/test-lazy-init-name-hash.c
> +	t/helper/test-match-trees.c t/helper/test-mergesort.c t/helper/test-mktemp.c
> +	t/helper/test-oidmap.c t/helper/test-online-cpus.c t/helper/test-parse-options.c
> +	t/helper/test-parse-pathspec-file.c t/helper/test-path-utils.c t/helper/test-pkt-line.c
> +	t/helper/test-prio-queue.c t/helper/test-progress.c t/helper/test-reach.c
> +	t/helper/test-read-cache.c t/helper/test-read-graph.c t/helper/test-read-midx.c
> +	t/helper/test-ref-store.c t/helper/test-regex.c t/helper/test-repository.c
> +	t/helper/test-revision-walking.c t/helper/test-run-command.c t/helper/test-scrap-cache-tree.c
> +	t/helper/test-serve-v2.c t/helper/test-sha1.c t/helper/test-oid-array.c t/helper/test-sha256.c
> +	t/helper/test-sigchain.c t/helper/test-strcmp-offset.c t/helper/test-string-list.c
> +	t/helper/test-submodule-config.c t/helper/test-submodule-nested-repo-config.c t/helper/test-subprocess.c
> +	t/helper/test-trace2.c t/helper/test-urlmatch-normalization.c t/helper/test-xml-encode.c
> +	t/helper/test-wildmatch.c t/helper/test-windows-named-pipe.c t/helper/test-write-cache.c)
> +
> +add_executable(test-tool ${test_helper_sources})
> +target_link_libraries(test-tool common-main)
> +
> +set_target_properties(test-fake-ssh test-line-buffer test-svn-fe test-tool
> +			PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/t/helper)
> +
> +#wrapper scripts
> +set(wrapper_scripts
> +	git git-upload-pack git-receive-pack git-upload-archive git-shell git-remote-ext)
> +
> +set(wrapper_test_scripts
> +	test-fake-ssh test-line-buffer test-svn-fe test-tool)
> +
> +
> +foreach(script ${wrapper_scripts})
> +	file(STRINGS ${CMAKE_SOURCE_DIR}/wrap-for-bin.sh content NEWLINE_CONSUME)
> +	string(REPLACE "@@BUILD_DIR@@" "${CMAKE_BINARY_DIR}" content "${content}")
> +	string(REPLACE "@@PROG@@" "${script}" content "${content}")
> +	file(WRITE ${CMAKE_BINARY_DIR}/bin-wrappers/${script} ${content})
> +endforeach()
> +
> +foreach(script ${wrapper_test_scripts})
> +	file(STRINGS ${CMAKE_SOURCE_DIR}/wrap-for-bin.sh content NEWLINE_CONSUME)
> +	string(REPLACE "@@BUILD_DIR@@" "${CMAKE_BINARY_DIR}" content "${content}")
> +	string(REPLACE "@@PROG@@" "t/helper/${script}" content "${content}")
> +	file(WRITE ${CMAKE_BINARY_DIR}/bin-wrappers/${script} ${content})
> +endforeach()
> +
> +file(STRINGS ${CMAKE_SOURCE_DIR}/wrap-for-bin.sh content NEWLINE_CONSUME)
> +string(REPLACE "@@BUILD_DIR@@" "${CMAKE_BINARY_DIR}" content "${content}")
> +string(REPLACE "@@PROG@@" "git-cvsserver" content "${content}")
> +file(WRITE ${CMAKE_BINARY_DIR}/bin-wrappers/git-cvsserver ${content})
> +
> +#options for configuring test options
> +option(PERL_TESTS "Perform tests that use perl" ON)
> +option(PYTHON_TESTS "Perform tests that use python" ON)
> +
> +#GIT-BUILD-OPTIONS
> +set(TEST_SHELL_PATH ${SHELL_PATH})
> +set(DIFF diff)
> +set(PYTHON_PATH /usr/bin/python)
> +set(TAR tar)
> +set(NO_CURL )
> +set(NO_EXPAT )
> +set(USE_LIBPCRE1 )
> +set(USE_LIBPCRE2 )

> +set(NO_LIBPCRE1_JIT )
> +set(NO_PERL )
> +set(NO_PTHREADS )
> +set(NO_PYTHON )
> +set(PAGER_ENV "LESS=FRX LV=-c")
> +set(DC_SHA1 YesPlease)
> +set(RUNTIME_PREFIX true)
> +set(NO_GETTEXT )
> +
> +if(NOT CURL_FOUND)
> +	set(NO_CURL 1)
> +endif()
> +
> +if(NOT EXPAT_FOUND)
> +	set(NO_EXPAT 1)
> +endif()
> +
> +if(NOT Intl_FOUND)
> +	set(NO_GETTEXT 1)
> +endif()
> +
> +if(NOT PERL_TESTS)
> +	set(NO_PERL 1)
> +endif()
> +
> +if(NOT PYTHON_TESTS)
> +	set(NO_PYTHON 1)
> +endif()

> +
> +file(WRITE ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "SHELL_PATH='${SHELL_PATH}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "TEST_SHELL_PATH='${TEST_SHELL_PATH}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "PERL_PATH='${PERL_PATH}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "DIFF='${DIFF}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "PYTHON_PATH='${PYTHON_PATH}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "TAR='${TAR}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_CURL='${NO_CURL}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_EXPAT='${NO_EXPAT}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "USE_LIBPCRE1='${USE_LIBPCRE1}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_LIBPCRE1_JIT='${NO_LIBPCRE1_JIT}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_PERL='${NO_PERL}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_PTHREADS='${NO_PTHREADS}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_UNIX_SOCKETS='${NO_UNIX_SOCKETS}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "PAGER_ENV='${PAGER_ENV}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "DC_SHA1='${DC_SHA1}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "X=''\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_GETTEXT='${NO_GETTEXT}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "RUNTIME_PREFIX='${RUNTIME_PREFIX}'\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_PYTHON='${NO_PYTHON}'\n")
> +
> +file(GLOB test_scipts "${CMAKE_SOURCE_DIR}/t/t[0-9]*.sh")

> +
> +#test
> +foreach(tsh ${test_scipts})
> +	add_test(NAME ${tsh}
> +		COMMAND ${SH_EXE} ${tsh}
> +		WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/t)
> +endforeach()
> +
> +endif()#BUILD_TESTING
> \ No newline at end of file

>
> On 2020-04-24 04:01:33+0000, Sibi Siddharthan via GitGitGadget <gitgitgadget@gmail.com> wrote:
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >
> > This patch provides an alternate way to test git using ctest.
> > CTest ships with CMake, so there is no additional dependency being
> > introduced.
> >
> > To perform the tests with ctest do this after building:
> > ctest -j[number of jobs]
> >
> > NOTE: -j is optional, the default number of jobs is 1
> >
> > Each of the jobs does this:
> > cd t/ && sh t[something].sh
> >
> > The reason for using CTest is that it logs the output of the tests
> > in a neat way, which can be helpful during diagnosis of failures.
> >
> > After the tests have run ctest generates three log files located in
> > `build-directory`/Testing/Temporary/
> >
> > These log files are:
> >
> > CTestCostData.txt:
> > This file contains the time taken to complete each test.
> >
> > LastTestsFailed.log:
> > This log file contains the names of the tests that have failed in the
> > run.
> >
> > LastTest.log:
> > This log file contains the log of all the tests that have run.
> > A snippet of the file is given below.
> >
> > 10/901 Testing: D:/my/git-master/t/t0009-prio-queue.sh
> > 10/901 Test: D:/my/git-master/t/t0009-prio-queue.sh
> > Command: "sh.exe" "D:/my/git-master/t/t0009-prio-queue.sh"
> > Directory: D:/my/git-master/t
> > "D:/my/git-master/t/t0009-prio-queue.sh"
> > Output:
> > ----------------------------------------------------------
> > ok 1 - basic ordering
> > ok 2 - mixed put and get
> > ok 3 - notice empty queue
> > ok 4 - stack order
> > passed all 4 test(s)
> > 1..4
> > <end of output>
> > Test time =   1.11 sec
> >
> > NOTE: Testing only works when building in source for now.
> >
> > Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > ---
> >  CMakeLists.txt | 142 +++++++++++++++++++++++++++++++++++++++++++++++++
> >  1 file changed, 142 insertions(+)
> >
> > diff --git a/CMakeLists.txt b/CMakeLists.txt
> > index 25de5b5bc35..141ccefa559 100644
> > --- a/CMakeLists.txt
> > +++ b/CMakeLists.txt
> > @@ -23,6 +23,7 @@ include(CheckIncludeFile)
> >  include(CheckFunctionExists)
> >  include(CheckSymbolExists)
> >  include(CheckStructHasMember)
> > +include(CTest)
> >
> >  find_package(ZLIB REQUIRED)
> >  find_package(CURL)
> > @@ -680,3 +681,144 @@ install(DIRECTORY ${CMAKE_BINARY_DIR}/templates/blt/ DESTINATION share/git-core/
> >  if(MSGFMT_EXE)
> >       install(DIRECTORY ${CMAKE_BINARY_DIR}/po/build/locale DESTINATION share)
> >  endif()
> > +
> > +
> > +if(BUILD_TESTING)
> > +
> > +#tests-helpers
> > +add_executable(test-fake-ssh t/helper/test-fake-ssh.c)
> > +target_link_libraries(test-fake-ssh common-main)
> > +
> > +add_executable(test-line-buffer t/helper/test-line-buffer.c)
> > +target_link_libraries(test-line-buffer common-main vcs-svn)
> > +
> > +add_executable(test-svn-fe t/helper/test-svn-fe.c)
> > +target_link_libraries(test-svn-fe common-main vcs-svn)
> > +
> > +set(test_helper_sources
> > +     t/helper/test-tool.c t/helper/test-advise.c t/helper/test-bloom.c t/helper/test-chmtime.c
> > +     t/helper/test-config.c t/helper/test-ctype.c t/helper/test-date.c t/helper/test-delta.c
> > +     t/helper/test-dir-iterator.c t/helper/test-drop-caches.c t/helper/test-dump-cache-tree.c
> > +     t/helper/test-dump-fsmonitor.c t/helper/test-dump-split-index.c
> > +     t/helper/test-dump-untracked-cache.c t/helper/test-example-decorate.c
> > +     t/helper/test-genrandom.c t/helper/test-genzeros.c t/helper/test-hash.c
> > +     t/helper/test-hashmap.c t/helper/test-hash-speed.c t/helper/test-index-version.c
> > +     t/helper/test-json-writer.c t/helper/test-lazy-init-name-hash.c
> > +     t/helper/test-match-trees.c t/helper/test-mergesort.c t/helper/test-mktemp.c
> > +     t/helper/test-oidmap.c t/helper/test-online-cpus.c t/helper/test-parse-options.c
> > +     t/helper/test-parse-pathspec-file.c t/helper/test-path-utils.c t/helper/test-pkt-line.c
> > +     t/helper/test-prio-queue.c t/helper/test-progress.c t/helper/test-reach.c
> > +     t/helper/test-read-cache.c t/helper/test-read-graph.c t/helper/test-read-midx.c
> > +     t/helper/test-ref-store.c t/helper/test-regex.c t/helper/test-repository.c
> > +     t/helper/test-revision-walking.c t/helper/test-run-command.c t/helper/test-scrap-cache-tree.c
> > +     t/helper/test-serve-v2.c t/helper/test-sha1.c t/helper/test-oid-array.c t/helper/test-sha256.c
> > +     t/helper/test-sigchain.c t/helper/test-strcmp-offset.c t/helper/test-string-list.c
> > +     t/helper/test-submodule-config.c t/helper/test-submodule-nested-repo-config.c t/helper/test-subprocess.c
> > +     t/helper/test-trace2.c t/helper/test-urlmatch-normalization.c t/helper/test-xml-encode.c
> > +     t/helper/test-wildmatch.c t/helper/test-windows-named-pipe.c t/helper/test-write-cache.c)
> > +
> > +add_executable(test-tool ${test_helper_sources})
> > +target_link_libraries(test-tool common-main)
> > +
> > +set_target_properties(test-fake-ssh test-line-buffer test-svn-fe test-tool
> > +                     PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/t/helper)
> > +
> > +#wrapper scripts
> > +set(wrapper_scripts
> > +     git git-upload-pack git-receive-pack git-upload-archive git-shell git-remote-ext)
> > +
> > +set(wrapper_test_scripts
> > +     test-fake-ssh test-line-buffer test-svn-fe test-tool)
> > +
> > +
> > +foreach(script ${wrapper_scripts})
> > +     file(STRINGS ${CMAKE_SOURCE_DIR}/wrap-for-bin.sh content NEWLINE_CONSUME)
> > +     string(REPLACE "@@BUILD_DIR@@" "${CMAKE_BINARY_DIR}" content "${content}")
> > +     string(REPLACE "@@PROG@@" "${script}" content "${content}")
> > +     file(WRITE ${CMAKE_BINARY_DIR}/bin-wrappers/${script} ${content})
> > +endforeach()
> > +
> > +foreach(script ${wrapper_test_scripts})
> > +     file(STRINGS ${CMAKE_SOURCE_DIR}/wrap-for-bin.sh content NEWLINE_CONSUME)
> > +     string(REPLACE "@@BUILD_DIR@@" "${CMAKE_BINARY_DIR}" content "${content}")
> > +     string(REPLACE "@@PROG@@" "t/helper/${script}" content "${content}")
> > +     file(WRITE ${CMAKE_BINARY_DIR}/bin-wrappers/${script} ${content})
> > +endforeach()
> > +
> > +file(STRINGS ${CMAKE_SOURCE_DIR}/wrap-for-bin.sh content NEWLINE_CONSUME)
> > +string(REPLACE "@@BUILD_DIR@@" "${CMAKE_BINARY_DIR}" content "${content}")
> > +string(REPLACE "@@PROG@@" "git-cvsserver" content "${content}")
> > +file(WRITE ${CMAKE_BINARY_DIR}/bin-wrappers/git-cvsserver ${content})
> > +
> > +#options for configuring test options
> > +option(PERL_TESTS "Perform tests that use perl" ON)
> > +option(PYTHON_TESTS "Perform tests that use python" ON)
> > +
> > +#GIT-BUILD-OPTIONS
> > +set(TEST_SHELL_PATH ${SHELL_PATH})
> > +set(DIFF diff)
> > +set(PYTHON_PATH /usr/bin/python)
> > +set(TAR tar)
> > +set(NO_CURL )
> > +set(NO_EXPAT )
> > +set(USE_LIBPCRE1 )
> > +set(USE_LIBPCRE2 )
>
> Hm, really?
>
>

> > +set(NO_LIBPCRE1_JIT )
> > +set(NO_PERL )
> > +set(NO_PTHREADS )
> > +set(NO_PYTHON )
> > +set(PAGER_ENV "LESS=FRX LV=-c")
> > +set(DC_SHA1 YesPlease)
> > +set(RUNTIME_PREFIX true)
> > +set(NO_GETTEXT )
> > +
> > +if(NOT CURL_FOUND)
> > +     set(NO_CURL 1)
> > +endif()
> > +
> > +if(NOT EXPAT_FOUND)
> > +     set(NO_EXPAT 1)
> > +endif()
> > +
> > +if(NOT Intl_FOUND)
> > +     set(NO_GETTEXT 1)
> > +endif()
> > +
> > +if(NOT PERL_TESTS)
> > +     set(NO_PERL 1)
> > +endif()
> > +
> > +if(NOT PYTHON_TESTS)
> > +     set(NO_PYTHON 1)
> > +endif()
>
> I hope we have something like:
>
> PYTHON_PATH=/path/to/my/yet/to/release/python/to/check/if/it/works/with/current/git
>
> If it's ready, thanks.
> If it isn't, no, I'm stressed enough by CMake.
>

> > +
> > +file(WRITE ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "SHELL_PATH='${SHELL_PATH}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "TEST_SHELL_PATH='${TEST_SHELL_PATH}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "PERL_PATH='${PERL_PATH}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "DIFF='${DIFF}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "PYTHON_PATH='${PYTHON_PATH}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "TAR='${TAR}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_CURL='${NO_CURL}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_EXPAT='${NO_EXPAT}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "USE_LIBPCRE1='${USE_LIBPCRE1}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_LIBPCRE1_JIT='${NO_LIBPCRE1_JIT}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_PERL='${NO_PERL}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_PTHREADS='${NO_PTHREADS}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_UNIX_SOCKETS='${NO_UNIX_SOCKETS}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "PAGER_ENV='${PAGER_ENV}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "DC_SHA1='${DC_SHA1}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "X=''\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_GETTEXT='${NO_GETTEXT}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "RUNTIME_PREFIX='${RUNTIME_PREFIX}'\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_PYTHON='${NO_PYTHON}'\n")
> > +
> > +file(GLOB test_scipts "${CMAKE_SOURCE_DIR}/t/t[0-9]*.sh")
>
> CMake recommends to not use GLOB for this kind of things, themselves, no?
>
> > +
> > +#test
> > +foreach(tsh ${test_scipts})
> > +     add_test(NAME ${tsh}
> > +             COMMAND ${SH_EXE} ${tsh}
> > +             WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/t)
> > +endforeach()
> > +
> > +endif()#BUILD_TESTING
> > \ No newline at end of file
>
> Please fix your editor!
>
> --
> Danh

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> 
> This patch modifies .github/workflows/main.yml to use CMake for
> Visual Studio builds.
> 
> Modified the vs-test step to match windows-test step. This speeds
> up the vs-test. Calling git-cmd from powershell and then calling git-bash
> to perform the tests slows things down(factor of about 6). So git-bash
> is directly called from powershell to perform the tests using prove.
> 
> NOTE: Since GitHub keeps the same directory for each job
> (with respect to path) absolute paths are used in the bin-wrapper
> scripts.
> 
> GitHub has switched to CMake 3.17.1 which changed the behaviour of
> FindCURL module. An extra definition (-DCURL_NO_CURL_CMAKE=ON) has been
> added to revert to the old behaviour.
> 
> Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> ---
>  .github/workflows/main.yml | 43 ++++++++++++++++++++++----------------
>  1 file changed, 25 insertions(+), 18 deletions(-)
> 
> diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
> index fd4df939b50..94f9a385225 100644
> --- a/.github/workflows/main.yml
> +++ b/.github/workflows/main.yml
> @@ -80,13 +80,6 @@ jobs:
>      - name: download git-sdk-64-minimal
>        shell: bash
>        run: a=git-sdk-64-minimal && mkdir -p $a && curl -# https://wingit.blob.core.windows.net/ci-artifacts/$a.tar.xz | tar -C $a -xJf -
> -    - name: generate Visual Studio solution
> -      shell: powershell
> -      run: |
> -        & .\git-sdk-64-minimal\usr\bin\bash.exe -lc @"
> -          make NDEBUG=1 DEVELOPER=1 vcxproj
> -        "@
> -        if (!$?) { exit(1) }
>      - name: download vcpkg artifacts
>        shell: powershell
>        run: |
> @@ -98,6 +91,13 @@ jobs:
>          Remove-Item compat.zip
>      - name: add msbuild to PATH
>        uses: microsoft/setup-msbuild@v1.0.0
> +    - name: generate Visual Studio solution
> +      shell: powershell
> +      run: |
> +        & .\git-sdk-64-minimal\usr\bin\bash.exe -lc @"
> +          cmake . -DCMAKE_PREFIX_PATH=./compat/vcbuild/vcpkg/installed/x64-windows -DMSGFMT_EXE=./git-sdk-64-minimal/mingw64/bin/msgfmt.exe -DPERL_TESTS=OFF -DPYTHON_TESTS=OFF -DCURL_NO_CURL_CMAKE=ON
> +        "@
> +        if (!$?) { exit(1) }

>      - name: MSBuild
>        run: msbuild git.sln -property:Configuration=Release -property:Platform=x64 -maxCpuCount:4 -property:PlatformToolset=v142
>      - name: bundle artifact tar
> @@ -125,9 +125,9 @@ jobs:
>          nr: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>      steps:
>      - uses: actions/checkout@v1
> -    - name: download git-64-portable
> +    - name: download git-sdk-64-minimal
>        shell: bash
> -      run: a=git-64-portable && mkdir -p $a && curl -# https://wingit.blob.core.windows.net/ci-artifacts/$a.tar.xz | tar -C $a -xJf -
> +      run: a=git-sdk-64-minimal && mkdir -p $a && curl -# https://wingit.blob.core.windows.net/ci-artifacts/$a.tar.xz | tar -C $a -xJf -
>      - name: download build artifacts
>        uses: actions/download-artifact@v1
>        with:
> @@ -136,23 +136,30 @@ jobs:
>      - name: extract build artifacts
>        shell: bash
>        run: tar xf artifacts.tar.gz
> -    - name: test (parallel)
> +    - name: test

>        shell: powershell
>        env:
>          MSYSTEM: MINGW64
>          NO_SVN_TESTS: 1
>          GIT_TEST_SKIP_REBASE_P: 1
>        run: |
> -        & git-64-portable\git-cmd.exe --command=usr\bin\bash.exe -lc @"
> -          # Let Git ignore the SDK and the test-cache
> -          printf '%s\n' /git-64-portable/ /test-cache/ >>.git/info/exclude
> +        & .\git-sdk-64-minimal\usr\bin\bash.exe -lc @"
> +          # Let Git ignore the SDK
> +          printf '%s\n' /git-sdk-64-minimal/ >>.git/info/exclude
>  
> -          cd t &&
> -          PATH=\"`$PWD/helper:`$PATH\" &&
> -          test-tool.exe run-command testsuite --jobs=10 -V -x --write-junit-xml \
> -                  `$(test-tool.exe path-utils slice-tests \
> -                          ${{matrix.nr}} 10 t[0-9]*.sh)
> +          ci/run-test-slice.sh ${{matrix.nr}} 10
>          "@
> +    - name: ci/print-test-failures.sh
> +      if: failure()
> +      shell: powershell
> +      run: |
> +        & .\git-sdk-64-minimal\usr\bin\bash.exe -lc ci/print-test-failures.sh

>
> On 2020-04-24 04:01:37+0000, Sibi Siddharthan via GitGitGadget <gitgitgadget@gmail.com> wrote:
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >
> > This patch modifies .github/workflows/main.yml to use CMake for
> > Visual Studio builds.
> >
> > Modified the vs-test step to match windows-test step. This speeds
> > up the vs-test. Calling git-cmd from powershell and then calling git-bash
> > to perform the tests slows things down(factor of about 6). So git-bash
> > is directly called from powershell to perform the tests using prove.
> >
> > NOTE: Since GitHub keeps the same directory for each job
> > (with respect to path) absolute paths are used in the bin-wrapper
> > scripts.
> >
> > GitHub has switched to CMake 3.17.1 which changed the behaviour of
> > FindCURL module. An extra definition (-DCURL_NO_CURL_CMAKE=ON) has been
> > added to revert to the old behaviour.
> >
> > Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > ---
> >  .github/workflows/main.yml | 43 ++++++++++++++++++++++----------------
> >  1 file changed, 25 insertions(+), 18 deletions(-)
> >
> > diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
> > index fd4df939b50..94f9a385225 100644
> > --- a/.github/workflows/main.yml
> > +++ b/.github/workflows/main.yml
> > @@ -80,13 +80,6 @@ jobs:
> >      - name: download git-sdk-64-minimal
> >        shell: bash
> >        run: a=git-sdk-64-minimal && mkdir -p $a && curl -# https://wingit.blob.core.windows.net/ci-artifacts/$a.tar.xz | tar -C $a -xJf -
> > -    - name: generate Visual Studio solution
> > -      shell: powershell
> > -      run: |
> > -        & .\git-sdk-64-minimal\usr\bin\bash.exe -lc @"
> > -          make NDEBUG=1 DEVELOPER=1 vcxproj
> > -        "@
> > -        if (!$?) { exit(1) }
> >      - name: download vcpkg artifacts
> >        shell: powershell
> >        run: |
> > @@ -98,6 +91,13 @@ jobs:
> >          Remove-Item compat.zip
> >      - name: add msbuild to PATH
> >        uses: microsoft/setup-msbuild@v1.0.0
> > +    - name: generate Visual Studio solution
> > +      shell: powershell
> > +      run: |
> > +        & .\git-sdk-64-minimal\usr\bin\bash.exe -lc @"
> > +          cmake . -DCMAKE_PREFIX_PATH=./compat/vcbuild/vcpkg/installed/x64-windows -DMSGFMT_EXE=./git-sdk-64-minimal/mingw64/bin/msgfmt.exe -DPERL_TESTS=OFF -DPYTHON_TESTS=OFF -DCURL_NO_CURL_CMAKE=ON
> > +        "@
> > +        if (!$?) { exit(1) }
>
> If you intended to modified some steps to provide a better script for
> that step, I believe you should change in that step.
>
> If the order of those steps need to be changed, please clarify your
> reasoning!
>

> >      - name: MSBuild
> >        run: msbuild git.sln -property:Configuration=Release -property:Platform=x64 -maxCpuCount:4 -property:PlatformToolset=v142
> >      - name: bundle artifact tar
> > @@ -125,9 +125,9 @@ jobs:
> >          nr: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
> >      steps:
> >      - uses: actions/checkout@v1
> > -    - name: download git-64-portable
> > +    - name: download git-sdk-64-minimal
> >        shell: bash
> > -      run: a=git-64-portable && mkdir -p $a && curl -# https://wingit.blob.core.windows.net/ci-artifacts/$a.tar.xz | tar -C $a -xJf -
> > +      run: a=git-sdk-64-minimal && mkdir -p $a && curl -# https://wingit.blob.core.windows.net/ci-artifacts/$a.tar.xz | tar -C $a -xJf -
> >      - name: download build artifacts
> >        uses: actions/download-artifact@v1
> >        with:
> > @@ -136,23 +136,30 @@ jobs:
> >      - name: extract build artifacts
> >        shell: bash
> >        run: tar xf artifacts.tar.gz
> > -    - name: test (parallel)
> > +    - name: test
>
> So the test couldn't be run in parallel anymore?
> It's a regression!
> And we don't need the matrix anymore!!!!!
>
> I wonder if Dscho's effort is wasted, he tried very hard to make
> those tests run in parallel.
> He even tried to re-order the matrix in GfW project to let longest
> test run first!
>
>

> >        shell: powershell
> >        env:
> >          MSYSTEM: MINGW64
> >          NO_SVN_TESTS: 1
> >          GIT_TEST_SKIP_REBASE_P: 1
> >        run: |
> > -        & git-64-portable\git-cmd.exe --command=usr\bin\bash.exe -lc @"
> > -          # Let Git ignore the SDK and the test-cache
> > -          printf '%s\n' /git-64-portable/ /test-cache/ >>.git/info/exclude
> > +        & .\git-sdk-64-minimal\usr\bin\bash.exe -lc @"
> > +          # Let Git ignore the SDK
> > +          printf '%s\n' /git-sdk-64-minimal/ >>.git/info/exclude
> >
> > -          cd t &&
> > -          PATH=\"`$PWD/helper:`$PATH\" &&
> > -          test-tool.exe run-command testsuite --jobs=10 -V -x --write-junit-xml \
> > -                  `$(test-tool.exe path-utils slice-tests \
> > -                          ${{matrix.nr}} 10 t[0-9]*.sh)
> > +          ci/run-test-slice.sh ${{matrix.nr}} 10
> >          "@
> > +    - name: ci/print-test-failures.sh
> > +      if: failure()
> > +      shell: powershell
> > +      run: |
> > +        & .\git-sdk-64-minimal\usr\bin\bash.exe -lc ci/print-test-failures.sh
>
> What is changed?
>
> --
> Danh

> On 2020-04-24 04:01:37+0000, Sibi Siddharthan via GitGitGadget <gitgitgadget@gmail.com> wrote:
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >
> > @@ -98,6 +91,13 @@ jobs:
> >          Remove-Item compat.zip
> >      - name: add msbuild to PATH
> >        uses: microsoft/setup-msbuild@v1.0.0
> > +    - name: generate Visual Studio solution
> > +      shell: powershell
> > +      run: |
> > +        & .\git-sdk-64-minimal\usr\bin\bash.exe -lc @"
> > +          cmake . -DCMAKE_PREFIX_PATH=./compat/vcbuild/vcpkg/installed/x64-windows -DMSGFMT_EXE=./git-sdk-64-minimal/mingw64/bin/msgfmt.exe -DPERL_TESTS=OFF -DPYTHON_TESTS=OFF -DCURL_NO_CURL_CMAKE=ON
> > +        "@
> > +        if (!$?) { exit(1) }
>
> If you intended to modified some steps to provide a better script for
> that step, I believe you should change in that step.
>
> If the order of those steps need to be changed, please clarify your
> reasoning!

> >      - name: MSBuild
> >        run: msbuild git.sln -property:Configuration=Release -property:Platform=x64 -maxCpuCount:4 -property:PlatformToolset=v142
> >      - name: bundle artifact tar
> > @@ -125,9 +125,9 @@ jobs:
> >          nr: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
> >      steps:
> >      - uses: actions/checkout@v1
> > -    - name: download git-64-portable
> > +    - name: download git-sdk-64-minimal
> >        shell: bash
> > -      run: a=git-64-portable && mkdir -p $a && curl -# https://wingit.blob.core.windows.net/ci-artifacts/$a.tar.xz | tar -C $a -xJf -
> > +      run: a=git-sdk-64-minimal && mkdir -p $a && curl -# https://wingit.blob.core.windows.net/ci-artifacts/$a.tar.xz | tar -C $a -xJf -
> >      - name: download build artifacts
> >        uses: actions/download-artifact@v1
> >        with:
> > @@ -136,23 +136,30 @@ jobs:
> >      - name: extract build artifacts
> >        shell: bash
> >        run: tar xf artifacts.tar.gz
> > -    - name: test (parallel)
> > +    - name: test
>
> So the test couldn't be run in parallel anymore?
> It's a regression!
> And we don't need the matrix anymore!!!!!
>
> I wonder if Dscho's effort is wasted, he tried very hard to make
> those tests run in parallel.

> >        shell: powershell
> >        env:
> >          MSYSTEM: MINGW64
> >          NO_SVN_TESTS: 1
> >          GIT_TEST_SKIP_REBASE_P: 1
> >        run: |
> > -        & git-64-portable\git-cmd.exe --command=usr\bin\bash.exe -lc @"
> > -          # Let Git ignore the SDK and the test-cache
> > -          printf '%s\n' /git-64-portable/ /test-cache/ >>.git/info/exclude
> > +        & .\git-sdk-64-minimal\usr\bin\bash.exe -lc @"
> > +          # Let Git ignore the SDK
> > +          printf '%s\n' /git-sdk-64-minimal/ >>.git/info/exclude
> >
> > -          cd t &&
> > -          PATH=\"`$PWD/helper:`$PATH\" &&
> > -          test-tool.exe run-command testsuite --jobs=10 -V -x --write-junit-xml \
> > -                  `$(test-tool.exe path-utils slice-tests \
> > -                          ${{matrix.nr}} 10 t[0-9]*.sh)
> > +          ci/run-test-slice.sh ${{matrix.nr}} 10
> >          "@
> > +    - name: ci/print-test-failures.sh
> > +      if: failure()
> > +      shell: powershell
> > +      run: |
> > +        & .\git-sdk-64-minimal\usr\bin\bash.exe -lc ci/print-test-failures.sh
>
> What is changed?

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
>
> This patch facilitates building git on Windows with CMake using MinGW
>
> NOTE: The funtions unsetenv and hstrerror are not checked in Windows
> builds.
> Reasons
> NO_UNSETENV is not compatible with Windows builds.
> lines 262-264 compat/mingw.h
>
> compat/mingw.h(line 25) provides a definition of hstrerror which
> conflicts with the definition provided in
> git-compat-util.h(lines 733-736).
>
> To use CMake on Windows with MinGW do this:
> cmake `relative-path-to-srcdir` -G "MinGW Makefiles"
>
> Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> ---
>  CMakeLists.txt | 120 +++++++++++++++++++++++++++++++++++++++----------
>  1 file changed, 97 insertions(+), 23 deletions(-)
>
> diff --git a/CMakeLists.txt b/CMakeLists.txt
> index 29a23eb11f7..d9eb1060390 100644
> --- a/CMakeLists.txt
> +++ b/CMakeLists.txt
> @@ -13,9 +13,12 @@ project(git
>  	VERSION ${git_version}
>  	LANGUAGES C)
>  
> +
>  #TODO gitk git-gui gitweb
> +#TODO Enable NLS on windows natively
>  #TODO Add pcre support
>  
> +
>  include(CheckTypeSize)
>  include(CheckCSourceRuns)
>  include(CheckCSourceCompiles)
> @@ -31,6 +34,7 @@ find_package(EXPAT)
>  find_package(Iconv)
>  find_package(Intl)
>  
> +
>  if(NOT Intl_FOUND)
>  	add_compile_definitions(NO_GETTEXT)
>  	if(NOT Iconv_FOUND)
> @@ -53,6 +57,16 @@ if(Intl_FOUND)
>  endif()
>  
>  find_program(SH_EXE sh)
> +if(NOT SH_EXE)
> +	message(FATAL_ERROR "sh interpreter was not found in your path, please install one. On Windows you can get it from here https://gitforwindows.org/")

> +endif()
> +
> +if(WIN32)
> +	find_program(WINDRES_EXE windres)
> +	if(NOT WINDRES_EXE)
> +		message(FATAL_ERROR "Install windres on Windows for resource files")
> +	endif()
> +endif()
>  
>  find_program(MSGFMT_EXE msgfmt)
>  if(NOT MSGFMT_EXE)
> @@ -85,11 +99,39 @@ add_compile_definitions(PAGER_ENV="LESS=FRX LV=-c"
>  			BINDIR="bin"
>  			GIT_BUILT_FROM_COMMIT="")
>  
> -set(FALLBACK_RUNTIME_PREFIX /home/$ENV{USER})
> -add_compile_definitions(FALLBACK_RUNTIME_PREFIX="${FALLBACK_RUNTIME_PREFIX}")
> +if(WIN32)
> +	set(FALLBACK_RUNTIME_PREFIX /mingw64)
> +	add_compile_definitions(FALLBACK_RUNTIME_PREFIX="${FALLBACK_RUNTIME_PREFIX}")
> +else()
> +	set(FALLBACK_RUNTIME_PREFIX /home/$ENV{USER})
> +	add_compile_definitions(FALLBACK_RUNTIME_PREFIX="${FALLBACK_RUNTIME_PREFIX}")
> +endif()
>  
> -add_compile_definitions(PROCFS_EXECUTABLE_PATH="/proc/self/exe" HAVE_DEV_TTY )
> -list(APPEND compat_SOURCES unix-socket.c)
> +
> +#Platform Specific
> +if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
> +	include_directories(compat/win32)
> +	add_compile_definitions(HAVE_ALLOCA_H NO_POSIX_GOODIES NATIVE_CRLF NO_UNIX_SOCKETS WIN32
> +				_CONSOLE DETECT_MSYS_TTY STRIP_EXTENSION=".exe"  NO_SYMLINK_HEAD UNRELIABLE_FSTAT
> +				NOGDI OBJECT_CREATION_MODE=1 __USE_MINGW_ANSI_STDIO=0 NO_ST_BLOCKS_IN_STRUCT_STAT
> +				USE_NED_ALLOCATOR OVERRIDE_STRDUP MMAP_PREVENTS_DELETE USE_WIN32_MMAP
> +				UNICODE _UNICODE HAVE_WPGMPTR ENSURE_MSYSTEM_IS_SET)
> +	list(APPEND compat_SOURCES compat/mingw.c compat/winansi.c compat/win32/path-utils.c
> +		compat/win32/pthread.c compat/win32mmap.c compat/win32/syslog.c
> +		compat/win32/trace2_win32_process_info.c compat/win32/dirent.c
> +		compat/nedmalloc/nedmalloc.c compat/strdup.c)
> +	set(NO_UNIX_SOCKETS 1)
> +
> +elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
> +	add_compile_definitions(PROCFS_EXECUTABLE_PATH="/proc/self/exe" HAVE_DEV_TTY )
> +	list(APPEND compat_SOURCES unix-socket.c)
> +endif()
> +
> +if(WIN32)
> +	set(EXE_EXTENSION .exe)
> +else()
> +	set(EXE_EXTENSION)
> +endif()
>  
>  #header checks
>  check_include_file(libgen.h HAVE_LIBGEN_H)
> @@ -150,7 +192,12 @@ endif()
>  #function checks
>  set(function_checks
>  	strcasestr memmem strlcpy strtoimax strtoumax strtoull
> -	setenv  mkdtemp poll pread  memmem unsetenv hstrerror)
> +	setenv  mkdtemp poll pread  memmem)
> +
> +#unsetenv,hstrerror are incompatible with windows build
> +if(NOT WIN32)
> +	list(APPEND function_checks unsetenv hstrerror)
> +endif()
>  
>  foreach(f ${function_checks})
>  	string(TOUPPER ${f} uf)
> @@ -309,7 +356,13 @@ endif()
>  #programs
>  set(PROGRAMS_BUILT
>  	git git-bugreport git-credential-store git-daemon git-fast-import git-http-backend git-sh-i18n--envsubst
> -	git-shell git-remote-testsvn git-credential-cache git-credential-cache--daemon)
> +	git-shell git-remote-testsvn)
> +
> +if(NO_UNIX_SOCKETS)
> +	list(APPEND excluded_progs git-credential-cache git-credential-cache--daemon)
> +else()
> +	list(APPEND PROGRAMS_BUILT git-credential-cache git-credential-cache--daemon)
> +endif()
>  
>  if(NOT CURL_FOUND)
>  	list(APPEND excluded_progs git-http-fetch git-http-push)
> @@ -410,15 +463,34 @@ set(libvcs-svn_SOURCES
>  	vcs-svn/svndiff.c vcs-svn/svndump.c)
>  add_library(vcs-svn STATIC ${libvcs-svn_SOURCES})
>  
> +#add git.rc for gcc
> +if(WIN32)
> +	add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/git.res
> +			COMMAND ${WINDRES_EXE} -O coff -DMAJOR=${PROJECT_VERSION_MAJOR} -DMINOR=${PROJECT_VERSION_MINOR}
> +				-DMICRO=${PROJECT_VERSION_PATCH} -DPATCHLEVEL=0 -DGIT_VERSION="\\\"${PROJECT_VERSION}.GIT\\\""
> +				-i ${CMAKE_SOURCE_DIR}/git.rc -o ${CMAKE_BINARY_DIR}/git.res
> +			WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
> +			VERBATIM)
> +	add_custom_target(git-rc DEPENDS ${CMAKE_BINARY_DIR}/git.res)
> +endif()
> +
>  #link all required libraries to common-main
>  add_library(common-main OBJECT common-main.c)
> -target_link_libraries(common-main libgit xdiff ${ZLIB_LIBRARIES} pthread rt)
> +
> +target_link_libraries(common-main libgit xdiff ${ZLIB_LIBRARIES})
>  if(Intl_FOUND)
>  	target_link_libraries(common-main ${Intl_LIBRARIES})
>  endif()
>  if(Iconv_FOUND)
>  	target_link_libraries(common-main ${Iconv_LIBRARIES})
>  endif()
> +if(WIN32)
> +	target_link_libraries(common-main ws2_32 ntdll ${CMAKE_BINARY_DIR}/git.res)
> +	add_dependencies(common-main git-rc)
> +	target_link_options(common-main PUBLIC -municode -Wl,--nxcompat -Wl,--dynamicbase -Wl,--pic-executable,-e,mainCRTStartup)
> +elseif(UNIX)
> +	target_link_libraries(common-main pthread rt)
> +endif()
>  
>  
>  set(git_SOURCES
> @@ -501,11 +573,13 @@ endif()
>  add_executable(git-remote-testsvn remote-testsvn.c)
>  target_link_libraries(git-remote-testsvn common-main vcs-svn)
>  
> -add_executable(git-credential-cache credential-cache.c)
> -target_link_libraries(git-credential-cache common-main)
> +if(NOT NO_UNIX_SOCKETS)
> +	add_executable(git-credential-cache credential-cache.c)
> +	target_link_libraries(git-credential-cache common-main)
>  
> -add_executable(git-credential-cache--daemon credential-cache--daemon.c)
> -target_link_libraries(git-credential-cache--daemon common-main)
> +	add_executable(git-credential-cache--daemon credential-cache--daemon.c)
> +	target_link_libraries(git-credential-cache--daemon common-main)
> +endif()
>  
>  
>  set(git_builtin_extra
> @@ -517,16 +591,16 @@ set(git_builtin_extra
>  foreach(s ${git_SOURCES} ${git_builtin_extra})
>  	string(REPLACE "builtin/" "" s ${s})
>  	string(REPLACE ".c" "" s ${s})
> -	file(APPEND ${CMAKE_BINARY_DIR}/CreateLinks.cmake "file(CREATE_LINK git git-${s})\n")
> -	list(APPEND git_links ${CMAKE_BINARY_DIR}/git-${s})
> +	file(APPEND ${CMAKE_BINARY_DIR}/CreateLinks.cmake "file(CREATE_LINK git${EXE_EXTENSION} git-${s}${EXE_EXTENSION})\n")
> +	list(APPEND git_links ${CMAKE_BINARY_DIR}/git-${s}${EXE_EXTENSION})
>  endforeach()
>  
>  if(CURL_FOUND)
>  	set(remote_exes
>  		git-remote-https git-remote-ftp git-remote-ftps)
>  	foreach(s ${remote_exes})
> -		file(APPEND ${CMAKE_BINARY_DIR}/CreateLinks.cmake "file(CREATE_LINK git-remote-http ${s})\n")
> -		list(APPEND git_http_links ${CMAKE_BINARY_DIR}/${s})
> +		file(APPEND ${CMAKE_BINARY_DIR}/CreateLinks.cmake "file(CREATE_LINK git-remote-http${EXE_EXTENSION} ${s}${EXE_EXTENSION})\n")
> +		list(APPEND git_http_links ${CMAKE_BINARY_DIR}/${s}${EXE_EXTENSION})
>  	endforeach()
>  endif()
>  
> @@ -654,20 +728,20 @@ set(bin_links
>  	git-receive-pack git-upload-archive git-upload-pack)
>  
>  foreach(b ${bin_links})
> -install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git ${CMAKE_INSTALL_PREFIX}/bin/${b})")
> +install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git${EXE_EXTENSION} ${CMAKE_INSTALL_PREFIX}/bin/${b}${EXE_EXTENSION})")
>  endforeach()
>  
> -install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git)")
> -install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git-shell ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git-shell)")
> +install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git${EXE_EXTENSION} ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git${EXE_EXTENSION})")
> +install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git-shell${EXE_EXTENSION} ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git-shell${EXE_EXTENSION})")
>  
>  foreach(b ${git_links})
>  	string(REPLACE "${CMAKE_BINARY_DIR}" "" b ${b})
> -	install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git ${CMAKE_INSTALL_PREFIX}/libexec/git-core/${b})")
> +	install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git${EXE_EXTENSION} ${CMAKE_INSTALL_PREFIX}/libexec/git-core/${b}${EXE_EXTENSION})")
>  endforeach()
>  
>  foreach(b ${git_http_links})
>  	string(REPLACE "${CMAKE_BINARY_DIR}" "" b ${b})
> -	install(CODE "file(CREATE_LINK  ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git-remote-http ${CMAKE_INSTALL_PREFIX}/libexec/git-core/${b})")
> +	install(CODE "file(CREATE_LINK  ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git-remote-http${EXE_EXTENSION} ${CMAKE_INSTALL_PREFIX}/libexec/git-core/${b}${EXE_EXTENSION})")
>  endforeach()
>  
>  install(PROGRAMS ${git_shell_scripts} ${git_perl_scripts} ${CMAKE_BINARY_DIR}/git-p4
> @@ -734,14 +808,14 @@ set(wrapper_test_scripts
>  foreach(script ${wrapper_scripts})
>  	file(STRINGS ${CMAKE_SOURCE_DIR}/wrap-for-bin.sh content NEWLINE_CONSUME)
>  	string(REPLACE "@@BUILD_DIR@@" "${CMAKE_BINARY_DIR}" content "${content}")
> -	string(REPLACE "@@PROG@@" "${script}" content "${content}")
> +	string(REPLACE "@@PROG@@" "${script}${EXE_EXTENSION}" content "${content}")
>  	file(WRITE ${CMAKE_BINARY_DIR}/bin-wrappers/${script} ${content})
>  endforeach()
>  
>  foreach(script ${wrapper_test_scripts})
>  	file(STRINGS ${CMAKE_SOURCE_DIR}/wrap-for-bin.sh content NEWLINE_CONSUME)
>  	string(REPLACE "@@BUILD_DIR@@" "${CMAKE_BINARY_DIR}" content "${content}")
> -	string(REPLACE "@@PROG@@" "t/helper/${script}" content "${content}")
> +	string(REPLACE "@@PROG@@" "t/helper/${script}${EXE_EXTENSION}" content "${content}")
>  	file(WRITE ${CMAKE_BINARY_DIR}/bin-wrappers/${script} ${content})
>  endforeach()
>  
> @@ -807,7 +881,7 @@ file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_PTHREADS='${NO_PTHREADS}'\
>  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_UNIX_SOCKETS='${NO_UNIX_SOCKETS}'\n")
>  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "PAGER_ENV='${PAGER_ENV}'\n")
>  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "DC_SHA1='${DC_SHA1}'\n")
> -file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "X=''\n")
> +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "X='${EXE_EXTENSION}'\n")
>  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_GETTEXT='${NO_GETTEXT}'\n")
>  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "RUNTIME_PREFIX='${RUNTIME_PREFIX}'\n")
>  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_PYTHON='${NO_PYTHON}'\n")

>
> Hi Sibi,
>
> On 24/04/2020 05:01, Sibi Siddharthan via GitGitGadget wrote:
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >
> > This patch facilitates building git on Windows with CMake using MinGW
> >
> > NOTE: The funtions unsetenv and hstrerror are not checked in Windows
> > builds.
> > Reasons
> > NO_UNSETENV is not compatible with Windows builds.
> > lines 262-264 compat/mingw.h
> >
> > compat/mingw.h(line 25) provides a definition of hstrerror which
> > conflicts with the definition provided in
> > git-compat-util.h(lines 733-736).
> >
> > To use CMake on Windows with MinGW do this:
> > cmake `relative-path-to-srcdir` -G "MinGW Makefiles"
> >
> > Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > ---
> >  CMakeLists.txt | 120 +++++++++++++++++++++++++++++++++++++++----------
> >  1 file changed, 97 insertions(+), 23 deletions(-)
> >
> > diff --git a/CMakeLists.txt b/CMakeLists.txt
> > index 29a23eb11f7..d9eb1060390 100644
> > --- a/CMakeLists.txt
> > +++ b/CMakeLists.txt
> > @@ -13,9 +13,12 @@ project(git
> >       VERSION ${git_version}
> >       LANGUAGES C)
> >
> > +
> >  #TODO gitk git-gui gitweb
> > +#TODO Enable NLS on windows natively
> >  #TODO Add pcre support
> >
> > +
> >  include(CheckTypeSize)
> >  include(CheckCSourceRuns)
> >  include(CheckCSourceCompiles)
> > @@ -31,6 +34,7 @@ find_package(EXPAT)
> >  find_package(Iconv)
> >  find_package(Intl)
> >
> > +
> >  if(NOT Intl_FOUND)
> >       add_compile_definitions(NO_GETTEXT)
> >       if(NOT Iconv_FOUND)
> > @@ -53,6 +57,16 @@ if(Intl_FOUND)
> >  endif()
> >
> >  find_program(SH_EXE sh)
> > +if(NOT SH_EXE)
> > +     message(FATAL_ERROR "sh interpreter was not found in your path, please install one. On Windows you can get it from here https://gitforwindows.org/")
> Either the error message or the web page it points to need to coordinate
> on the 'sh interpreter' reference to help the script kiddies follow the
> thread. At the moment there is no 'interp..' on the gitforwindows web
> page. Would someone attempting to use cmake need to use the Download or
> the Contribute buttons, or some other route to acquire the missing SH_EXE?
>

> (this is also a context line in the next patch)
> > +endif()
> > +
> > +if(WIN32)
> > +     find_program(WINDRES_EXE windres)
> > +     if(NOT WINDRES_EXE)
> > +             message(FATAL_ERROR "Install windres on Windows for resource files")
> > +     endif()
> > +endif()
> >
> >  find_program(MSGFMT_EXE msgfmt)
> >  if(NOT MSGFMT_EXE)
> > @@ -85,11 +99,39 @@ add_compile_definitions(PAGER_ENV="LESS=FRX LV=-c"
> >                       BINDIR="bin"
> >                       GIT_BUILT_FROM_COMMIT="")
> >
> > -set(FALLBACK_RUNTIME_PREFIX /home/$ENV{USER})
> > -add_compile_definitions(FALLBACK_RUNTIME_PREFIX="${FALLBACK_RUNTIME_PREFIX}")
> > +if(WIN32)
> > +     set(FALLBACK_RUNTIME_PREFIX /mingw64)
> > +     add_compile_definitions(FALLBACK_RUNTIME_PREFIX="${FALLBACK_RUNTIME_PREFIX}")
> > +else()
> > +     set(FALLBACK_RUNTIME_PREFIX /home/$ENV{USER})
> > +     add_compile_definitions(FALLBACK_RUNTIME_PREFIX="${FALLBACK_RUNTIME_PREFIX}")
> > +endif()
> >
> > -add_compile_definitions(PROCFS_EXECUTABLE_PATH="/proc/self/exe" HAVE_DEV_TTY )
> > -list(APPEND compat_SOURCES unix-socket.c)
> > +
> > +#Platform Specific
> > +if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
> > +     include_directories(compat/win32)
> > +     add_compile_definitions(HAVE_ALLOCA_H NO_POSIX_GOODIES NATIVE_CRLF NO_UNIX_SOCKETS WIN32
> > +                             _CONSOLE DETECT_MSYS_TTY STRIP_EXTENSION=".exe"  NO_SYMLINK_HEAD UNRELIABLE_FSTAT
> > +                             NOGDI OBJECT_CREATION_MODE=1 __USE_MINGW_ANSI_STDIO=0 NO_ST_BLOCKS_IN_STRUCT_STAT
> > +                             USE_NED_ALLOCATOR OVERRIDE_STRDUP MMAP_PREVENTS_DELETE USE_WIN32_MMAP
> > +                             UNICODE _UNICODE HAVE_WPGMPTR ENSURE_MSYSTEM_IS_SET)
> > +     list(APPEND compat_SOURCES compat/mingw.c compat/winansi.c compat/win32/path-utils.c
> > +             compat/win32/pthread.c compat/win32mmap.c compat/win32/syslog.c
> > +             compat/win32/trace2_win32_process_info.c compat/win32/dirent.c
> > +             compat/nedmalloc/nedmalloc.c compat/strdup.c)
> > +     set(NO_UNIX_SOCKETS 1)
> > +
> > +elseif(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
> > +     add_compile_definitions(PROCFS_EXECUTABLE_PATH="/proc/self/exe" HAVE_DEV_TTY )
> > +     list(APPEND compat_SOURCES unix-socket.c)
> > +endif()
> > +
> > +if(WIN32)
> > +     set(EXE_EXTENSION .exe)
> > +else()
> > +     set(EXE_EXTENSION)
> > +endif()
> >
> >  #header checks
> >  check_include_file(libgen.h HAVE_LIBGEN_H)
> > @@ -150,7 +192,12 @@ endif()
> >  #function checks
> >  set(function_checks
> >       strcasestr memmem strlcpy strtoimax strtoumax strtoull
> > -     setenv  mkdtemp poll pread  memmem unsetenv hstrerror)
> > +     setenv  mkdtemp poll pread  memmem)
> > +
> > +#unsetenv,hstrerror are incompatible with windows build
> > +if(NOT WIN32)
> > +     list(APPEND function_checks unsetenv hstrerror)
> > +endif()
> >
> >  foreach(f ${function_checks})
> >       string(TOUPPER ${f} uf)
> > @@ -309,7 +356,13 @@ endif()
> >  #programs
> >  set(PROGRAMS_BUILT
> >       git git-bugreport git-credential-store git-daemon git-fast-import git-http-backend git-sh-i18n--envsubst
> > -     git-shell git-remote-testsvn git-credential-cache git-credential-cache--daemon)
> > +     git-shell git-remote-testsvn)
> > +
> > +if(NO_UNIX_SOCKETS)
> > +     list(APPEND excluded_progs git-credential-cache git-credential-cache--daemon)
> > +else()
> > +     list(APPEND PROGRAMS_BUILT git-credential-cache git-credential-cache--daemon)
> > +endif()
> >
> >  if(NOT CURL_FOUND)
> >       list(APPEND excluded_progs git-http-fetch git-http-push)
> > @@ -410,15 +463,34 @@ set(libvcs-svn_SOURCES
> >       vcs-svn/svndiff.c vcs-svn/svndump.c)
> >  add_library(vcs-svn STATIC ${libvcs-svn_SOURCES})
> >
> > +#add git.rc for gcc
> > +if(WIN32)
> > +     add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/git.res
> > +                     COMMAND ${WINDRES_EXE} -O coff -DMAJOR=${PROJECT_VERSION_MAJOR} -DMINOR=${PROJECT_VERSION_MINOR}
> > +                             -DMICRO=${PROJECT_VERSION_PATCH} -DPATCHLEVEL=0 -DGIT_VERSION="\\\"${PROJECT_VERSION}.GIT\\\""
> > +                             -i ${CMAKE_SOURCE_DIR}/git.rc -o ${CMAKE_BINARY_DIR}/git.res
> > +                     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
> > +                     VERBATIM)
> > +     add_custom_target(git-rc DEPENDS ${CMAKE_BINARY_DIR}/git.res)
> > +endif()
> > +
> >  #link all required libraries to common-main
> >  add_library(common-main OBJECT common-main.c)
> > -target_link_libraries(common-main libgit xdiff ${ZLIB_LIBRARIES} pthread rt)
> > +
> > +target_link_libraries(common-main libgit xdiff ${ZLIB_LIBRARIES})
> >  if(Intl_FOUND)
> >       target_link_libraries(common-main ${Intl_LIBRARIES})
> >  endif()
> >  if(Iconv_FOUND)
> >       target_link_libraries(common-main ${Iconv_LIBRARIES})
> >  endif()
> > +if(WIN32)
> > +     target_link_libraries(common-main ws2_32 ntdll ${CMAKE_BINARY_DIR}/git.res)
> > +     add_dependencies(common-main git-rc)
> > +     target_link_options(common-main PUBLIC -municode -Wl,--nxcompat -Wl,--dynamicbase -Wl,--pic-executable,-e,mainCRTStartup)
> > +elseif(UNIX)
> > +     target_link_libraries(common-main pthread rt)
> > +endif()
> >
> >
> >  set(git_SOURCES
> > @@ -501,11 +573,13 @@ endif()
> >  add_executable(git-remote-testsvn remote-testsvn.c)
> >  target_link_libraries(git-remote-testsvn common-main vcs-svn)
> >
> > -add_executable(git-credential-cache credential-cache.c)
> > -target_link_libraries(git-credential-cache common-main)
> > +if(NOT NO_UNIX_SOCKETS)
> > +     add_executable(git-credential-cache credential-cache.c)
> > +     target_link_libraries(git-credential-cache common-main)
> >
> > -add_executable(git-credential-cache--daemon credential-cache--daemon.c)
> > -target_link_libraries(git-credential-cache--daemon common-main)
> > +     add_executable(git-credential-cache--daemon credential-cache--daemon.c)
> > +     target_link_libraries(git-credential-cache--daemon common-main)
> > +endif()
> >
> >
> >  set(git_builtin_extra
> > @@ -517,16 +591,16 @@ set(git_builtin_extra
> >  foreach(s ${git_SOURCES} ${git_builtin_extra})
> >       string(REPLACE "builtin/" "" s ${s})
> >       string(REPLACE ".c" "" s ${s})
> > -     file(APPEND ${CMAKE_BINARY_DIR}/CreateLinks.cmake "file(CREATE_LINK git git-${s})\n")
> > -     list(APPEND git_links ${CMAKE_BINARY_DIR}/git-${s})
> > +     file(APPEND ${CMAKE_BINARY_DIR}/CreateLinks.cmake "file(CREATE_LINK git${EXE_EXTENSION} git-${s}${EXE_EXTENSION})\n")
> > +     list(APPEND git_links ${CMAKE_BINARY_DIR}/git-${s}${EXE_EXTENSION})
> >  endforeach()
> >
> >  if(CURL_FOUND)
> >       set(remote_exes
> >               git-remote-https git-remote-ftp git-remote-ftps)
> >       foreach(s ${remote_exes})
> > -             file(APPEND ${CMAKE_BINARY_DIR}/CreateLinks.cmake "file(CREATE_LINK git-remote-http ${s})\n")
> > -             list(APPEND git_http_links ${CMAKE_BINARY_DIR}/${s})
> > +             file(APPEND ${CMAKE_BINARY_DIR}/CreateLinks.cmake "file(CREATE_LINK git-remote-http${EXE_EXTENSION} ${s}${EXE_EXTENSION})\n")
> > +             list(APPEND git_http_links ${CMAKE_BINARY_DIR}/${s}${EXE_EXTENSION})
> >       endforeach()
> >  endif()
> >
> > @@ -654,20 +728,20 @@ set(bin_links
> >       git-receive-pack git-upload-archive git-upload-pack)
> >
> >  foreach(b ${bin_links})
> > -install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git ${CMAKE_INSTALL_PREFIX}/bin/${b})")
> > +install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git${EXE_EXTENSION} ${CMAKE_INSTALL_PREFIX}/bin/${b}${EXE_EXTENSION})")
> >  endforeach()
> >
> > -install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git)")
> > -install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git-shell ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git-shell)")
> > +install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git${EXE_EXTENSION} ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git${EXE_EXTENSION})")
> > +install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git-shell${EXE_EXTENSION} ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git-shell${EXE_EXTENSION})")
> >
> >  foreach(b ${git_links})
> >       string(REPLACE "${CMAKE_BINARY_DIR}" "" b ${b})
> > -     install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git ${CMAKE_INSTALL_PREFIX}/libexec/git-core/${b})")
> > +     install(CODE "file(CREATE_LINK ${CMAKE_INSTALL_PREFIX}/bin/git${EXE_EXTENSION} ${CMAKE_INSTALL_PREFIX}/libexec/git-core/${b}${EXE_EXTENSION})")
> >  endforeach()
> >
> >  foreach(b ${git_http_links})
> >       string(REPLACE "${CMAKE_BINARY_DIR}" "" b ${b})
> > -     install(CODE "file(CREATE_LINK  ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git-remote-http ${CMAKE_INSTALL_PREFIX}/libexec/git-core/${b})")
> > +     install(CODE "file(CREATE_LINK  ${CMAKE_INSTALL_PREFIX}/libexec/git-core/git-remote-http${EXE_EXTENSION} ${CMAKE_INSTALL_PREFIX}/libexec/git-core/${b}${EXE_EXTENSION})")
> >  endforeach()
> >
> >  install(PROGRAMS ${git_shell_scripts} ${git_perl_scripts} ${CMAKE_BINARY_DIR}/git-p4
> > @@ -734,14 +808,14 @@ set(wrapper_test_scripts
> >  foreach(script ${wrapper_scripts})
> >       file(STRINGS ${CMAKE_SOURCE_DIR}/wrap-for-bin.sh content NEWLINE_CONSUME)
> >       string(REPLACE "@@BUILD_DIR@@" "${CMAKE_BINARY_DIR}" content "${content}")
> > -     string(REPLACE "@@PROG@@" "${script}" content "${content}")
> > +     string(REPLACE "@@PROG@@" "${script}${EXE_EXTENSION}" content "${content}")
> >       file(WRITE ${CMAKE_BINARY_DIR}/bin-wrappers/${script} ${content})
> >  endforeach()
> >
> >  foreach(script ${wrapper_test_scripts})
> >       file(STRINGS ${CMAKE_SOURCE_DIR}/wrap-for-bin.sh content NEWLINE_CONSUME)
> >       string(REPLACE "@@BUILD_DIR@@" "${CMAKE_BINARY_DIR}" content "${content}")
> > -     string(REPLACE "@@PROG@@" "t/helper/${script}" content "${content}")
> > +     string(REPLACE "@@PROG@@" "t/helper/${script}${EXE_EXTENSION}" content "${content}")
> >       file(WRITE ${CMAKE_BINARY_DIR}/bin-wrappers/${script} ${content})
> >  endforeach()
> >
> > @@ -807,7 +881,7 @@ file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_PTHREADS='${NO_PTHREADS}'\
> >  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_UNIX_SOCKETS='${NO_UNIX_SOCKETS}'\n")
> >  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "PAGER_ENV='${PAGER_ENV}'\n")
> >  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "DC_SHA1='${DC_SHA1}'\n")
> > -file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "X=''\n")
> > +file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "X='${EXE_EXTENSION}'\n")
> >  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_GETTEXT='${NO_GETTEXT}'\n")
> >  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "RUNTIME_PREFIX='${RUNTIME_PREFIX}'\n")
> >  file(APPEND ${CMAKE_BINARY_DIR}/GIT-BUILD-OPTIONS "NO_PYTHON='${NO_PYTHON}'\n")
>

> Hi Philip,
>
> On Fri, Apr 24, 2020 at 11:09 PM Philip Oakley <philipoakley@iee.email> wrote:
>> Hi Sibi,
>>
>> On 24/04/2020 05:01, Sibi Siddharthan via GitGitGadget wrote:
>>> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
>>>
>>> This patch facilitates building git on Windows with CMake using MinGW
>>>
>>> NOTE: The funtions unsetenv and hstrerror are not checked in Windows
>>> builds.
>>> Reasons
>>> NO_UNSETENV is not compatible with Windows builds.
>>> lines 262-264 compat/mingw.h
>>>
>>> compat/mingw.h(line 25) provides a definition of hstrerror which
>>> conflicts with the definition provided in
>>> git-compat-util.h(lines 733-736).
>>>
>>> To use CMake on Windows with MinGW do this:
>>> cmake `relative-path-to-srcdir` -G "MinGW Makefiles"
>>>
>>> Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
>>> ---
>>>  CMakeLists.txt | 120 +++++++++++++++++++++++++++++++++++++++----------
>>>  1 file changed, 97 insertions(+), 23 deletions(-)
>>>
>>> diff --git a/CMakeLists.txt b/CMakeLists.txt
>>> index 29a23eb11f7..d9eb1060390 100644
>>> [snip..]
>>>  find_program(SH_EXE sh)
>>> +if(NOT SH_EXE)
>>> +     message(FATAL_ERROR "sh interpreter was not found in your path, please install one. On Windows you can get it from here https://gitforwindows.org/")
>> Either the error message or the web page it points to need to coordinate
>> on the 'sh interpreter' reference to help the script kiddies follow the
>> thread. At the moment there is no 'interp..' on the gitforwindows web
>> page. Would someone attempting to use cmake need to use the Download or
>> the Contribute buttons, or some other route to acquire the missing SH_EXE?
>>
> On Windows, if you are using Git Bash, then you don't have a problem.
> This message was for people trying to Git on Windows without a bash shell.
>
> I can rephrase the message saying
> "On Windows go to https://gitforwindows.org/ and download the Git
> installer which ships with a sh interpreter(bash)."
>
> Would you suggest something else?

>
> Hi Sibi,
>
> On 24/04/2020 21:29, Sibi Siddharthan wrote:
> > Hi Philip,
> >
> > On Fri, Apr 24, 2020 at 11:09 PM Philip Oakley <philipoakley@iee.email> wrote:
> >> Hi Sibi,
> >>
> >> On 24/04/2020 05:01, Sibi Siddharthan via GitGitGadget wrote:
> >>> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >>>
> >>> This patch facilitates building git on Windows with CMake using MinGW
> >>>
> >>> NOTE: The funtions unsetenv and hstrerror are not checked in Windows
> >>> builds.
> >>> Reasons
> >>> NO_UNSETENV is not compatible with Windows builds.
> >>> lines 262-264 compat/mingw.h
> >>>
> >>> compat/mingw.h(line 25) provides a definition of hstrerror which
> >>> conflicts with the definition provided in
> >>> git-compat-util.h(lines 733-736).
> >>>
> >>> To use CMake on Windows with MinGW do this:
> >>> cmake `relative-path-to-srcdir` -G "MinGW Makefiles"
> >>>
> >>> Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >>> ---
> >>>  CMakeLists.txt | 120 +++++++++++++++++++++++++++++++++++++++----------
> >>>  1 file changed, 97 insertions(+), 23 deletions(-)
> >>>
> >>> diff --git a/CMakeLists.txt b/CMakeLists.txt
> >>> index 29a23eb11f7..d9eb1060390 100644
> >>> [snip..]
> >>>  find_program(SH_EXE sh)
> >>> +if(NOT SH_EXE)
> >>> +     message(FATAL_ERROR "sh interpreter was not found in your path, please install one. On Windows you can get it from here https://gitforwindows.org/")
> >> Either the error message or the web page it points to need to coordinate
> >> on the 'sh interpreter' reference to help the script kiddies follow the
> >> thread. At the moment there is no 'interp..' on the gitforwindows web
> >> page. Would someone attempting to use cmake need to use the Download or
> >> the Contribute buttons, or some other route to acquire the missing SH_EXE?
> >>
> > On Windows, if you are using Git Bash, then you don't have a problem.
> > This message was for people trying to Git on Windows without a bash shell.
> >
> > I can rephrase the message saying
> > "On Windows go to https://gitforwindows.org/ and download the Git
> > installer which ships with a sh interpreter(bash)."
> >
> > Would you suggest something else?
>
> Filling the message out a little, I'm thinking of:
>
> "sh: shell interpreter was not found in your path, please install one.
> On Windows, you can get it as part of 'Git for Windows' install at
> https://gitforwindows.org/"
>
> The second 'install' could be dropped, but may be needed to fully
> qualify the instructions for some readers.
>
> The key feature I was checking was the clarity of the 'install' action,
> as opposed to the way sh is integrated within Git for Windows (which is
> a whole new topic of conversation for some users!)

> >
> >> (this is also a context line in the next patch)
> >>
> [snip..]
>
> --
> Philip

>
> "Sibi Siddharthan via GitGitGadget" <gitgitgadget@gmail.com> writes:
>
> > This is an attempt to build Git using CMake.
>
> What is your longer-term plan on this one?  Would the ultimate goal
> be
>
>  (1) to maintain both CMake and Makefile and keep them in sync?
>
>  (2) force all the Git developers (not users or binary packagers)
>      start using cmake and abandon Makefile, and let CMake generate
>      Makefile?
>
>  (3) something else?
>
> Given that bootstrapping CMake typically takes a working "make", by
> definition, if you drop Makefile from our shipped source tree, the
> audience you can support on minority platforms would be smaller than
> what we have.  It is not negotiable that we keep Makefile as a valid
> way to build Git, and the Makefile must be tweakable for those on a
> minority platforms when things do not go the way they want to (the
> tweakability is most needed on minority/exotic platforms).
>
> W ith either (1) or (2) above, I have a feeling that engineering
> burden to divert resources to add cmake support (with sustainable
> plan to keep "fixable/tweakable" Makefile that is in sync) alone
> would already be high enough.  It is unclear the reason why we want
> to pay all that cost---to gain what?  Other than to make those who
> like CMake feel happier, that is.
>
> I do not want to sound overly negative in my first response, but you
> might thank whoever says "no" early before you invest too much time
> on this topic, so I'll send the above before even reading these 8
> patches.
>
> Thanks for your interest in the project.
>

> The goal would be to maintain a CMake build for Git keeping it in sync
> with the Makefile.
> The Makefile is not going to be replaced at all. The CMake script for
> now only supports Linux and Windows.
> It does not support BSD, Solaris and others, whereas the Makefile does
> support them.

>
> Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
>
> > The goal would be to maintain a CMake build for Git keeping it in sync
> > with the Makefile.
> > The Makefile is not going to be replaced at all. The CMake script for
> > now only supports Linux and Windows.
> > It does not support BSD, Solaris and others, whereas the Makefile does
> > support them.
>
> So you are doing (1).  I already said that I feel that engineering
> burden to divert resources for CMake support would be unacceptably
> high.
>
> Whenever any of our developers need to add source files, Makefile
> configuration knobs that people can add to config.mak, etc., you are
> forcing them to figure out where in the CMakefile to add them or
> devise ways to allow builders who do not use config.mak (because
> they use CMake) to do similar tweaks.
>

> Any patch that is acceptable to the current project would become
> unacceptable because they lack updates to CMake part, but I suspect
> we do not have enough people who are so much devoted to give a good
> review if updates to CMake part are added.  And it is unclear why it
> would be beneficial to slow our existing developers down by forcing
> them to become familiar with CMake.
>
> So..., I am not just "still not convinced", but I am even more
> convinced that we do not want this series, after thinking about it
> longer.
>
> Thanks.
>

> On Sat, Apr 25, 2020 at 3:13 AM Junio C Hamano <gitster@pobox.com> wrote:
>> Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
>>
>>> The goal would be to maintain a CMake build for Git keeping it in sync
>>> with the Makefile.
>>> The Makefile is not going to be replaced at all. The CMake script for
>>> now only supports Linux and Windows.
>>> It does not support BSD, Solaris and others, whereas the Makefile does
>>> support them.
>> So you are doing (1).  I already said that I feel that engineering
>> burden to divert resources for CMake support would be unacceptably
>> high.
>>
>> Whenever any of our developers need to add source files, Makefile
>> configuration knobs that people can add to config.mak, etc., you are
>> forcing them to figure out where in the CMakefile to add them or
>> devise ways to allow builders who do not use config.mak (because
>> they use CMake) to do similar tweaks.
>>
> Adding source files to the CMakefile is going to just as long as
> adding it to the Makefile,
> anyone can figure this out and this is not going to take much time at all.

>
> As for the configuration knobs I agree that adding the same to CMake
> is going to a bit longer.
> But anyone who is hacking Git is going to do it with the Makefile or
> (if accepted)CMake script, but not both while hacking.
> So they will continue to make progress with the system they feel comfortable in.
> They will only run into an issue when they try for a PR. Currently the
> CMake script is only used for generating the visual studio solution.
> We can add a (continue-on-error) to vs-build job to make this process
> less of a hindrance.
> If people take the time to hack Git, figuring out how to do the
> configuration knobs in the CMake script is not going to that much take
> time
> compared to the time they spend making Git better.
>
>
>> Any patch that is acceptable to the current project would become
>> unacceptable because they lack updates to CMake part, but I suspect
>> we do not have enough people who are so much devoted to give a good
>> review if updates to CMake part are added.  And it is unclear why it
>> would be beneficial to slow our existing developers down by forcing
>> them to become familiar with CMake.
>>
>> So..., I am not just "still not convinced", but I am even more
>> convinced that we do not want this series, after thinking about it
>> longer.
>>
>> Thanks.
>>

> On 25/04/2020 05:09, Sibi Siddharthan wrote:
> > On Sat, Apr 25, 2020 at 3:13 AM Junio C Hamano <gitster@pobox.com> wrote:
> >> Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
> >>
> >>> The goal would be to maintain a CMake build for Git keeping it in
> >>> sync with the Makefile. The Makefile is not going to be replaced at
> >>> all. The CMake script for now only supports Linux and Windows. It
> >>> does not support BSD, Solaris and others, whereas the Makefile does
> >>> support them.
> >>
> >> So you are doing (1).  I already said that I feel that engineering
> >> burden to divert resources for CMake support would be unacceptably
> >> high.
> >>
> >> Whenever any of our developers need to add source files, Makefile
> >> configuration knobs that people can add to config.mak, etc., you are
> >> forcing them to figure out where in the CMakefile to add them or
> >> devise ways to allow builders who do not use config.mak (because they
> >> use CMake) to do similar tweaks.
> >
> > Adding source files to the CMakefile is going to just as long as
> > adding it to the Makefile, anyone can figure this out and this is not
> > going to take much time at all.
>
> While figuring these things out isn't /hard/ it can be tedious and time
> consuming for those who are not familiar with the particular tool set
> (as evidenced, in my mind, by the poor dev support for Git for Windows
> because of the need to understand two operating systems and their
> awkward interactions) - those that are familiar and understand the/their
> whole tool set are usually the x10 folks.

> > As for the configuration knobs I agree that adding the same to CMake
> > is going to a bit longer.
> > But anyone who is hacking Git is going to do it with the Makefile or
> > (if accepted)CMake script, but not both while hacking.
> > So they will continue to make progress with the system they feel comfortable in.
> > They will only run into an issue when they try for a PR. Currently the
> > CMake script is only used for generating the visual studio solution.
> > We can add a (continue-on-error) to vs-build job to make this process
> > less of a hindrance.
> > If people take the time to hack Git, figuring out how to do the
> > configuration knobs in the CMake script is not going to that much take
> > time
> > compared to the time they spend making Git better.
> >
> >
> >> Any patch that is acceptable to the current project would become
> >> unacceptable because they lack updates to CMake part, but I suspect
> >> we do not have enough people who are so much devoted to give a good
> >> review if updates to CMake part are added.  And it is unclear why it
> >> would be beneficial to slow our existing developers down by forcing
> >> them to become familiar with CMake.
> >>
> >> So..., I am not just "still not convinced", but I am even more
> >> convinced that we do not want this series, after thinking about it
> >> longer.
> >>
> >> Thanks.
> >>
>
> Is there a middle way, given that IIUC there is most benefit on the
> Windows side, that on the git.git side the Makefile could contain a
> suitable comment directing those interested in CMake to the relevant
> part of Git-for-Windows. Is there a part that could hold, and track, the
> matching changes to the primary Makefile? 

>
> Hi Philip,
>
> On Sat, 25 Apr 2020, Philip Oakley wrote:
>
> > On 25/04/2020 05:09, Sibi Siddharthan wrote:
> > > On Sat, Apr 25, 2020 at 3:13 AM Junio C Hamano <gitster@pobox.com> wrote:
> > >> Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
> > >>
> > >>> The goal would be to maintain a CMake build for Git keeping it in
> > >>> sync with the Makefile. The Makefile is not going to be replaced at
> > >>> all. The CMake script for now only supports Linux and Windows. It
> > >>> does not support BSD, Solaris and others, whereas the Makefile does
> > >>> support them.
> > >>
> > >> So you are doing (1).  I already said that I feel that engineering
> > >> burden to divert resources for CMake support would be unacceptably
> > >> high.
> > >>
> > >> Whenever any of our developers need to add source files, Makefile
> > >> configuration knobs that people can add to config.mak, etc., you are
> > >> forcing them to figure out where in the CMakefile to add them or
> > >> devise ways to allow builders who do not use config.mak (because they
> > >> use CMake) to do similar tweaks.
> > >
> > > Adding source files to the CMakefile is going to just as long as
> > > adding it to the Makefile, anyone can figure this out and this is not
> > > going to take much time at all.
> >
> > While figuring these things out isn't /hard/ it can be tedious and time
> > consuming for those who are not familiar with the particular tool set
> > (as evidenced, in my mind, by the poor dev support for Git for Windows
> > because of the need to understand two operating systems and their
> > awkward interactions) - those that are familiar and understand the/their
> > whole tool set are usually the x10 folks.

>
> Is it fair to compare the complexities of the differences between what Git
> expects and what Windows provides to the difference to add files to
> Makefile _and_ CMakeLists.txt?
>
> When I add a file to the Makefile, what I do (and imagine that _everybody_
> is doing in that circumstance) is to find an already-existing file that is
> similar to the one I want to add. For example, if adding
> `builtin/oakley--helper.c`, I will try to imitate
> `builtin/submodule--helper.c`.
>
> And when you do that, you don't really need to understand Makefiles or
> CMake. You find the list(s) and add your file there, paying attention to
> whether it is maintained alphabetically or append-only.
>
> That is a _far_ cry from the hoops through which you have to jump to
> understand, say, the important background details in order to start
> working on `compat/mingw.c`.
>
> At least from my point of view, there is very little analogy between the
> subject under discussion and what you brought up.
>
> Having said that...
>
> > > As for the configuration knobs I agree that adding the same to CMake
> > > is going to a bit longer.
> > > But anyone who is hacking Git is going to do it with the Makefile or
> > > (if accepted)CMake script, but not both while hacking.
> > > So they will continue to make progress with the system they feel comfortable in.
> > > They will only run into an issue when they try for a PR. Currently the
> > > CMake script is only used for generating the visual studio solution.
> > > We can add a (continue-on-error) to vs-build job to make this process
> > > less of a hindrance.
> > > If people take the time to hack Git, figuring out how to do the
> > > configuration knobs in the CMake script is not going to that much take
> > > time
> > > compared to the time they spend making Git better.
> > >
> > >
> > >> Any patch that is acceptable to the current project would become
> > >> unacceptable because they lack updates to CMake part, but I suspect
> > >> we do not have enough people who are so much devoted to give a good
> > >> review if updates to CMake part are added.  And it is unclear why it
> > >> would be beneficial to slow our existing developers down by forcing
> > >> them to become familiar with CMake.
> > >>
> > >> So..., I am not just "still not convinced", but I am even more
> > >> convinced that we do not want this series, after thinking about it
> > >> longer.
> > >>
> > >> Thanks.
> > >>
> >
> > Is there a middle way, given that IIUC there is most benefit on the
> > Windows side, that on the git.git side the Makefile could contain a
> > suitable comment directing those interested in CMake to the relevant
> > part of Git-for-Windows. Is there a part that could hold, and track, the
> > matching changes to the primary Makefile?
>
> We already use `GIT-VERSION-GEN` as the authoritative source for the Git
> version, by parsing the line that contains.
>
> It would look very similar, at least in my mind, to generate the list of
> source/script files by parsing the `Makefile`.
>
> Sibi, what do you think?
>

> On Sat, Apr 25, 2020 at 6:59 PM Johannes Schindelin
> <Johannes.Schindelin@gmx.de> wrote:
>
> >
> > We already use `GIT-VERSION-GEN` as the authoritative source for the Git
> > version, by parsing the line that contains.
> >
> > It would look very similar, at least in my mind, to generate the list of
> > source/script files by parsing the `Makefile`.
> >
> > Sibi, what do you think?
>
> One way of doing it is to track if the Makefile is changed in a commit,
> run a hook to see if it contains any new OBJs and match it with the
> CMake script. But this is too much work, in my opinion.

>
> Hi Sibi,
>
> On Sat, 25 Apr 2020, Sibi Siddharthan wrote:
>
> > On Sat, Apr 25, 2020 at 6:59 PM Johannes Schindelin
> > <Johannes.Schindelin@gmx.de> wrote:
> >
> > >
> > > We already use `GIT-VERSION-GEN` as the authoritative source for the Git
> > > version, by parsing the line that contains.
> > >
> > > It would look very similar, at least in my mind, to generate the list of
> > > source/script files by parsing the `Makefile`.
> > >
> > > Sibi, what do you think?
> >
> > One way of doing it is to track if the Makefile is changed in a commit,
> > run a hook to see if it contains any new OBJs and match it with the
> > CMake script. But this is too much work, in my opinion.
>
> Oh, sorry, I should have clarified: We already parse the
> `DEF_VER=v2.26.GIT` line in `GIT-VERSION-GEN` to determine the Git
> version.
>
> We should be able to do the very exact same thing to parse the `SCRIPT_SH`
> lines like
>
>         SCRIPT_SH += git-bisect.sh
>
> in the `Makefile` to accumulate the list of shell scripts, and likewise
> the list of object files could be accumulated by parsing the `LIB_OBJS`
> lines like
>
>         LIB_OBJS += abspath.o
>
> (We would of course need to substitute the `.o` with `.c`, but that should
> be easy.)
>
> That way, nobody will ever need to touch the CMakeLists.txt file when they
> add a new source file to libgit.a.
>

> I was not trying to auto-detect what `sed` invocation changed. Those
> changes _will_ need manual forward-porting to CMakeLists.txt. Thankfully,
> those events are really rare.
>
> Makes sense?
>
> Ciao,
> Dscho

> On Sat, Apr 25, 2020 at 7:58 PM Johannes Schindelin
> <Johannes.Schindelin@gmx.de> wrote:
> >
> > On Sat, 25 Apr 2020, Sibi Siddharthan wrote:
> >
> > > On Sat, Apr 25, 2020 at 6:59 PM Johannes Schindelin
> > > <Johannes.Schindelin@gmx.de> wrote:
> > >
> > > >
> > > > We already use `GIT-VERSION-GEN` as the authoritative source for the Git
> > > > version, by parsing the line that contains.
> > > >
> > > > It would look very similar, at least in my mind, to generate the list of
> > > > source/script files by parsing the `Makefile`.
> > > >
> > > > Sibi, what do you think?
> > >
> > > One way of doing it is to track if the Makefile is changed in a commit,
> > > run a hook to see if it contains any new OBJs and match it with the
> > > CMake script. But this is too much work, in my opinion.
> >
> > Oh, sorry, I should have clarified: We already parse the
> > `DEF_VER=v2.26.GIT` line in `GIT-VERSION-GEN` to determine the Git
> > version.
> >
> > We should be able to do the very exact same thing to parse the `SCRIPT_SH`
> > lines like
> >
> >         SCRIPT_SH += git-bisect.sh
> >
> > in the `Makefile` to accumulate the list of shell scripts, and likewise
> > the list of object files could be accumulated by parsing the `LIB_OBJS`
> > lines like
> >
> >         LIB_OBJS += abspath.o
> >
> > (We would of course need to substitute the `.o` with `.c`, but that should
> > be easy.)
> >
> > That way, nobody will ever need to touch the CMakeLists.txt file when they
> > add a new source file to libgit.a.
> >
>
> I understand what you are trying to say, this is not impossible to do but doing
> so will make the CMake script dependent on the Makefile for the sources.
> I am not fan of this approach.
>
> We should write a separate script (say python) to match each of the sources in
> the Makefile and the CMake file automatically whenever the changes detected.
> This excludes the platform specific/compatibility stuff in config.mak.uname.

>
> > I was not trying to auto-detect what `sed` invocation changed. Those
> > changes _will_ need manual forward-porting to CMakeLists.txt. Thankfully,
> > those events are really rare.
> >
> > Makes sense?
> >
> > Ciao,
> > Dscho
>
> Thank You,
> Sibi Siddharthan
>
>

>
> Hi Sibi,
>
> On Sat, 25 Apr 2020, Sibi Siddharthan wrote:
>
> > On Sat, Apr 25, 2020 at 7:58 PM Johannes Schindelin
> > <Johannes.Schindelin@gmx.de> wrote:
> > >
> > > On Sat, 25 Apr 2020, Sibi Siddharthan wrote:
> > >
> > > > On Sat, Apr 25, 2020 at 6:59 PM Johannes Schindelin
> > > > <Johannes.Schindelin@gmx.de> wrote:
> > > >
> > > > >
> > > > > We already use `GIT-VERSION-GEN` as the authoritative source for the Git
> > > > > version, by parsing the line that contains.
> > > > >
> > > > > It would look very similar, at least in my mind, to generate the list of
> > > > > source/script files by parsing the `Makefile`.
> > > > >
> > > > > Sibi, what do you think?
> > > >
> > > > One way of doing it is to track if the Makefile is changed in a commit,
> > > > run a hook to see if it contains any new OBJs and match it with the
> > > > CMake script. But this is too much work, in my opinion.
> > >
> > > Oh, sorry, I should have clarified: We already parse the
> > > `DEF_VER=v2.26.GIT` line in `GIT-VERSION-GEN` to determine the Git
> > > version.
> > >
> > > We should be able to do the very exact same thing to parse the `SCRIPT_SH`
> > > lines like
> > >
> > >         SCRIPT_SH += git-bisect.sh
> > >
> > > in the `Makefile` to accumulate the list of shell scripts, and likewise
> > > the list of object files could be accumulated by parsing the `LIB_OBJS`
> > > lines like
> > >
> > >         LIB_OBJS += abspath.o
> > >
> > > (We would of course need to substitute the `.o` with `.c`, but that should
> > > be easy.)
> > >
> > > That way, nobody will ever need to touch the CMakeLists.txt file when they
> > > add a new source file to libgit.a.
> > >
> >
> > I understand what you are trying to say, this is not impossible to do but doing
> > so will make the CMake script dependent on the Makefile for the sources.
> > I am not fan of this approach.
> >
> > We should write a separate script (say python) to match each of the sources in
> > the Makefile and the CMake file automatically whenever the changes detected.
> > This excludes the platform specific/compatibility stuff in config.mak.uname.
>
> Hmm. That is an approach that _I_ don't like. Why duplicate the
> information when you don't have to?
>
> I don't see any issue with keeping CMakeLists.txt dependent on Makefile.
> We could of course extract the lists into a separate file that is sourced
> both from the Makefile and from CMakeLists.txt, but that would actually
> not reflect that the Makefile _is_ authoritative. CMakeLists.txt will
> never be the authoritative source.
>
> Ciao,
> Dscho
>
> >
> > > I was not trying to auto-detect what `sed` invocation changed. Those
> > > changes _will_ need manual forward-porting to CMakeLists.txt. Thankfully,
> > > those events are really rare.
> > >
> > > Makes sense?
> > >
> > > Ciao,
> > > Dscho
> >
> > Thank You,
> > Sibi Siddharthan
> >
> >

> Hi Dscho,
> 
> I guess this is a pain point having to manage two separate build systems.
> I will modify CMake script to get its sources from the Makefile.
> 
> > > I understand what you are trying to say, this is not impossible to do but doing
> > > so will make the CMake script dependent on the Makefile for the sources.
> > > I am not fan of this approach.
> > >
> > > We should write a separate script (say python) to match each of the sources in
> > > the Makefile and the CMake file automatically whenever the changes detected.
> > > This excludes the platform specific/compatibility stuff in config.mak.uname.
> >
> > Hmm. That is an approach that _I_ don't like. Why duplicate the
> > information when you don't have to?
> >
> > I don't see any issue with keeping CMakeLists.txt dependent on Makefile.
> > We could of course extract the lists into a separate file that is sourced
> > both from the Makefile and from CMakeLists.txt, but that would actually
> > not reflect that the Makefile _is_ authoritative. CMakeLists.txt will
> > never be the authoritative source.

>
> On 2020-04-25 20:27:37+0530, Sibi Siddharthan <sibisiddharthan.github@gmail.com> wrote:
> > Hi Dscho,
> >
> > I guess this is a pain point having to manage two separate build systems.
> > I will modify CMake script to get its sources from the Makefile.
> >
> > > > I understand what you are trying to say, this is not impossible to do but doing
> > > > so will make the CMake script dependent on the Makefile for the sources.
> > > > I am not fan of this approach.
> > > >
> > > > We should write a separate script (say python) to match each of the sources in
> > > > the Makefile and the CMake file automatically whenever the changes detected.
> > > > This excludes the platform specific/compatibility stuff in config.mak.uname.
> > >
> > > Hmm. That is an approach that _I_ don't like. Why duplicate the
> > > information when you don't have to?
> > >
> > > I don't see any issue with keeping CMakeLists.txt dependent on Makefile.
> > > We could of course extract the lists into a separate file that is sourced
> > > both from the Makefile and from CMakeLists.txt, but that would actually
> > > not reflect that the Makefile _is_ authoritative. CMakeLists.txt will
> > > never be the authoritative source.
>
> (This email is hard to be replied, because Sibi do top-posting.
> And, I want to quote both on this).
>
> I'm still not a fan of CMake despite that I need to write it at
> previous $DAYJOBS.
>
> I would like to keep Makefile as authoritative source of information,
> and to convince other developers, we need to keep Makefile as
> authoritative source of information. Let's say this way, I dislike it,
> but if it works for you, that's fine, just don't add more burden for
> existing people.
>
> Remember that with CMake support, we will never able to use CMake
> generated build in-tree because we have an existing Makefile in-tree
> (not a problem since it's expected to be built out-of-tree if CMake is used),
> but please don't complain if it people accidentally break it.
> ./configure doesn't work correctly with `--without-<pkg>` and people
> seems to not interest in my series to respect it, for example.
>

> When writing this, I intended to write something to support
> out-of-tree build with current Makefile. Hopefully, it won't be rocket
> science.
>
> Last but not least, (this point was discussed with Sibi off-list)
> about our test infrastructure, when we add a new test,
> we can simply run:
>
>         make test
>
> Makefile will pick it up, and run all tests just fine.
>
> CMake's glob only works at CMake configuration time.
> If there's a new test after CMake was run, and nothing changed in
> CMakeList.txt. The list generated by CMake will still be the same,
> ctest wouldn't know that there's a new test.
> People need to manually run cmake again to pick it up (or as Sibi
> told me off-list, that developer is question can run by hand
>
>         path/to/git/source/t/t-9999-true.sh
>
> That's not a problem for the person write that test,
> but it'll be problem for other people, who will fetch the new source
> to their own repo, and naively run msbuild and ctest.
>
> It's analogue to this habit in git (me in my previous $DAYJOBS)
>
>         yes | git add -p
>
> Anyway, get back to the solution (should this series be accepted),
> I think it'll work if we can split:
>
>         SOURCE_FILES += cmake.c
>
> into a source-list.mak
>
> Then, cmake will do some magic with `configure_file` or something
> similar, IIRC, it's a reduced functionallity of sed.
>

> Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
>
> > The goal would be to maintain a CMake build for Git keeping it in sync
> > with the Makefile. The Makefile is not going to be replaced at all.
> > The CMake script for now only supports Linux and Windows. It does not
> > support BSD, Solaris and others, whereas the Makefile does support
> > them.
>
> So you are doing (1).  I already said that I feel that engineering
> burden to divert resources for CMake support would be unacceptably
> high.

> Whenever any of our developers need to add source files, Makefile
> configuration knobs that people can add to config.mak, etc., you are
> forcing them to figure out where in the CMakefile to add them or devise
> ways to allow builders who do not use config.mak (because they use
> CMake) to do similar tweaks.

> Any patch that is acceptable to the current project would become
> unacceptable because they lack updates to CMake part, but I suspect
> we do not have enough people who are so much devoted to give a good
> review if updates to CMake part are added.  And it is unclear why it
> would be beneficial to slow our existing developers down by forcing
> them to become familiar with CMake.

> > > The goal would be to maintain a CMake build for Git keeping it in sync
> > > with the Makefile. The Makefile is not going to be replaced at all.
> > > The CMake script for now only supports Linux and Windows. It does not
> > > support BSD, Solaris and others, whereas the Makefile does support
> > > them.
> >
> > So you are doing (1).  I already said that I feel that engineering
> > burden to divert resources for CMake support would be unacceptably
> > high.
> 
> Would your position change if Sibi was interested in maintaining this, and
> helping with keeping CMake support in shape?

> > Any patch that is acceptable to the current project would become
> > unacceptable because they lack updates to CMake part, but I suspect
> > we do not have enough people who are so much devoted to give a good
> > review if updates to CMake part are added.  And it is unclear why it
> > would be beneficial to slow our existing developers down by forcing
> > them to become familiar with CMake.
> 
> When it comes to new Makefile knobs, I do agree that it would place an
> unacceptable burden on contributors if we expected them to add the same
> knob to CMakeLists.txt. But we already don't do that for our autoconf
> support, so why would we expect it for CMake?

> But even if I haven't, I would like to propose to run with Sibi's patches
> and merge them first to `pu`, and then to `next`, and let that cook for a
> while (I will merge them into Git for Windows early so that there is also
> some support stream from that side).
> 
> I know you think that the maintenance cost is too high, but I think it
> might be more than just manageable. And I don't think that the risk is too
> high to give the patches a try, at least inside `next`, for a couple of
> weeks or even months.
> 
> If it turns out that they _do_ add too much of a maintenance burden, big
> deal: we just drop the patches, and that's that. No hard feelings, we gave
> it a try, a scientific test, if you want, and we now have evidence to back
> up your initial suspicion.
> 
> If it turns out that they _do_ add value _and_ are easy to maintain, then
> that's good, right? And then, at your leisurely leisure, you can merge
> them down to `master` and eventually into an official release.
> 
> What do you think? Doesn't that sound like a good plan?

> On Mon, Apr 27, 2020 at 04:08:52PM -0400, Jeff King wrote:
> 
> > Skimming the patches, I do wish I didn't see so much repetition with the
> > existing Makefile. I know that some of the logic will just have to be
> > ported manually, but surely we could be pulling things like the list of
> > libgit_SOURCES from the Makefile as the single source of truth?
> 
> Thinking I surely couldn't be the only one to think of this, I dug
> further into some of the sub-threads. And indeed, it seems like you are
> on the same page here.
> 
> IMHO it is worth making the cmake file depend as much as possible on
> what's in the Makefile.

> On 2020-04-27 16:12:28-0400, Jeff King <peff@peff.net> wrote:
> > On Mon, Apr 27, 2020 at 04:08:52PM -0400, Jeff King wrote:
> > 
> > > Skimming the patches, I do wish I didn't see so much repetition with the
> > > existing Makefile. I know that some of the logic will just have to be
> > > ported manually, but surely we could be pulling things like the list of
> > > libgit_SOURCES from the Makefile as the single source of truth?
> > 
> > Thinking I surely couldn't be the only one to think of this, I dug
> > further into some of the sub-threads. And indeed, it seems like you are
> > on the same page here.
> > 
> > IMHO it is worth making the cmake file depend as much as possible on
> > what's in the Makefile.
> 
> Please correct me if I were wrong (I recall this from my memory
> without checking anything).
> 
> The worst thing about CMake is we can't override (Make's) variable
> in Makefile generated by CMake.

>
> On Tue, Apr 28, 2020 at 08:52:37PM +0700, Danh Doan wrote:
>
> > On 2020-04-27 16:12:28-0400, Jeff King <peff@peff.net> wrote:
> > > On Mon, Apr 27, 2020 at 04:08:52PM -0400, Jeff King wrote:
> > >
> > > > Skimming the patches, I do wish I didn't see so much repetition with the
> > > > existing Makefile. I know that some of the logic will just have to be
> > > > ported manually, but surely we could be pulling things like the list of
> > > > libgit_SOURCES from the Makefile as the single source of truth?
> > >
> > > Thinking I surely couldn't be the only one to think of this, I dug
> > > further into some of the sub-threads. And indeed, it seems like you are
> > > on the same page here.
> > >
> > > IMHO it is worth making the cmake file depend as much as possible on
> > > what's in the Makefile.
> >
> > Please correct me if I were wrong (I recall this from my memory
> > without checking anything).
> >
> > The worst thing about CMake is we can't override (Make's) variable
> > in Makefile generated by CMake.
>
> I really don't know enough about cmake to say one way or the other. I
> can well believe there are parts of the Makefile that will need to be
> manually translated, and that it may not ever hit full parity.
>
> But as long as it just a tool for people using Visual Studio, and if
> they are happier being able to use that tool, even with a few
> deficiencies, then it may still be worth doing.
>
> -Peff

>
> Thank You,
> Sibi Siddharthan
>
> On Wed, Apr 29, 2020 at 2:37 AM Jeff King <peff@peff.net> wrote:
> >
> > On Tue, Apr 28, 2020 at 08:52:37PM +0700, Danh Doan wrote:
> >
> > > On 2020-04-27 16:12:28-0400, Jeff King <peff@peff.net> wrote:
> > > > On Mon, Apr 27, 2020 at 04:08:52PM -0400, Jeff King wrote:
> > > >
> > > > > Skimming the patches, I do wish I didn't see so much repetition with the
> > > > > existing Makefile. I know that some of the logic will just have to be
> > > > > ported manually, but surely we could be pulling things like the list of
> > > > > libgit_SOURCES from the Makefile as the single source of truth?
> > > >
> > > > Thinking I surely couldn't be the only one to think of this, I dug
> > > > further into some of the sub-threads. And indeed, it seems like you are
> > > > on the same page here.
> > > >
> > > > IMHO it is worth making the cmake file depend as much as possible on
> > > > what's in the Makefile.
> > >
> > > Please correct me if I were wrong (I recall this from my memory
> > > without checking anything).
> > >
> > > The worst thing about CMake is we can't override (Make's) variable
> > > in Makefile generated by CMake.
> >
> > I really don't know enough about cmake to say one way or the other. I
> > can well believe there are parts of the Makefile that will need to be
> > manually translated, and that it may not ever hit full parity.
> >
> > But as long as it just a tool for people using Visual Studio, and if
> > they are happier being able to use that tool, even with a few
> > deficiencies, then it may still be worth doing.
> >
> > -Peff
>

>
> Hi Sibi,
>
> [please avoid top-posting on this list, but do reply inline instead, that
> is much preferred.]
>
> On Wed, 29 Apr 2020, Sibi Siddharthan wrote:
>
> > Adding the CMake script to contrib/buildsystem is a good option.
>
> I'd actually prefer it to live in a different subdirectory: what is in
> contrib/buildsystem/ uses the technique of running `make` in a dry-run
> mode, parsing the output, and then generating project files. But that is
> not what CMakeLists.txt is about.
>
> How about contrib/cmake/?
>

> > Is there any changes (apart from the CMakeLists.txt critique and) that
> > I have to do on my part?
>
> No, I think that's it!
>
> Thanks,
> Dscho
>
> >
> > Thank You,
> > Sibi Siddharthan
> >
> > On Wed, Apr 29, 2020 at 2:37 AM Jeff King <peff@peff.net> wrote:
> > >
> > > On Tue, Apr 28, 2020 at 08:52:37PM +0700, Danh Doan wrote:
> > >
> > > > On 2020-04-27 16:12:28-0400, Jeff King <peff@peff.net> wrote:
> > > > > On Mon, Apr 27, 2020 at 04:08:52PM -0400, Jeff King wrote:
> > > > >
> > > > > > Skimming the patches, I do wish I didn't see so much repetition with the
> > > > > > existing Makefile. I know that some of the logic will just have to be
> > > > > > ported manually, but surely we could be pulling things like the list of
> > > > > > libgit_SOURCES from the Makefile as the single source of truth?
> > > > >
> > > > > Thinking I surely couldn't be the only one to think of this, I dug
> > > > > further into some of the sub-threads. And indeed, it seems like you are
> > > > > on the same page here.
> > > > >
> > > > > IMHO it is worth making the cmake file depend as much as possible on
> > > > > what's in the Makefile.
> > > >
> > > > Please correct me if I were wrong (I recall this from my memory
> > > > without checking anything).
> > > >
> > > > The worst thing about CMake is we can't override (Make's) variable
> > > > in Makefile generated by CMake.
> > >
> > > I really don't know enough about cmake to say one way or the other. I
> > > can well believe there are parts of the Makefile that will need to be
> > > manually translated, and that it may not ever hit full parity.
> > >
> > > But as long as it just a tool for people using Visual Studio, and if
> > > they are happier being able to use that tool, even with a few
> > > deficiencies, then it may still be worth doing.
> > >
> > > -Peff
> >

> On Sat, May 2, 2020 at 1:02 AM Johannes Schindelin
> <Johannes.Schindelin@gmx.de> wrote:
> > On Wed, 29 Apr 2020, Sibi Siddharthan wrote:
> >
> > > Adding the CMake script to contrib/buildsystem is a good option.
> >
> > I'd actually prefer it to live in a different subdirectory: what is in
> > contrib/buildsystem/ uses the technique of running `make` in a dry-run
> > mode, parsing the output, and then generating project files. But that
> > is not what CMakeLists.txt is about.
> >
> > How about contrib/cmake/?
> >
> 
> The CMakeLists.txt will be non-functional if it in any other directory except
> the root source directory. To help users we can, add some instructions in
> INSTALL on how to use the script.
> OR
> create a dummy CMakeLists.txt in the root directory which just says
> `message("Copy and Replace the CMakeLists from `whatever-folder` to
> here")` along with some instructions if necessary. This is what LLVM does for
> autoconf.
> > > Is there any changes (apart from the CMakeLists.txt critique and)
> > > that I have to do on my part?
> >
> > No, I think that's it!
> >
> > Thanks,
> > Dscho
> >
> > >
> > > Thank You,
> > > Sibi Siddharthan
> > >
> > > On Wed, Apr 29, 2020 at 2:37 AM Jeff King <peff@peff.net> wrote:
> > > >
> > > > On Tue, Apr 28, 2020 at 08:52:37PM +0700, Danh Doan wrote:
> > > >
> > > > > On 2020-04-27 16:12:28-0400, Jeff King <peff@peff.net> wrote:
> > > > > > On Mon, Apr 27, 2020 at 04:08:52PM -0400, Jeff King wrote:
> > > > > >
> > > > > > > Skimming the patches, I do wish I didn't see so much
> > > > > > > repetition with the existing Makefile. I know that some of
> > > > > > > the logic will just have to be ported manually, but surely
> > > > > > > we could be pulling things like the list of libgit_SOURCES from the
> Makefile as the single source of truth?
> > > > > >
> > > > > > Thinking I surely couldn't be the only one to think of this, I
> > > > > > dug further into some of the sub-threads. And indeed, it seems
> > > > > > like you are on the same page here.
> > > > > >
> > > > > > IMHO it is worth making the cmake file depend as much as
> > > > > > possible on what's in the Makefile.
> > > > >
> > > > > Please correct me if I were wrong (I recall this from my memory
> > > > > without checking anything).
> > > > >
> > > > > The worst thing about CMake is we can't override (Make's)
> > > > > variable in Makefile generated by CMake.
> > > >
> > > > I really don't know enough about cmake to say one way or the
> > > > other. I can well believe there are parts of the Makefile that
> > > > will need to be manually translated, and that it may not ever hit full
> parity.
> > > >
> > > > But as long as it just a tool for people using Visual Studio, and
> > > > if they are happier being able to use that tool, even with a few
> > > > deficiencies, then it may still be worth doing.
> > > >
> > > > -Peff
> > >

>> How about contrib/cmake/?
>>
>
> The CMakeLists.txt will be non-functional if it in any other directory except
> the root source directory. To help users we can,
> add some instructions in INSTALL on how to use the script.
> OR
> create a dummy CMakeLists.txt in the root directory which just
> says
> `message("Copy and Replace the CMakeLists from `whatever-folder` to here")`
> along with some instructions if necessary. This is what LLVM does for autoconf.

>
> Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
>
> >> How about contrib/cmake/?
> >>
> >
> > The CMakeLists.txt will be non-functional if it in any other directory except
> > the root source directory. To help users we can,
> > add some instructions in INSTALL on how to use the script.
> > OR
> > create a dummy CMakeLists.txt in the root directory which just
> > says
> > `message("Copy and Replace the CMakeLists from `whatever-folder` to here")`
> > along with some instructions if necessary. This is what LLVM does for autoconf.
>
> Isn't there a corresponding feature to make's "-f" option to specify
> which file to read instructions from?

>
> As you say, an extra instruction in INSTALL file to tell users to
> copy from contrib/cmake may workable, though it is unsatisfactory.
> But the other one will not simply work.  If we need to have a new
> file with string "CMake" in its name at the top-level *anyway*, we
> should have the real thing to reduce one step from those who want to
> use it.  Those who do not want to see "CMake" at the toplevel are
> already harmed either way, if is a dummy or if it is the real thing.

>> As you say, an extra instruction in INSTALL file to tell users to
>> copy from contrib/cmake may workable, though it is unsatisfactory.
>> But the other one will not simply work.  If we need to have a new
>> file with string "CMake" in its name at the top-level *anyway*, we
>> should have the real thing to reduce one step from those who want to
>> use it.  Those who do not want to see "CMake" at the toplevel are
>> already harmed either way, if is a dummy or if it is the real thing.
>
> In your opinion, what would be the best way to communicate with users, there is
> an optional CMake build system for git?

> Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
>
>>>  As you say, an extra instruction in INSTALL file to tell users to
>>>  copy from contrib/cmake may workable, though it is unsatisfactory.
>>>  But the other one will not simply work. If we need to have a new
>>>  file with string "CMake" in its name at the top-level *anyway*, we
>>>  should have the real thing to reduce one step from those who want to
>>>  use it. Those who do not want to see "CMake" at the toplevel are
>>>  already harmed either way, if is a dummy or if it is the real thing.
>>
>>  In your opinion, what would be the best way to communicate with users, there is
>>  an optional CMake build system for git?
>
> You do not want to hear my opinion, as my priorities would be
> different from yours ;-)
>
> Given that we all agreed that the only reason we contemplate use of
> CMake in our project is strictly to help Windows build, i.e. due to
> the same reason why we have contrib/buildsystems/, it is not one of
> my goals to communicate with general users about optional CMake
> support in the first place. It has lower priority than keeping the
> project tree and the project history less cluttered.
>
> So my first preference would be an instruction somewhere in install
> or readme that tells those who want to build for windows to copy
> from (or perhaps update cmake to offer the "-f" option and tell it
> to read from) contrib/cmake/CMakeLists.txt to the toplevel before
> doing anything [*1*].

>
> If there are many people who want to help the cmake effort, however,
> shipping a real CMakeLists.txt at the top-level of the tree, with
> all the instructions at the beginning of *that* file, would be an
> easier way for them to discover and polish. It would also be my
> preference but only under the "if there are many people" condition.
>
> Thanks.
>
> [Footnote]
>
> *1* It probably is too error prone to tell people who do the real
>     work to "copy", as they are prone to modify the copy and forget
>     updating the source. So the instruction may tell them to create
>     a symlink at the toplevel that points to the real file in the
>     contrib/cmake/ directory, or if the filesystem does not support
>     symbolic links (which is very likely given the target audience
>     of this are all on Windows), tell them copy a small skeleton
>     file that is also shipped in contrib/cmake/ directory to the
>     top-level. That skeleton file would "include" the real thing
>     that lives in contrib/cmake/ directory (I am assuming that
>     CMakeLists.txt can include other CMakeLists.txt file here).

>
>
> 03.05.2020, 20:21, "Junio C Hamano" <gitster@pobox.com>:
> > Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
> >
> >>>  As you say, an extra instruction in INSTALL file to tell users to
> >>>  copy from contrib/cmake may workable, though it is unsatisfactory.
> >>>  But the other one will not simply work. If we need to have a new
> >>>  file with string "CMake" in its name at the top-level *anyway*, we
> >>>  should have the real thing to reduce one step from those who want to
> >>>  use it. Those who do not want to see "CMake" at the toplevel are
> >>>  already harmed either way, if is a dummy or if it is the real thing.
> >>
> >>  In your opinion, what would be the best way to communicate with users, there is
> >>  an optional CMake build system for git?
> >
> > You do not want to hear my opinion, as my priorities would be
> > different from yours ;-)
> >
> > Given that we all agreed that the only reason we contemplate use of
> > CMake in our project is strictly to help Windows build, i.e. due to
> > the same reason why we have contrib/buildsystems/, it is not one of
> > my goals to communicate with general users about optional CMake
> > support in the first place. It has lower priority than keeping the
> > project tree and the project history less cluttered.
> >
> > So my first preference would be an instruction somewhere in install
> > or readme that tells those who want to build for windows to copy
> > from (or perhaps update cmake to offer the "-f" option and tell it
> > to read from) contrib/cmake/CMakeLists.txt to the toplevel before
> > doing anything [*1*].
>
> FWIW, CMakeLists.txt doesn't have to be in the root of source tree in
> order to work. It can perfectly work from contrib/cmake after necessary
> changes in relative paths.

> Hi Konst,
>
> On Sun, 3 May 2020, Konstantin Tokarev wrote:
>
>>  03.05.2020, 20:21, "Junio C Hamano" <gitster@pobox.com>:
>>  > Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
>>  >
>>  >>>  As you say, an extra instruction in INSTALL file to tell users to
>>  >>>  copy from contrib/cmake may workable, though it is unsatisfactory.
>>  >>>  But the other one will not simply work. If we need to have a new
>>  >>>  file with string "CMake" in its name at the top-level *anyway*, we
>>  >>>  should have the real thing to reduce one step from those who want to
>>  >>>  use it. Those who do not want to see "CMake" at the toplevel are
>>  >>>  already harmed either way, if is a dummy or if it is the real thing.
>>  >>
>>  >>  In your opinion, what would be the best way to communicate with users, there is
>>  >>  an optional CMake build system for git?
>>  >
>>  > You do not want to hear my opinion, as my priorities would be
>>  > different from yours ;-)
>>  >
>>  > Given that we all agreed that the only reason we contemplate use of
>>  > CMake in our project is strictly to help Windows build, i.e. due to
>>  > the same reason why we have contrib/buildsystems/, it is not one of
>>  > my goals to communicate with general users about optional CMake
>>  > support in the first place. It has lower priority than keeping the
>>  > project tree and the project history less cluttered.
>>  >
>>  > So my first preference would be an instruction somewhere in install
>>  > or readme that tells those who want to build for windows to copy
>>  > from (or perhaps update cmake to offer the "-f" option and tell it
>>  > to read from) contrib/cmake/CMakeLists.txt to the toplevel before
>>  > doing anything [*1*].
>>
>>  FWIW, CMakeLists.txt doesn't have to be in the root of source tree in
>>  order to work. It can perfectly work from contrib/cmake after necessary
>>  changes in relative paths.
>
> Would you have an example handy, or a link to an article describing this?

>
>
>
> 05.05.2020, 00:32, "Johannes Schindelin" <johannes.schindelin@gmx.de>:
> > Hi Konst,
> >
> > On Sun, 3 May 2020, Konstantin Tokarev wrote:
> >
> >>  03.05.2020, 20:21, "Junio C Hamano" <gitster@pobox.com>:
> >>  > Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
> >>  >
> >>  >>>  As you say, an extra instruction in INSTALL file to tell users to
> >>  >>>  copy from contrib/cmake may workable, though it is unsatisfactory.
> >>  >>>  But the other one will not simply work. If we need to have a new
> >>  >>>  file with string "CMake" in its name at the top-level *anyway*, we
> >>  >>>  should have the real thing to reduce one step from those who want to
> >>  >>>  use it. Those who do not want to see "CMake" at the toplevel are
> >>  >>>  already harmed either way, if is a dummy or if it is the real thing.
> >>  >>
> >>  >>  In your opinion, what would be the best way to communicate with users, there is
> >>  >>  an optional CMake build system for git?
> >>  >
> >>  > You do not want to hear my opinion, as my priorities would be
> >>  > different from yours ;-)
> >>  >
> >>  > Given that we all agreed that the only reason we contemplate use of
> >>  > CMake in our project is strictly to help Windows build, i.e. due to
> >>  > the same reason why we have contrib/buildsystems/, it is not one of
> >>  > my goals to communicate with general users about optional CMake
> >>  > support in the first place. It has lower priority than keeping the
> >>  > project tree and the project history less cluttered.
> >>  >
> >>  > So my first preference would be an instruction somewhere in install
> >>  > or readme that tells those who want to build for windows to copy
> >>  > from (or perhaps update cmake to offer the "-f" option and tell it
> >>  > to read from) contrib/cmake/CMakeLists.txt to the toplevel before
> >>  > doing anything [*1*].
> >>
> >>  FWIW, CMakeLists.txt doesn't have to be in the root of source tree in
> >>  order to work. It can perfectly work from contrib/cmake after necessary
> >>  changes in relative paths.
> >
> > Would you have an example handy, or a link to an article describing this?
>
> It's so trivial that I'm not sure what such an article would have to describe.
>
> https://github.com/annulen/cmake-example
>

> I have made the following changes as suggested:
> 1) The CMake script works from contrib/cmake now.
> 2) The CMake script parses the Makefile for
> SCRIPT_SH
> SCRIPT_PERL
> TEST_BUILTINS_OBJS
> LIB_OBJS
> BUILTIN_OBJS
> XDIFF_OBJS
> VCSSVN_OBJS
> 3) Philip suggested to change the error message if sh/bash was not
> found on windows.
> 4) CMake now tests for ICONV_OMITS_BOM, NO_ST_BLOCKS_IN_STRUCT_STAT.
>
> Regarding the commits, since 1,2,4 are additions to the script, is it
> acceptable for those changes to be staged in the next commits?

>
> Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
>
> > I have made the following changes as suggested:
> > 1) The CMake script works from contrib/cmake now.
> > 2) The CMake script parses the Makefile for
> > SCRIPT_SH
> > SCRIPT_PERL
> > TEST_BUILTINS_OBJS
> > LIB_OBJS
> > BUILTIN_OBJS
> > XDIFF_OBJS
> > VCSSVN_OBJS
> > 3) Philip suggested to change the error message if sh/bash was not
> > found on windows.
> > 4) CMake now tests for ICONV_OMITS_BOM, NO_ST_BLOCKS_IN_STRUCT_STAT.
> >
> > Regarding the commits, since 1,2,4 are additions to the script, is it
> > acceptable for those changes to be staged in the next commits?
>
> I am not sure what you exactly mean by "to be staged in the next
> commits".  But as a new topic (from the point of view of the general
> public), please avoid adding a known-broken one in patch 1 and then
> following up with a series of "oops, that was wrong and here is to
> fix the breakage" patches.
>
> On the other hand, if the final contents added by the resulting
> topic is easier to explain and review if built incrementally in
> logical steps, please do so.  In other words, a series of follow up
> "now we have basics there, teach the machinery to do this, too"
> patches is perfectly fine, as opposed to "oops, that was wrong and
> here is to fix".
>

> > Regarding the workflow file(main.yml), I modified the vs-build and
> > test steps, should I drop the commit or should I keep the changes(a
> > modification is further needed if CMake is going to be used for
> > vs-build)
>
> It sounds like an integral part of the end result we would want to
> get out of this series, so if that is the case, I do not see a
> reason to exclude it.
>
> Thanks.

> On Tue, May 5, 2020 at 11:47 PM Junio C Hamano <gitster@pobox.com> wrote:
> >
> > Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
> >
> > > I have made the following changes as suggested:
> > > 1) The CMake script works from contrib/cmake now.
> I am confused for 1 though.
> I think it would be better to add it as a new commit (between 7/8 and 8/8).
> Is this acceptable?

> Hi there,
>
> I have made the following changes as suggested:
> 1) The CMake script works from contrib/cmake now.
> 2) The CMake script parses the Makefile for
> SCRIPT_SH
> SCRIPT_PERL
> TEST_BUILTINS_OBJS
> LIB_OBJS
> BUILTIN_OBJS
> XDIFF_OBJS
> VCSSVN_OBJS
> 3) Philip suggested to change the error message if sh/bash was not
> found on windows.
> 4) CMake now tests for ICONV_OMITS_BOM, NO_ST_BLOCKS_IN_STRUCT_STAT.
>
> Regarding the commits, since 1,2,4 are additions to the script, is it
> acceptable for those changes to be staged in the next commits?
> Regarding the workflow file(main.yml), I modified the vs-build and
> test steps, should I drop the commit or should I keep the changes(a
> modification is further needed if CMake is going to be used for
> vs-build)

> 05.05.2020, 00:32, "Johannes Schindelin" <johannes.schindelin@gmx.de>:
> > Hi Konst,
> >
> > On Sun, 3 May 2020, Konstantin Tokarev wrote:
> >
> >>  03.05.2020, 20:21, "Junio C Hamano" <gitster@pobox.com>:
> >>  > Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
> >>  >
> >>  >>>  As you say, an extra instruction in INSTALL file to tell users to
> >>  >>>  copy from contrib/cmake may workable, though it is unsatisfactory.
> >>  >>>  But the other one will not simply work. If we need to have a new
> >>  >>>  file with string "CMake" in its name at the top-level *anyway*, we
> >>  >>>  should have the real thing to reduce one step from those who want to
> >>  >>>  use it. Those who do not want to see "CMake" at the toplevel are
> >>  >>>  already harmed either way, if is a dummy or if it is the real thing.
> >>  >>
> >>  >>  In your opinion, what would be the best way to communicate with users, there is
> >>  >>  an optional CMake build system for git?
> >>  >
> >>  > You do not want to hear my opinion, as my priorities would be
> >>  > different from yours ;-)
> >>  >
> >>  > Given that we all agreed that the only reason we contemplate use of
> >>  > CMake in our project is strictly to help Windows build, i.e. due to
> >>  > the same reason why we have contrib/buildsystems/, it is not one of
> >>  > my goals to communicate with general users about optional CMake
> >>  > support in the first place. It has lower priority than keeping the
> >>  > project tree and the project history less cluttered.
> >>  >
> >>  > So my first preference would be an instruction somewhere in install
> >>  > or readme that tells those who want to build for windows to copy
> >>  > from (or perhaps update cmake to offer the "-f" option and tell it
> >>  > to read from) contrib/cmake/CMakeLists.txt to the toplevel before
> >>  > doing anything [*1*].
> >>
> >>  FWIW, CMakeLists.txt doesn't have to be in the root of source tree in
> >>  order to work. It can perfectly work from contrib/cmake after necessary
> >>  changes in relative paths.
> >
> > Would you have an example handy, or a link to an article describing this?
>
> It's so trivial that I'm not sure what such an article would have to describe.
>
> https://github.com/annulen/cmake-example

> --
> Regards,
> Konstantin
>
>

> > > Please correct me if I were wrong (I recall this from my memory
> > > without checking anything).
> > >
> > > The worst thing about CMake is we can't override (Make's) variable
> > > in Makefile generated by CMake.
> >
> > I really don't know enough about cmake to say one way or the other. I
> > can well believe there are parts of the Makefile that will need to be
> > manually translated, and that it may not ever hit full parity.
> >
> > But as long as it just a tool for people using Visual Studio, and if
> > they are happier being able to use that tool, even with a few
> > deficiencies, then it may still be worth doing.
> Adding the CMake script to contrib/buildsystem is a good option.
> Is there any changes (apart from the CMakeLists.txt critique and) that
> I have to do on my part?

>
> Hi Sibi,
>
> On 2020-04-29 14:12:43+0530, Sibi Siddharthan <sibisiddharthan.github@gmail.com> wrote:
> > > > Please correct me if I were wrong (I recall this from my memory
> > > > without checking anything).
> > > >
> > > > The worst thing about CMake is we can't override (Make's) variable
> > > > in Makefile generated by CMake.
> > >
> > > I really don't know enough about cmake to say one way or the other. I
> > > can well believe there are parts of the Makefile that will need to be
> > > manually translated, and that it may not ever hit full parity.
> > >
> > > But as long as it just a tool for people using Visual Studio, and if
> > > they are happier being able to use that tool, even with a few
> > > deficiencies, then it may still be worth doing.
> > Adding the CMake script to contrib/buildsystem is a good option.
> > Is there any changes (apart from the CMakeLists.txt critique and) that
> > I have to do on my part?
>
> (Sorry for this late reply, it's holiday over here).
>
> It's long time since last time I worked with CMake, but I have some
> suggestion, maybe it was written in my previous comment, maybe not.
>
> - If we could find anything in CMake that equivalent with `sysconfdir`
>   in autotools, please use it for configuration files instead of
>   relative to `CMAKE_INSTALL_PREFIX`

> - I'll change (this and alikes)
>         find_program(SH_PATH, "sh")
>   with:
>         option(SHELL_PATH "path to POSIX compliance shell" "/bin/sh")
>   in order to support Solaris people, should they want to try CMake
> - I'll wrap the incompatible option of gettext under uname check
> - and remove ${} around variable in `if`
>

> On Sat, May 2, 2020 at 6:51 PM Danh Doan <congdanhqx@gmail.com> wrote:
> The thing with options in cmake is the values it takes are boolean only.
> To do what you want I think you have to do something along the lines of this.
> if(NOT DEFINED SHELL_PATH)
> set(SHELL_PATH  <default value> CACHE STRING "path to POSIX compliance shell")
> endif()
> 
> Then if you want to change this value, edit this value in CMakeCache.txt.

>
> On 2020-05-02 20:20:50+0530, Sibi Siddharthan <sibisiddharthan.github@gmail.com> wrote:
> > On Sat, May 2, 2020 at 6:51 PM Danh Doan <congdanhqx@gmail.com> wrote:
> > The thing with options in cmake is the values it takes are boolean only.
> > To do what you want I think you have to do something along the lines of this.
> > if(NOT DEFINED SHELL_PATH)
> > set(SHELL_PATH  <default value> CACHE STRING "path to POSIX compliance shell")
> > endif()
> >
> > Then if you want to change this value, edit this value in CMakeCache.txt.
>
> Ah, this is what I mean, I think it's better to use this (without
> if_not_define)
>
>         set(SHELL_PATH  "/bin/sh" CACHE PATH "path to POSIX compliance shell")
>
> Then, we can use this:
>
>         cmake -DSHELL_PATH=/path/to/good/sh ...
>

> I think what I'm suggesting is not all that different from this, except
> that I'd suspect "next" would not get enough exposure. So in my mind
> merging to master is not so much "hooray, we now have visual studio
> support" but rather the first step in getting data. But we'd have to be
> very clear about how the project regards the cmake support: it's there
> for now, you're encouraged to play with it, but don't be upset if it
> needs some coaxing to behave like the normal Makefile or if it goes away
> in the future.

> Jeff King <peff@peff.net> writes:
> 
> > I think what I'm suggesting is not all that different from this, except
> > that I'd suspect "next" would not get enough exposure. So in my mind
> > merging to master is not so much "hooray, we now have visual studio
> > support" but rather the first step in getting data. But we'd have to be
> > very clear about how the project regards the cmake support: it's there
> > for now, you're encouraged to play with it, but don't be upset if it
> > needs some coaxing to behave like the normal Makefile or if it goes away
> > in the future.  
> 
> I think you said almost everything I would have said.  
> 
> If we were to adopt it as an experiment, hoping to gain exposure,
> nothing above 'master' (or tagged releases) won't work.  And once a
> thing is in 'master', users will ignore the "this is merely an
> experiment" warning and expect it to be fully functional and usable.
> 
> Given the observation in the thread that it would take a fairly
> recent version to benefit platform-agnostic usability features, I
> did not get an impression that it is ready to be anywhere near that,
> not even ready for 'next'.  It is *not* like "Sibi's patches were
> bad but they can become ready with further polishing".  The
> impression I got was that the large part of why it is not ready is
> because it needs time for larger set of distros to adopt more recent
> versions of cmake.
> 

> But in the meantime, those who are interested in building Git with
> cmake do not have to wait, doing nothing, I would imagine.  I wonder
> if they can work on a separate project (let's call it git-on-cmake)
> whose sole purpose is to develop and polish CMakeLists.txt, waiting
> for an advanced enough version of cmake becomes commonplace.  Then,
> anybody who are interested and has recent cmake can subtree-merge
> git-on-cmake project into their own clone of our project somewhere,
> and help developing git-on-cmake further.

>
> On Mon, Apr 27, 2020 at 02:17:32PM -0700, Junio C Hamano wrote:
>
> > If we were to adopt it as an experiment, hoping to gain exposure,
> > nothing above 'master' (or tagged releases) won't work.  And once a
> > thing is in 'master', users will ignore the "this is merely an
> > experiment" warning and expect it to be fully functional and usable.
>
> Yeah, that is a problem. I wonder if the state would be more obvious if
> it lived in contrib/. We already have contrib/buildsystems,
> which seems like an earlier attempt at this exact problem?
>
> > But in the meantime, those who are interested in building Git with
> > cmake do not have to wait, doing nothing, I would imagine.  I wonder
> > if they can work on a separate project (let's call it git-on-cmake)
> > whose sole purpose is to develop and polish CMakeLists.txt, waiting
> > for an advanced enough version of cmake becomes commonplace.  Then,
> > anybody who are interested and has recent cmake can subtree-merge
> > git-on-cmake project into their own clone of our project somewhere,
> > and help developing git-on-cmake further.
>
> I think there's actually a good reason to have it in your tree: people
> use your tree as the basis to build (and submit!) changes.
>
> I noticed the same thing with trying to play with CI changes. As a
> contributor, yes I _can_ make my CI changes, and then base my branches
> on that. But it gets rather awkward juggling branches that contain some
> changes that should go upstream, and some which should not. And quite a
> bit more difficult if people want to use tools like GitGitGadget to just
> target a PR against git.git and send it to the mailing list.
>
> If it lived in contrib/ that might strike a good balance between making
> it available for people to experiment with, but not having people
> confuse it for the official build system.

> > If it lived in contrib/ that might strike a good balance between making
> > it available for people to experiment with, but not having people
> > confuse it for the official build system.
> 
> Maybe we could move configure.ac and config.mak.in into contrib as well?

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
>
> This patch implements the placeholder substitution to generate, say,
> `git-request-pull` from `git-request-pull.sh`.
>
> The shell/perl/python scripts and template are generated using CMake
> (very similar to what sed does).

>
> "Sibi Siddharthan via GitGitGadget" <gitgitgadget@gmail.com> writes:
>
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >
> > This patch implements the placeholder substitution to generate, say,
> > `git-request-pull` from `git-request-pull.sh`.
> >
> > The shell/perl/python scripts and template are generated using CMake
> > (very similar to what sed does).
>
> We do not say "This patch does X" or "I do Y in this patch".
> perhaps.
>
>         Implement the placeholder substitution to generate scripted
>         Porcelain commands, e.g. git-request-pull out of
>         git-request-pull.sh
>
>         Generate scripts and templates using CMake, instead of using
>         sed like the build procedure in the Makefile does.
>

> To make this a little less awkward, the Git for Windows project offers
> the `vs/master` branch which has a full Visual Studio solution generated
> and committed. This branch can therefore be used to tinker with Git in
> Visual Studio _without_ having to download the full Git for Windows SDK.
> Unfortunatly, that branch is auto-generated from Git for Windows'
> `master`. If a developer wants to tinker, say, with `pu`, they are out
> of luck.

> This is only the first step, and to make it easier to review, it only
> allows for configuring builds on the platform that is easiest to
> configure for: Linux.
>
> The CMake script checks whether the headers are present(eg. libgen.h),
> whether the functions are present(eg. memmem), whether the funtions work
> properly (eg. snprintf) and generate the required compile definitions
> for the platform. The script also searches for the required libraries,
> if it fails to find the required libraries the respective executables
> won't be built.(eg. If libcurl is not found then git-remote-http won't
> be built). This will help building Git easier.
>
> With a CMake script an out of source build of git is possible resulting
> in a clean source tree.

> Note: earlier endeavors on the Git mailing list to introduce CMake ended
> up in dead water. The primary reason for that was that reviewers
> _expected_ CMake support to fall out of maintenance, unless the
> contributor would promise to keep an eye on keeping CMake support up to
> date. However, in the meantime, support for automated testing has been
> introduced in Git's source code, and a later patch will modify the
> (still experimental) GitHub workflow to continually verify that CMake
> support is still complete. That will make maintenance reasonably easy.

> Note: this patch asks for the minimum version v3.14 of CMake (which is
> not all that old as of time of writing) because that is the first
> version to offer a platform-independent way to generate hardlinks as
> part of the build. This is needed to generate all those hardlinks for
> the built-in commands of Git.

> Instructions to run CMake:
>
> cmake `relative-path-to-srcdir` -DCMAKE_BUILD_TYPE=Release
>
> Possible build configurations(-DCMAKE_BUILD_TYPE) with corresponding
> compiler flags
> Debug : -g
> Release: -O3
> RelWithDebInfo : -O2 -g
> MinSizeRel : -Os
> empty(default) :
>
> NOTE: -DCMAKE_BUILD_TYPE is optional
>
> This process generates a Makefile.
> Then run `make` to build Git.
>
> NOTE: By default CMake uses Makefile as the build tool on Linux, to use
> another tool say `ninja` add this to the command line when configuring.
> `-G Ninja`

> Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> ---
>  CMakeLists.txt | 528 +++++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 528 insertions(+)
>  create mode 100644 CMakeLists.txt
>
> diff --git a/CMakeLists.txt b/CMakeLists.txt
> new file mode 100644
> index 00000000000..73703bd321f
> --- /dev/null
> +++ b/CMakeLists.txt
> @@ -0,0 +1,528 @@
> +#
> +#	Copyright (c) 2020 Sibi Siddharthan
> +#
> +
> +cmake_minimum_required(VERSION 3.14)
> +
> +#Parse GIT-VERSION-GEN to get the version
> +file(STRINGS ${CMAKE_SOURCE_DIR}/GIT-VERSION-GEN git_version REGEX "DEF_VER=v(.*)")
> +string(REPLACE "DEF_VER=v" "" git_version ${git_version})
> +string(REPLACE ".GIT" ".0" git_version ${git_version})#for building from a snapshot

> +set(git_SOURCES
> +	builtin/add.c builtin/am.c builtin/annotate.c builtin/apply.c
> +	builtin/archive.c builtin/bisect--helper.c builtin/blame.c
> +	builtin/branch.c builtin/bundle.c builtin/cat-file.c builtin/check-attr.c
> +	builtin/check-ignore.c builtin/check-mailmap.c builtin/check-ref-format.c
> +	builtin/checkout-index.c builtin/checkout.c builtin/clean.c
> +	builtin/clone.c builtin/column.c builtin/commit-tree.c
> +	builtin/commit.c builtin/commit-graph.c builtin/config.c
> +	builtin/count-objects.c builtin/credential.c builtin/describe.c
> +	builtin/diff-files.c builtin/diff-index.c builtin/diff-tree.c
> +	builtin/diff.c builtin/difftool.c builtin/env--helper.c
> +	builtin/fast-export.c builtin/fetch-pack.c builtin/fetch.c builtin/fmt-merge-msg.c
> +	builtin/for-each-ref.c builtin/fsck.c builtin/gc.c
> +	builtin/get-tar-commit-id.c builtin/grep.c builtin/hash-object.c
> +	builtin/help.c builtin/index-pack.c builtin/init-db.c
> +	builtin/interpret-trailers.c builtin/log.c builtin/ls-files.c
> +	builtin/ls-remote.c builtin/ls-tree.c builtin/mailinfo.c builtin/mailsplit.c
> +	builtin/merge.c builtin/merge-base.c builtin/merge-file.c builtin/merge-index.c
> +	builtin/merge-ours.c builtin/merge-recursive.c builtin/merge-tree.c
> +	builtin/mktag.c builtin/mktree.c builtin/multi-pack-index.c builtin/mv.c
> +	builtin/name-rev.c builtin/notes.c builtin/pack-objects.c builtin/pack-redundant.c
> +	builtin/pack-refs.c builtin/patch-id.c builtin/prune-packed.c builtin/prune.c
> +	builtin/pull.c builtin/push.c builtin/range-diff.c builtin/read-tree.c
> +	builtin/rebase.c builtin/receive-pack.c builtin/reflog.c builtin/remote.c
> +	builtin/remote-ext.c builtin/remote-fd.c builtin/repack.c builtin/replace.c
> +	builtin/rerere.c builtin/reset.c builtin/rev-list.c builtin/rev-parse.c
> +	builtin/revert.c builtin/rm.c builtin/send-pack.c builtin/shortlog.c
> +	builtin/show-branch.c builtin/show-index.c builtin/show-ref.c
> +	builtin/sparse-checkout.c builtin/stash.c builtin/stripspace.c
> +	builtin/submodule--helper.c builtin/symbolic-ref.c builtin/tag.c
> +	builtin/unpack-file.c builtin/unpack-objects.c builtin/update-index.c
> +	builtin/update-ref.c builtin/update-server-info.c builtin/upload-archive.c
> +	builtin/upload-pack.c builtin/var.c builtin/verify-commit.c builtin/verify-pack.c
> +	builtin/verify-tag.c builtin/worktree.c builtin/write-tree.c)

>
> "Sibi Siddharthan via GitGitGadget" <gitgitgadget@gmail.com> writes:
>
> > To make this a little less awkward, the Git for Windows project offers
> > the `vs/master` branch which has a full Visual Studio solution generated
> > and committed. This branch can therefore be used to tinker with Git in
> > Visual Studio _without_ having to download the full Git for Windows SDK.
> > Unfortunatly, that branch is auto-generated from Git for Windows'
> > `master`. If a developer wants to tinker, say, with `pu`, they are out
> > of luck.
>
> 'pu' or 'next' are not to be built upon, so this is not a good line
> of reasoning to complain that generating only for 'master' is bad.
>
> > CMake was invented to make this sort of problem go away, by providing a
> > more standardized, cross-platform way to configure builds.
>
> I think everything above this point (including Makefile, autoconf
> etc.) can be replaced with a single sentence
>
>         The build infrastructure for Git is written around being
>         able to run make, which is not supported natively on
>         Windows.
>
> without anything else.  That will flow naturally to
>
>         Add a build script that uses CMake to help developers on
>         Windows to build git.
>
> and then you can continue the current state, like this paragraph.
>
> > This is only the first step, and to make it easier to review, it only
> > allows for configuring builds on the platform that is easiest to
> > configure for: Linux.
> >
> > The CMake script checks whether the headers are present(eg. libgen.h),
> > whether the functions are present(eg. memmem), whether the funtions work
> > properly (eg. snprintf) and generate the required compile definitions
> > for the platform. The script also searches for the required libraries,
> > if it fails to find the required libraries the respective executables
> > won't be built.(eg. If libcurl is not found then git-remote-http won't
> > be built). This will help building Git easier.
> >
> > With a CMake script an out of source build of git is possible resulting
> > in a clean source tree.
>
>
> > Note: earlier endeavors on the Git mailing list to introduce CMake ended
> > up in dead water. The primary reason for that was that reviewers
> > _expected_ CMake support to fall out of maintenance, unless the
> > contributor would promise to keep an eye on keeping CMake support up to
> > date. However, in the meantime, support for automated testing has been
> > introduced in Git's source code, and a later patch will modify the
> > (still experimental) GitHub workflow to continually verify that CMake
> > support is still complete. That will make maintenance reasonably easy.
>
> I am not sure this belongs to the log message.
>

> > Note: this patch asks for the minimum version v3.14 of CMake (which is
> > not all that old as of time of writing) because that is the first
> > version to offer a platform-independent way to generate hardlinks as
> > part of the build. This is needed to generate all those hardlinks for
> > the built-in commands of Git.
>
> This does, but I do not think hardlinks are not required for our
> build.  On Unix filesystems, it is not just possible but convenient
> to use, and that is the only reason why we use hardlinks.
>
> If hardlinks are possible but inconvenient to use on Windows, you
> shouldn't force your target audience to use it.

>
> > Instructions to run CMake:
> >
> > cmake `relative-path-to-srcdir` -DCMAKE_BUILD_TYPE=Release
> >
> > Possible build configurations(-DCMAKE_BUILD_TYPE) with corresponding
> > compiler flags
> > Debug : -g
> > Release: -O3
> > RelWithDebInfo : -O2 -g
> > MinSizeRel : -Os
> > empty(default) :
> >
> > NOTE: -DCMAKE_BUILD_TYPE is optional
> >
> > This process generates a Makefile.
> > Then run `make` to build Git.
> >
> > NOTE: By default CMake uses Makefile as the build tool on Linux, to use
> > another tool say `ninja` add this to the command line when configuring.
> > `-G Ninja`
>
> I find it curious that from the instruction, the most important
> platform, the primary reason why we are reviewing this patch, is
> missing.  Don't Windows folks need to be told how to run CMake to
> build?

>
> In any case, all of the above "Instructions" should go at the top
> part of CMakeLists.txt in a comment, and not in the log message.
> "git log" output is not an easy way for your target audience to
> learn how to use what the commit adds.  Think what they need to do
> when they discover there is CMakeLists.txt in our tree in three
> months.  Don't force them to run "git blame" to find this commit
> that added the support.

>
> > Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > ---
> >  CMakeLists.txt | 528 +++++++++++++++++++++++++++++++++++++++++++++++++
> >  1 file changed, 528 insertions(+)
> >  create mode 100644 CMakeLists.txt
> >
> > diff --git a/CMakeLists.txt b/CMakeLists.txt
> > new file mode 100644
> > index 00000000000..73703bd321f
> > --- /dev/null
> > +++ b/CMakeLists.txt
> > @@ -0,0 +1,528 @@
> > +#
> > +#    Copyright (c) 2020 Sibi Siddharthan
> > +#
> > +
> > +cmake_minimum_required(VERSION 3.14)
> > +
> > +#Parse GIT-VERSION-GEN to get the version
> > +file(STRINGS ${CMAKE_SOURCE_DIR}/GIT-VERSION-GEN git_version REGEX "DEF_VER=v(.*)")
> > +string(REPLACE "DEF_VER=v" "" git_version ${git_version})
> > +string(REPLACE ".GIT" ".0" git_version ${git_version})#for building from a snapshot
>
> Hmph, I'd really prefer to see the logic in GIT-VERSION-GEN not
> bypassed like this.  People know they can create a text file 'version'
> and record the version name they desire in it and expect GIT-VERSION-GEN
> to pick it up, for example.
>
> Later in this file, you seem to depend on the shell to do things
> like generating config-list.h file, so I'd rather see the same
> technique used here a well.
>
> > +set(libgit_SOURCES
> > +     abspath.c add-interactive.c add-patch.c advice.c alias.c
> > +...
> > +     zlib.c)
>
> Hmph.
>
> > +set(git_SOURCES
> > +     builtin/add.c builtin/am.c builtin/annotate.c builtin/apply.c
> > +     builtin/archive.c builtin/bisect--helper.c builtin/blame.c
> > +     builtin/branch.c builtin/bundle.c builtin/cat-file.c builtin/check-attr.c
> > +     builtin/check-ignore.c builtin/check-mailmap.c builtin/check-ref-format.c
> > +     builtin/checkout-index.c builtin/checkout.c builtin/clean.c
> > +     builtin/clone.c builtin/column.c builtin/commit-tree.c
> > +     builtin/commit.c builtin/commit-graph.c builtin/config.c
> > +     builtin/count-objects.c builtin/credential.c builtin/describe.c
> > +     builtin/diff-files.c builtin/diff-index.c builtin/diff-tree.c
> > +     builtin/diff.c builtin/difftool.c builtin/env--helper.c
> > +     builtin/fast-export.c builtin/fetch-pack.c builtin/fetch.c builtin/fmt-merge-msg.c
> > +     builtin/for-each-ref.c builtin/fsck.c builtin/gc.c
> > +     builtin/get-tar-commit-id.c builtin/grep.c builtin/hash-object.c
> > +     builtin/help.c builtin/index-pack.c builtin/init-db.c
> > +     builtin/interpret-trailers.c builtin/log.c builtin/ls-files.c
> > +     builtin/ls-remote.c builtin/ls-tree.c builtin/mailinfo.c builtin/mailsplit.c
> > +     builtin/merge.c builtin/merge-base.c builtin/merge-file.c builtin/merge-index.c
> > +     builtin/merge-ours.c builtin/merge-recursive.c builtin/merge-tree.c
> > +     builtin/mktag.c builtin/mktree.c builtin/multi-pack-index.c builtin/mv.c
> > +     builtin/name-rev.c builtin/notes.c builtin/pack-objects.c builtin/pack-redundant.c
> > +     builtin/pack-refs.c builtin/patch-id.c builtin/prune-packed.c builtin/prune.c
> > +     builtin/pull.c builtin/push.c builtin/range-diff.c builtin/read-tree.c
> > +     builtin/rebase.c builtin/receive-pack.c builtin/reflog.c builtin/remote.c
> > +     builtin/remote-ext.c builtin/remote-fd.c builtin/repack.c builtin/replace.c
> > +     builtin/rerere.c builtin/reset.c builtin/rev-list.c builtin/rev-parse.c
> > +     builtin/revert.c builtin/rm.c builtin/send-pack.c builtin/shortlog.c
> > +     builtin/show-branch.c builtin/show-index.c builtin/show-ref.c
> > +     builtin/sparse-checkout.c builtin/stash.c builtin/stripspace.c
> > +     builtin/submodule--helper.c builtin/symbolic-ref.c builtin/tag.c
> > +     builtin/unpack-file.c builtin/unpack-objects.c builtin/update-index.c
> > +     builtin/update-ref.c builtin/update-server-info.c builtin/upload-archive.c
> > +     builtin/upload-pack.c builtin/var.c builtin/verify-commit.c builtin/verify-pack.c
> > +     builtin/verify-tag.c builtin/worktree.c builtin/write-tree.c)
>
> Can't we do a bit better here?
>
> Perhaps grab this out of our Makefile?  The same command applies to
> huge lists of sources we have seen.
>
> Or do the equivalent of $(wildcard builtin/*.c) if CMake has such a
> feature?
>

> > ...
> > \ No newline at end of file
>
> Double check and make sure you have a text file without an incomplete
> line at the end.
>
> Thanks.

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> diff --git a/CMakeLists.txt b/CMakeLists.txt
> index 47d3f3c2866..9625e41886f 100644
> --- a/CMakeLists.txt
> +++ b/CMakeLists.txt
> @@ -13,9 +13,12 @@ project(git
>  	VERSION ${git_version}
>  	LANGUAGES C)
>  
> +

>
> Hi Sibi,
>
> On 2020-05-12 16:50:49+0000, Sibi Siddharthan via GitGitGadget <gitgitgadget@gmail.com> wrote:
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > diff --git a/CMakeLists.txt b/CMakeLists.txt
> > index 47d3f3c2866..9625e41886f 100644
> > --- a/CMakeLists.txt
> > +++ b/CMakeLists.txt
> > @@ -13,9 +13,12 @@ project(git
> >       VERSION ${git_version}
> >       LANGUAGES C)
> >
> > +
>
> This newline maybe left from debugging. (and other new newline below).
>
> > +#Platform Specific
> > +if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
>
> Please drop ${} around CMAKE_SYSTEM_NAME, here (and other if)
> Or user may accidental messed up.
> ------------8<----------------
> $ cat CMakeLists.txt
> project(test)
> message("This is ${CMAKE_SYSTEM_NAME}")
> if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
>         message("Yes, STREQUAL Windows")
> endif()
> $ cmake . -DLinux=Windows
> This is Linux
> Yes, STREQUAL Windows
> -- Configuring done
> -- Generating done
> -- Build files have been written to: /tmp
> ---------------->8--------------
>

> diff --git a/CMakeLists.txt b/CMakeLists.txt
> index 4353080b708..975791c8b89 100644
> --- a/CMakeLists.txt
> +++ b/CMakeLists.txt
> @@ -22,6 +22,7 @@ project(git
>  include(CheckTypeSize)
>  include(CheckCSourceRuns)
>  include(CheckCSourceCompiles)
> +include(CheckCSourceRuns)
> ...
> +#check for st_blocks in struct stat
> +check_struct_has_member("struct stat" st_blocks "sys/stat.h" STRUCT_STAT_HAS_ST_BLOCKS)
> +if(NOT STRUCT_STAT_HAS_ST_BLOCKS)
> +	add_compile_definitions(NO_ST_BLOCKS_IN_STRUCT_STAT)
> +endif()

>
> "Sibi Siddharthan via GitGitGadget" <gitgitgadget@gmail.com> writes:
>
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > Subject: Re: [PATCH v2 08/11] cmake: added checks for struct stat and libiconv
>
> s/added/add/; give a command to the codebase to "be like so", or a
> command to whoever is typing changes to the editor to "make this
> happen".
>
> > The CMake script now checks whether st_blocks is a member of struct stat
> > and set the compile definition NO_ST_BLOCKS_IN_STRUCT_STAT accordingly.
>
>         Teach the CMake script to check ...
>
> > diff --git a/CMakeLists.txt b/CMakeLists.txt
> > index 4353080b708..975791c8b89 100644
> > --- a/CMakeLists.txt
> > +++ b/CMakeLists.txt
> > @@ -22,6 +22,7 @@ project(git
> >  include(CheckTypeSize)
> >  include(CheckCSourceRuns)
> >  include(CheckCSourceCompiles)
> > +include(CheckCSourceRuns)
> > ...
> > +#check for st_blocks in struct stat
> > +check_struct_has_member("struct stat" st_blocks "sys/stat.h" STRUCT_STAT_HAS_ST_BLOCKS)
> > +if(NOT STRUCT_STAT_HAS_ST_BLOCKS)
> > +     add_compile_definitions(NO_ST_BLOCKS_IN_STRUCT_STAT)
> > +endif()
>
> All of these compatibility stuff makes sense, but how do we decide
> where to draw the line between the checks we saw added in [01/11]
> and the checks added here?  It feels pretty arbitrary to me and if
> that is the case, perhaps we want to move all the "add checks" to a
> commit separate from [01/11] (whose primary purpose is to add the
> basic rules without these build tweaks in the file at the final
> place)?
>

>> All of these compatibility stuff makes sense, but how do we decide
>> where to draw the line between the checks we saw added in [01/11]
>> and the checks added here?  It feels pretty arbitrary to me and if
>> that is the case, perhaps we want to move all the "add checks" to a
>> commit separate from [01/11] (whose primary purpose is to add the
>> basic rules without these build tweaks in the file at the final
>> place)?
>>
>
> The checks are added on a "demand" based the target platform.
> In the future, if apple support is needed, we need to add ST_TIMESPEC checks.

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> 
> The CMake script now checks whether st_blocks is a member of struct stat
> and set the compile definition NO_ST_BLOCKS_IN_STRUCT_STAT accordingly.
> 
> The check for whether ICONV_OMITS_BOM is also added as requested by Danh.

> Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> ---
>  CMakeLists.txt | 59 ++++++++++++++++++++++++++++++++++++++++++++++++--
>  1 file changed, 57 insertions(+), 2 deletions(-)
> 
> diff --git a/CMakeLists.txt b/CMakeLists.txt
> index 4353080b708..975791c8b89 100644
> --- a/CMakeLists.txt
> +++ b/CMakeLists.txt
> @@ -22,6 +22,7 @@ project(git
>  include(CheckTypeSize)
>  include(CheckCSourceRuns)
>  include(CheckCSourceCompiles)
> +include(CheckCSourceRuns)
>  include(CheckIncludeFile)
>  include(CheckFunctionExists)
>  include(CheckSymbolExists)
> @@ -128,7 +129,7 @@ if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
>  	include_directories(compat/win32)
>  	add_compile_definitions(HAVE_ALLOCA_H NO_POSIX_GOODIES NATIVE_CRLF NO_UNIX_SOCKETS WIN32
>  				_CONSOLE DETECT_MSYS_TTY STRIP_EXTENSION=".exe"  NO_SYMLINK_HEAD UNRELIABLE_FSTAT
> -				NOGDI OBJECT_CREATION_MODE=1 __USE_MINGW_ANSI_STDIO=0 NO_ST_BLOCKS_IN_STRUCT_STAT
> +				NOGDI OBJECT_CREATION_MODE=1 __USE_MINGW_ANSI_STDIO=0
>  				USE_NED_ALLOCATOR OVERRIDE_STRDUP MMAP_PREVENTS_DELETE USE_WIN32_MMAP
>  				UNICODE _UNICODE HAVE_WPGMPTR ENSURE_MSYSTEM_IS_SET)
>  	list(APPEND compat_SOURCES compat/mingw.c compat/winansi.c compat/win32/path-utils.c
> @@ -280,6 +281,11 @@ if(HAVE_CLOCK_MONOTONIC)
>  	add_compile_definitions(HAVE_CLOCK_MONOTONIC)
>  endif()
>  
> +#check for st_blocks in struct stat
> +check_struct_has_member("struct stat" st_blocks "sys/stat.h" STRUCT_STAT_HAS_ST_BLOCKS)
> +if(NOT STRUCT_STAT_HAS_ST_BLOCKS)
> +	add_compile_definitions(NO_ST_BLOCKS_IN_STRUCT_STAT)
> +endif()
>  
>  #compile checks
>  check_c_source_runs("
> @@ -344,7 +350,6 @@ if(NOT HAVE_REGEX)
>  	add_compile_definitions(NO_REGEX NO_MBSUPPORT GAWK)
>  endif()
>  
> -
>  check_c_source_compiles("
>  #include <stddef.h>
>  #include <sys/types.h>
> @@ -368,6 +373,56 @@ if(HAVE_BSD_SYSCTL)
>  	add_compile_definitions(HAVE_BSD_SYSCTL)
>  endif()
>  
> +set(CMAKE_REQUIRED_LIBRARIES ${Iconv_LIBRARIES})
> +set(CMAKE_REQUIRED_INCLUDES ${Iconv_INCLUDE_DIRS})
> +
> +check_c_source_compiles("
> +#include <iconv.h>
> +
> +extern size_t iconv(iconv_t cd,
> +		char **inbuf, size_t *inbytesleft,
> +		char **outbuf, size_t *outbytesleft);
> +
> +int main(){return 0;}"
> +HAVE_NEW_ICONV)
> +if(HAVE_NEW_ICONV)
> +	set(HAVE_OLD_ICONV 0)
> +else()
> +	set(HAVE_OLD_ICONV 1)
> +endif()
> +
> +check_c_source_runs("
> +#include <iconv.h>
> +#if ${HAVE_OLD_ICONV}
> +typedef const char *iconv_ibp;
> +#else
> +typedef char *iconv_ibp;
> +#endif
> +
> +int main()
> +{
> +	int v;
> +	iconv_t conv;
> +	char in[] = \"a\"; iconv_ibp pin = in;
> +	char out[20] = \"\"; char *pout = out;
> +	size_t isz = sizeof in;
> +	size_t osz = sizeof out;
> +
> +	conv = iconv_open(\"UTF-16\", \"UTF-8\");
> +	iconv(conv, &pin, &isz, &pout, &osz);
> +	iconv_close(conv);
> +	v = (unsigned char)(out[0]) + (unsigned char)(out[1]);
> +	return v != 0xfe + 0xff;
> +}"

>
> On 2020-05-12 16:50:51+0000, Sibi Siddharthan via GitGitGadget <gitgitgadget@gmail.com> wrote:
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >
> > The CMake script now checks whether st_blocks is a member of struct stat
> > and set the compile definition NO_ST_BLOCKS_IN_STRUCT_STAT accordingly.
> >
> > The check for whether ICONV_OMITS_BOM is also added as requested by Danh.
>
> Please don't write my name in the commit message like this.
> This maybe rephased to:
>
>         While we're as it, add the check for ICONV_OMITS_BOM.

>
> > Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > ---
> >  CMakeLists.txt | 59 ++++++++++++++++++++++++++++++++++++++++++++++++--
> >  1 file changed, 57 insertions(+), 2 deletions(-)
> >
> > diff --git a/CMakeLists.txt b/CMakeLists.txt
> > index 4353080b708..975791c8b89 100644
> > --- a/CMakeLists.txt
> > +++ b/CMakeLists.txt
> > @@ -22,6 +22,7 @@ project(git
> >  include(CheckTypeSize)
> >  include(CheckCSourceRuns)
> >  include(CheckCSourceCompiles)
> > +include(CheckCSourceRuns)
> >  include(CheckIncludeFile)
> >  include(CheckFunctionExists)
> >  include(CheckSymbolExists)
> > @@ -128,7 +129,7 @@ if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
> >       include_directories(compat/win32)
> >       add_compile_definitions(HAVE_ALLOCA_H NO_POSIX_GOODIES NATIVE_CRLF NO_UNIX_SOCKETS WIN32
> >                               _CONSOLE DETECT_MSYS_TTY STRIP_EXTENSION=".exe"  NO_SYMLINK_HEAD UNRELIABLE_FSTAT
> > -                             NOGDI OBJECT_CREATION_MODE=1 __USE_MINGW_ANSI_STDIO=0 NO_ST_BLOCKS_IN_STRUCT_STAT
> > +                             NOGDI OBJECT_CREATION_MODE=1 __USE_MINGW_ANSI_STDIO=0
> >                               USE_NED_ALLOCATOR OVERRIDE_STRDUP MMAP_PREVENTS_DELETE USE_WIN32_MMAP
> >                               UNICODE _UNICODE HAVE_WPGMPTR ENSURE_MSYSTEM_IS_SET)
> >       list(APPEND compat_SOURCES compat/mingw.c compat/winansi.c compat/win32/path-utils.c
> > @@ -280,6 +281,11 @@ if(HAVE_CLOCK_MONOTONIC)
> >       add_compile_definitions(HAVE_CLOCK_MONOTONIC)
> >  endif()
> >
> > +#check for st_blocks in struct stat
> > +check_struct_has_member("struct stat" st_blocks "sys/stat.h" STRUCT_STAT_HAS_ST_BLOCKS)
> > +if(NOT STRUCT_STAT_HAS_ST_BLOCKS)
> > +     add_compile_definitions(NO_ST_BLOCKS_IN_STRUCT_STAT)
> > +endif()
> >
> >  #compile checks
> >  check_c_source_runs("
> > @@ -344,7 +350,6 @@ if(NOT HAVE_REGEX)
> >       add_compile_definitions(NO_REGEX NO_MBSUPPORT GAWK)
> >  endif()
> >
> > -
> >  check_c_source_compiles("
> >  #include <stddef.h>
> >  #include <sys/types.h>
> > @@ -368,6 +373,56 @@ if(HAVE_BSD_SYSCTL)
> >       add_compile_definitions(HAVE_BSD_SYSCTL)
> >  endif()
> >
> > +set(CMAKE_REQUIRED_LIBRARIES ${Iconv_LIBRARIES})
> > +set(CMAKE_REQUIRED_INCLUDES ${Iconv_INCLUDE_DIRS})
> > +
> > +check_c_source_compiles("
> > +#include <iconv.h>
> > +
> > +extern size_t iconv(iconv_t cd,
> > +             char **inbuf, size_t *inbytesleft,
> > +             char **outbuf, size_t *outbytesleft);
> > +
> > +int main(){return 0;}"
> > +HAVE_NEW_ICONV)
> > +if(HAVE_NEW_ICONV)
> > +     set(HAVE_OLD_ICONV 0)
> > +else()
> > +     set(HAVE_OLD_ICONV 1)
> > +endif()
> > +
> > +check_c_source_runs("
> > +#include <iconv.h>
> > +#if ${HAVE_OLD_ICONV}
> > +typedef const char *iconv_ibp;
> > +#else
> > +typedef char *iconv_ibp;
> > +#endif
> > +
> > +int main()
> > +{
> > +     int v;
> > +     iconv_t conv;
> > +     char in[] = \"a\"; iconv_ibp pin = in;
> > +     char out[20] = \"\"; char *pout = out;
> > +     size_t isz = sizeof in;
> > +     size_t osz = sizeof out;
> > +
> > +     conv = iconv_open(\"UTF-16\", \"UTF-8\");
> > +     iconv(conv, &pin, &isz, &pout, &osz);
> > +     iconv_close(conv);
> > +     v = (unsigned char)(out[0]) + (unsigned char)(out[1]);
> > +     return v != 0xfe + 0xff;
> > +}"
>
> I think the closing double-quote should be placed in a newline,
> in order to make sure the source file ended with newline,
> old C standard requires final newline.
>

>
> "Sibi Siddharthan via GitGitGadget" <gitgitgadget@gmail.com> writes:
>
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > Subject: Re: [PATCH v2 11/11] ci: modification of main.yml to use cmake for vs-build job
>
> Yay!
>
> > This patch modifies .github/workflows/main.yml to use CMake for
> > Visual Studio builds.
> > Modified the vs-test step to match windows-test step. This speeds
>
>         Teach .github/workflows/main.yml to use Cmake for VS builds.
>         Modify vs-test step to match windows-test step to speed up
>         the vs-test.
>
> > Changes:
> > The CMake script has been relocated to contib/buildsystems, so point
> > to the CMakeLists.txt in the invocation commands.
>
> This does not belong to the log message for this (or any for that
> matter) commit, no?  Up to this point, nothing in main.yml used
> CMake script from anywhere, and "has been relocated" is irrelevant.
>

> And if we add CMake script to contrib/buildsystems/ from the
> beginning in [01/11], there won't be any "relocation" the readers of
> the log message of this step need to know about.
>
> > The generation command now uses the absolute paths for the generation
> > step.
>
> "now uses"?  Is that something the readers of the log message of
> this step need to know about, or is it "in contrast to an earlier
> attempt to add CMake script"?  If the latter, it only confuses the
> readers of our history, as most of them will not even know about an
> earlier attempt.

> 1) Relocating the CMake script to contrib/buildsystems from patch 01/xx.
> 2) Parse the Makefile for sources from patch 01/xx.
> 3) Reworded the commit messages you pointed out.
> 4) Rebased the ST_BLOCKS_IN_STRUCT_STAT and ICONV_OMITS_BOM to patch
> 01/xx to make the review process easier.
> ...
> No new features will be introduced in the script, to make the review
> process easier.

>
> Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
>
> > 1) Relocating the CMake script to contrib/buildsystems from patch 01/xx.
> > 2) Parse the Makefile for sources from patch 01/xx.
> > 3) Reworded the commit messages you pointed out.
> > 4) Rebased the ST_BLOCKS_IN_STRUCT_STAT and ICONV_OMITS_BOM to patch
> > 01/xx to make the review process easier.
> > ...
> > No new features will be introduced in the script, to make the review
> > process easier.
>
> You did not answer <xmqqd077qnqc.fsf@gitster.c.googlers.com>,
> so I have to guess.

>
> I am guessing that your answer would be that if we keep this series
> concentrate only on Windows support from the beginning and do not
> add support for any other platform at all, the scope and necessary
> effort to bring the patches in reviewable shape would be reduced
> dramatically.  And if that is the case, that would be great.
>
> In other words, I'd prefer not just "no new features", but "with
> much less features, now we do not even add support for Linux or
> macOS to the initial patch series".

>
> But because I haven't heard the question answered, I cannot tell if
> that level of simplification is possible and if that is already what
> you did in (silent) response to my questions.
>
> > I have looked at the GIT-VERSION-GEN script and the logic it uses to
> > determine the version of git.
> > The logic is a bit complicated to be implemented in a  CMake script,
> > so I am skipping it for now.
>
> Regarding the generation of GIT-VERSION-FILE, I asked you why you
> need to hand-parse, instead of running the script itself, which is
> the way you generate the config-list.h file in the same patch, which
> is done with execute_process() to run generate-cmdlist.sh.
>
> You did not answer the question, either, so I have to guess.
>
> I am guessing that it was an oversight that you did not update the
> procedure to handle GIT-VERSION-FILE because you wrote the "let's
> string-find in the GIT-VERSION-GEN script" approach way before you
> wrote the other parts of the CMake thing, and with the experience
> and hindsight of having written command-list-h support, you now
> realize that running the script to ensure that you get the result
> consistent with folks who use Makefile would be much better.  After
> all, the logic being more complex than your CMake support can
> express shouldn't be an issue, if you just let the logic execute
> itself, no?
>

> But that is also merely my guess, so...
>
> > Any other changes I should make before I submit PATCH v3?
>
> ... at this point, it is too early for me to answer that question.

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
>
> The CMake script parses the Makefile for:
> SCRIPT_SH
> SCRIPT_PERL
> TEST_BUILTINS_OBJS
> LIB_OBJS
> BUILTIN_OBJS
> XDIFF_OBJS
> VCSSVN_OBJS
>
> By doing this we avoid duplication of text between the Makefile and
> the CMake script.

>
> "Sibi Siddharthan via GitGitGadget" <gitgitgadget@gmail.com> writes:
>
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >
> > The CMake script parses the Makefile for:
> > SCRIPT_SH
> > SCRIPT_PERL
> > TEST_BUILTINS_OBJS
> > LIB_OBJS
> > BUILTIN_OBJS
> > XDIFF_OBJS
> > VCSSVN_OBJS
> >
> > By doing this we avoid duplication of text between the Makefile and
> > the CMake script.
>
> Thanks, this makes perfect sense, but it probably should have been
> done from the very beginning, without copying the huge list manually
> in the step [01/11].
>
> How robust is the "parser"?  Do we need to leave an instruction to
> Makefile writers to conform to certain style to help CMake users as
> an additional comment in the Makefile, or is any reasonable textual
> drift still accepted?
>

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
>
> The CMake script has been relocated to contrib/buildsystems.
> The changes made to the script involves pointing to correct location
> of the source files.

> Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> ---
>  .../buildsystems/CMakeLists.txt               | 76 +++++++++++--------
>  1 file changed, 45 insertions(+), 31 deletions(-)
>  rename CMakeLists.txt => contrib/buildsystems/CMakeLists.txt (92%)

>
> "Sibi Siddharthan via GitGitGadget" <gitgitgadget@gmail.com> writes:
>
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >
> > The CMake script has been relocated to contrib/buildsystems.
> > The changes made to the script involves pointing to correct location
> > of the source files.
>
> This does match what the list agreed to do.  Why isn't this done as
> part of [01/11]?  If there is no technical reason not to, I'd
> strongly prefer to see it done from the very beginning.  The same
> comment applies to the next step.

>
> Thanks.
>
> > Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > ---
> >  .../buildsystems/CMakeLists.txt               | 76 +++++++++++--------
> >  1 file changed, 45 insertions(+), 31 deletions(-)
> >  rename CMakeLists.txt => contrib/buildsystems/CMakeLists.txt (92%)

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
>
> At the moment, the recommended way to configure Git's builds is to
> ...
> Note: this patch asks for the minimum version v3.14 of CMake (which is
> not all that old as of time of writing) because that is the first
> version to offer a platform-independent way to generate hardlinks as
> part of the build. This is needed to generate all those hardlinks for
> the built-in commands of Git.

> Changes
> The CMake script parses the Makefile for:
> LIB_OBJS
> BUILTIN_OBJS
> XDIFF_OBJS
> VCSSVN_OBJS
> TEST_BUILTINS_OBJS
>
> By doing this we avoid duplication of text between the Makefile and
> the CMake script.
>
> The CMake script has been relocated to contrib/buildsystems.
>
> The CMake script uses GIT-VERSION-GEN to determine the version of Git
> being built.

> Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> ---
>  contrib/buildsystems/CMakeLists.txt | 575 ++++++++++++++++++++++++++++
>  1 file changed, 575 insertions(+)
>  create mode 100644 contrib/buildsystems/CMakeLists.txt
>
> diff --git a/contrib/buildsystems/CMakeLists.txt b/contrib/buildsystems/CMakeLists.txt
> new file mode 100644
> index 00000000000..8e2b27f44a6
> --- /dev/null
> +++ b/contrib/buildsystems/CMakeLists.txt
> @@ -0,0 +1,575 @@
> +#
> +#	Copyright (c) 2020 Sibi Siddharthan
> +#
> +
> +#[[
> +
> +Instructions to run CMake:
> +
> +cmake `relative-path-to-CMakeLists.txt` -DCMAKE_BUILD_TYPE=Release

> +Possible build configurations(-DCMAKE_BUILD_TYPE) with corresponding
> +compiler flags
> +Debug : -g
> +Release: -O3
> +RelWithDebInfo : -O2 -g
> +MinSizeRel : -Os
> +empty(default) :
> +
> +NOTE: -DCMAKE_BUILD_TYPE is optional. For multi-config generators like Visual Studio
> +this option is ignored

> +This process generates a Makefile(Linux) , Visual Studio solution(Windows) by default.
> +Run `make` to build Git on Linux.
> +Open git.sln on Windows and build Git.
> +
> +NOTE: By default CMake uses Makefile as the build tool on Linux and Visual Studio in Windows,

> +to use another tool say `ninja` add this to the command line when configuring.
> +`-G Ninja`
> +
> +]]
> +cmake_minimum_required(VERSION 3.14)
> ...
> +check_c_source_compiles("

> +	if (p) return 0;
> +	return 0;
> +}"
> +HAVE_ALLOCA_H)
> ...
> +check_c_source_runs("
> +#include<stdio.h>
> +#include<stdarg.h>
> +#include<string.h>
> +#include<stdlib.h>
> +int test_vsnprintf(char *str, size_t maxsize, const char *format, ...)
> +{
> +	int ret;
> +	va_list ap;
> +
> +	va_start(ap, format);
> +	ret = vsnprintf(str, maxsize, format, ap);
> +	va_end(ap);
> +	return ret;
> +}
> +
> +int
> +main ()
> +{

> +	char buf[6];
> +	if (test_vsnprintf(buf, 3, \"%s\", \"12345\") != 5
> +		|| strcmp(buf, \"12\")) return 1;
> +	if (snprintf(buf, 3, \"%s\", \"12345\") != 5
> +		|| strcmp(buf, \"12\")) return 1;
> +
> +	return 0;
> +}"

>
> "Sibi Siddharthan via GitGitGadget" <gitgitgadget@gmail.com> writes:
>
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >
> > At the moment, the recommended way to configure Git's builds is to
> > ...
> > Note: this patch asks for the minimum version v3.14 of CMake (which is
> > not all that old as of time of writing) because that is the first
> > version to offer a platform-independent way to generate hardlinks as
> > part of the build. This is needed to generate all those hardlinks for
> > the built-in commands of Git.
>
> All of the above reads reasonable.
>
> > Changes
> > The CMake script parses the Makefile for:
> > LIB_OBJS
> > BUILTIN_OBJS
> > XDIFF_OBJS
> > VCSSVN_OBJS
> > TEST_BUILTINS_OBJS
> >
> > By doing this we avoid duplication of text between the Makefile and
> > the CMake script.
> >
> > The CMake script has been relocated to contrib/buildsystems.
> >
> > The CMake script uses GIT-VERSION-GEN to determine the version of Git
> > being built.
>
> Everything after the "Changes" line does not belong to the commit
> log, as it is no use for those who read "git log" output and
> encounter the "first" attempt to add CMake support there.  There is
> no need to tell them that you did things differently from this
> version in the past, as they simply do not know what you did in the
> previous iterations, nor particularly care about them.
>
> These *do* help reviewers who saw previous iterations, and the space
> after the three-dash line below is the right/recommended place for
> them.
>
> The above applies to other patches in this series.

>
> > Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> > ---
> >  contrib/buildsystems/CMakeLists.txt | 575 ++++++++++++++++++++++++++++
> >  1 file changed, 575 insertions(+)
> >  create mode 100644 contrib/buildsystems/CMakeLists.txt
> >
> > diff --git a/contrib/buildsystems/CMakeLists.txt b/contrib/buildsystems/CMakeLists.txt
> > new file mode 100644
> > index 00000000000..8e2b27f44a6
> > --- /dev/null
> > +++ b/contrib/buildsystems/CMakeLists.txt
> > @@ -0,0 +1,575 @@
> > +#
> > +#    Copyright (c) 2020 Sibi Siddharthan
> > +#
> > +
> > +#[[
> > +
> > +Instructions to run CMake:
> > +
> > +cmake `relative-path-to-CMakeLists.txt` -DCMAKE_BUILD_TYPE=Release
>
> The readers can infer from `relative-path-to-CMakeLists` that they
> can run this command from anywhere, e.g.
>
>         $ cd $HOME
>         $ tar xf /var/tmp/git-2.7.0.tar
>         $ cd /tmp
>         $ cmake $HOME/git/contrib/buildsystems/CMakeLists.txt
>
> but when given the freedom/flexibility to use it from "anywhere",
> they are faced by an extra choice to make.  It may be helpful to
> readers to elaborate a bit more to help them decide where in the
> directory hierarchy they would want to run this command.  In the
> above example sequence, I chose /tmp, but if I used /var/tmp as the
> starting place instead, what becomes different?  The answer might
> be "resulting 'git' binary is stored in the directory you run the
> 'cmake' command in", and by spelling it out, it helps readers to
> make an informed decision.
>

> > +Possible build configurations(-DCMAKE_BUILD_TYPE) with corresponding
> > +compiler flags
> > +Debug : -g
> > +Release: -O3
> > +RelWithDebInfo : -O2 -g
> > +MinSizeRel : -Os
> > +empty(default) :
> > +
> > +NOTE: -DCMAKE_BUILD_TYPE is optional. For multi-config generators like Visual Studio
> > +this option is ignored
>
> Quite helpful.
>
> > +This process generates a Makefile(Linux) , Visual Studio solution(Windows) by default.
> > +Run `make` to build Git on Linux.
> > +Open git.sln on Windows and build Git.
> > +
> > +NOTE: By default CMake uses Makefile as the build tool on Linux and Visual Studio in Windows,
>
> The above makes it sound as if Linux and VS are the only two systems
> we care about, but is it really Linux, or UNIX-flavoured systems in
> general?  In other words, are we excluding friends on BSD and macOS
> with the above?
>
> The above is not a complaint about "exclusion", but is a complaint
> about unclarity.
>

> > +to use another tool say `ninja` add this to the command line when configuring.
> > +`-G Ninja`
> > +
> > +]]
> > +cmake_minimum_required(VERSION 3.14)
> > ...
> > +check_c_source_compiles("
>
> The "source" given to check_c_source_{compiles,runs} may be allowed
> to be anything, but I'd prefer to see it follow some consistent
> style, preferrably our CodingGuidelines (except for git specific
> bits like "do not include standard system file but instead just use
> git-compat-util.h", which of course should not apply).  This is a
> comment not only about the two instances below I use as examples,
> but all C-source snippets in this patch.
>
> > +#include <alloca.h>
> > +int
> > +main ()
> > +{
>
>         int main(void)
>         {
>
> is how we start this function.
>
> > +char *p = (char *) alloca (2 * sizeof (int));
>
> And the decl of function local variable here would be indented by a
> HT like the remainder of the function.  No SP between function name
> and the parentheses around its arguments.  NP SP after sizeof,
> either.
>
> > +     if (p) return 0;
> > +     return 0;
> > +}"
> > +HAVE_ALLOCA_H)
> > ...
> > +check_c_source_runs("
> > +#include<stdio.h>
> > +#include<stdarg.h>
> > +#include<string.h>
> > +#include<stdlib.h>
> > +int test_vsnprintf(char *str, size_t maxsize, const char *format, ...)
> > +{
> > +     int ret;
> > +     va_list ap;
> > +
> > +     va_start(ap, format);
> > +     ret = vsnprintf(str, maxsize, format, ap);
> > +     va_end(ap);
> > +     return ret;
> > +}
> > +
> > +int
> > +main ()
> > +{
>
> Likewise.
>
> > +     char buf[6];
> > +     if (test_vsnprintf(buf, 3, \"%s\", \"12345\") != 5
> > +             || strcmp(buf, \"12\")) return 1;
> > +     if (snprintf(buf, 3, \"%s\", \"12345\") != 5
> > +             || strcmp(buf, \"12\")) return 1;
> > +
> > +     return 0;
> > +}"
>

> On Sat, May 30, 2020 at 12:57 AM Junio C Hamano <gitster@pobox.com> wrote:
>> ...
>> Everything after the "Changes" line does not belong to the commit
>> log, as it is no use for those who read "git log" output and
>> encounter the "first" attempt to add CMake support there.  There is
>> no need to tell them that you did things differently from this
>> version in the past, as they simply do not know what you did in the
>> previous iterations, nor particularly care about them.
>>
>> These *do* help reviewers who saw previous iterations, and the space
>> after the three-dash line below is the right/recommended place for
>> them.
>>
>> The above applies to other patches in this series.
>
> Do you mean this line '---' below?

> Sibi Siddharthan <sibisiddharthan.github@gmail.com> writes:
>
> > On Sat, May 30, 2020 at 12:57 AM Junio C Hamano <gitster@pobox.com> wrote:
> >> ...
> >> Everything after the "Changes" line does not belong to the commit
> >> log, as it is no use for those who read "git log" output and
> >> encounter the "first" attempt to add CMake support there.  There is
> >> no need to tell them that you did things differently from this
> >> version in the past, as they simply do not know what you did in the
> >> previous iterations, nor particularly care about them.
> >>
> >> These *do* help reviewers who saw previous iterations, and the space
> >> after the three-dash line below is the right/recommended place for
> >> them.
> >>
> >> The above applies to other patches in this series.
> >
> > Do you mean this line '---' below?
>
> Yes.
>
> > If so how do I place the changelog below them?
> > I just do `/submit` at gigitgadet/git.
>
> Sorry, I don't use GGG, so the question needs to be redirected to
> those who do and enhance (Dscho cc'ed).

> >> > Signed-off-by: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >> > ---
>
> Here is what I meant, but another place that is suitable to describe
> differences from previous rounds is the cover letter.  If the split
> of tasks between steps in a multi-patch series hasn't changed from
> the previous round, it makes it easier to review if the changes
> since the last round for each individual step is described in the
> message itself, like you did.  It just needs to be done outside the
> log message.
>
> Thanks.
>

> +file(STRINGS ${CMAKE_SOURCE_DIR}/GIT-VERSION-FILE git_version REGEX "GIT_VERSION = (.*)")
> +string(REPLACE "GIT_VERSION = " "" git_version ${git_version})
> +string(FIND ${git_version} "GIT" location)
> +if(location EQUAL -1)
> +	string(REGEX MATCH "[0-9]*\\.[0-9]*\\.[0-9]*" git_version ${git_version})

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
>
> Implement the placeholder substitution to generate scripted
> Porcelain commands, e.g. git-request-pull out of
> git-request-pull.sh
>
> Generate shell/perl/python scripts and template using CMake instead of
> using sed like the build procedure in the Makefile does.
>
> The text translations are only build if `msgfmt` is found in your path.
>
> NOTE: The scripts and templates are generated during configuration.

> +#perl modules
> +file(GLOB_RECURSE perl_modules "${CMAKE_SOURCE_DIR}/perl/*.pm")
> +
> +foreach(pm ${perl_modules})
> +	string(REPLACE "${CMAKE_SOURCE_DIR}/perl/" "" file_path ${pm})
> +	file(STRINGS ${pm} content NEWLINE_CONSUME)
> +	string(REPLACE "@@LOCALEDIR@@" "${LOCALEDIR}" content "${content}")
> +	string(REPLACE "@@NO_PERL_CPAN_FALLBACKS@@" "" content "${content}")
> +	file(WRITE ${CMAKE_BINARY_DIR}/perl/build/lib/${file_path} ${content})
> +#test-lib.sh requires perl/build/lib to be the build directory of perl modules
> +endforeach()
> +
> +
> +#templates
> +file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/templates/blt/branches) #create branches
> +set(hooks_templates
> +	applypatch-msg.sample pre-applypatch.sample pre-push.sample
> +	commit-msg.sample pre-commit.sample pre-rebase.sample
> +	fsmonitor-watchman.sample pre-merge-commit.sample pre-receive.sample
> +	post-update.sample prepare-commit-msg.sample update.sample)

> +#templates have @.*@ replacement so use configure_file instead
> +#hooks
> +foreach(tm ${hooks_templates})
> +	configure_file(${CMAKE_SOURCE_DIR}/templates/hooks--${tm} ${CMAKE_BINARY_DIR}/templates/blt/hooks/${tm} @ONLY)
> +endforeach()
> +
> +#info
> +configure_file(${CMAKE_SOURCE_DIR}/templates/info--exclude ${CMAKE_BINARY_DIR}/templates/blt/info/exclude @ONLY)
> +
> +#this
> +configure_file(${CMAKE_SOURCE_DIR}/templates/this--description ${CMAKE_BINARY_DIR}/templates/blt/description @ONLY)

> +	foreach(po ${po_files})
> +		file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/po/build/locale/${po}/LC_MESSAGES)
> +		add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/po/build/locale/${po}/LC_MESSAGES/git.mo
> +				COMMAND ${MSGFMT_EXE} --check --statistics -o ${CMAKE_BINARY_DIR}/po/build/locale/${po}/LC_MESSAGES/git.mo ${CMAKE_SOURCE_DIR}/po/${po}.po)
> +		list(APPEND po_gen ${CMAKE_BINARY_DIR}/po/build/locale/${po}/LC_MESSAGES/git.mo)
> +	endforeach()
> +	add_custom_target(po-gen ALL DEPENDS ${po_gen})
> +endif()

>
> "Sibi Siddharthan via GitGitGadget" <gitgitgadget@gmail.com> writes:
>
> > From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> >
> > Implement the placeholder substitution to generate scripted
> > Porcelain commands, e.g. git-request-pull out of
> > git-request-pull.sh
> >
> > Generate shell/perl/python scripts and template using CMake instead of
> > using sed like the build procedure in the Makefile does.
> >
> > The text translations are only build if `msgfmt` is found in your path.
> >
> > NOTE: The scripts and templates are generated during configuration.
>
> OK.
>
> > Changes
> > The CMake script parses the Makefile for:
> > SCRIPT_SH
> > SCRIPT_PERL
>
> Below the three-dash line.
>
> > +#shell scripts
> > +parse_makefile_for_scripts(git_sh_scripts "SCRIPT_SH" ".sh")
>
> OK.
>
> > +set(git_shell_scripts
> > +     ${git_sh_scripts}
> > +     git-mergetool--lib git-parse-remote git-rebase--preserve-merges
> > +     git-sh-setup git-sh-i18n git-instaweb)
>
> Do we need to have enumeration here, which can drift out of sync
> with the reality?  Wouldn't we want to avoid it with something like
>
>  parse_makefile_for_scripts(git_sh_lib "SCRIPT_LIB" "")
>
> too?
>

> > +#perl modules
> > +file(GLOB_RECURSE perl_modules "${CMAKE_SOURCE_DIR}/perl/*.pm")
> > +
> > +foreach(pm ${perl_modules})
> > +     string(REPLACE "${CMAKE_SOURCE_DIR}/perl/" "" file_path ${pm})
> > +     file(STRINGS ${pm} content NEWLINE_CONSUME)
> > +     string(REPLACE "@@LOCALEDIR@@" "${LOCALEDIR}" content "${content}")
> > +     string(REPLACE "@@NO_PERL_CPAN_FALLBACKS@@" "" content "${content}")
> > +     file(WRITE ${CMAKE_BINARY_DIR}/perl/build/lib/${file_path} ${content})
> > +#test-lib.sh requires perl/build/lib to be the build directory of perl modules
> > +endforeach()
> > +
> > +
> > +#templates
> > +file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/templates/blt/branches) #create branches
> > +set(hooks_templates
> > +     applypatch-msg.sample pre-applypatch.sample pre-push.sample
> > +     commit-msg.sample pre-commit.sample pre-rebase.sample
> > +     fsmonitor-watchman.sample pre-merge-commit.sample pre-receive.sample
> > +     post-update.sample prepare-commit-msg.sample update.sample)
>
> Do we need to have enumeration here, which can drift out of sync
> with the reality?  Wouldn't we want to avoid it with file(GLOB) or
> something?
>

> > +#templates have @.*@ replacement so use configure_file instead
> > +#hooks
> > +foreach(tm ${hooks_templates})
> > +     configure_file(${CMAKE_SOURCE_DIR}/templates/hooks--${tm} ${CMAKE_BINARY_DIR}/templates/blt/hooks/${tm} @ONLY)
> > +endforeach()
> > +
> > +#info
> > +configure_file(${CMAKE_SOURCE_DIR}/templates/info--exclude ${CMAKE_BINARY_DIR}/templates/blt/info/exclude @ONLY)
> > +
> > +#this
> > +configure_file(${CMAKE_SOURCE_DIR}/templates/this--description ${CMAKE_BINARY_DIR}/templates/blt/description @ONLY)
>
> I was hoping that we could drive any build system without having to
> have separate rules like the above.  The idea behind all files with
> funny double-dash in its name under templates/ directory is:
>

>  - double-dash denotes directory boundary
>
>  - when a template input ends with double-dash, it tells us to
>    create a directory
>
>  - leading "this--" denotes "not in a subdirectory but at the top
>    level of the generated template directory"
>
> so that each of them knows what the name of the file and directory
> hierarchy of the final destination is, and the result of transforming
> can be created and deposited at the final place mechanically with a
> single rule.
>
> > +#translations
> > +if(MSGFMT_EXE)
> > +     set(po_files bg  ca  de  el  es  fr  is  it  ko  pt_PT  ru  sv  tr  vi  zh_CN  zh_TW)
>
> Do we need to have enumeration here, which can drift out of sync
> with the reality?  Wouldn't globbing for *.po be sufficient?
>
> > +     foreach(po ${po_files})
> > +             file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/po/build/locale/${po}/LC_MESSAGES)
> > +             add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/po/build/locale/${po}/LC_MESSAGES/git.mo
> > +                             COMMAND ${MSGFMT_EXE} --check --statistics -o ${CMAKE_BINARY_DIR}/po/build/locale/${po}/LC_MESSAGES/git.mo ${CMAKE_SOURCE_DIR}/po/${po}.po)
> > +             list(APPEND po_gen ${CMAKE_BINARY_DIR}/po/build/locale/${po}/LC_MESSAGES/git.mo)
> > +     endforeach()
> > +     add_custom_target(po-gen ALL DEPENDS ${po_gen})
> > +endif()
>
> Thanks.

> Hi Junio,
>
> I have done the suggested changes namely:
> 1) Format code inside check_c_source_compiles/runs
> 2) Moved the changelog of the patch series from the commit messages to
> the cover letter
> 3) parse for SCRIPT_LIB
> 4) glob templates and po files
> 5) add logic as to where the template file should be built.
>
> Any other changes I should do before I a new version of the patch series?
>
> Thank You,
> Sibi Siddharthan

> From: Sibi Siddharthan <sibisiddharthan.github@gmail.com>
> 
> This patch provides an alternate way to test git using ctest.
> CTest ships with CMake, so there is no additional dependency being
> introduced.
> 
> To perform the tests with ctest do this after building:
> ctest -j[number of jobs]