if test "$PORTNAME" = "win32" -o "$PORTNAME" = "cygwin"; then

# Cygwin and (apparently, based on test results) Mingw both

# have a broken strtof(), so substitute the same replacement

# code we use with VS2013. That's not a perfect fix, since

# (unlike with VS2013) it doesn't avoid double-rounding, but

# we have no better options. To get that, though, we have to

# have a broken strtof(), so substitute its implementation.

# That's not a perfect fix, since it doesn't avoid double-rounding,

# but we have no better options. To get that, though, we have to

# force the file to be compiled despite HAVE_STRTOF.

case " $LIBOBJS " in

*" strtof.$ac_objext "* ) ;;

if test "$PORTNAME" = "win32" -o "$PORTNAME" = "cygwin"; then

<productname>Windows</productname>. The simplest way to build with

Microsoft tools is to install <productname>Visual Studio 2022</productname>

and use the included compiler. It is also possible to build with the full

<productname>Microsoft Visual C++2013 to 2022</productname>.

<productname>Microsoft Visual C++2015 to 2022</productname>.

In some cases that requires the installation of the

<productname>Windows SDK</productname> in addition to the compiler.

</para>

<para>

Both 32-bit and 64-bit builds are possible with the Microsoft Compiler suite.

32-bit PostgreSQL builds are possible with

<productname>Visual Studio2013</productname> to

<productname>Visual Studio2015</productname> to

<productname>Visual Studio 2022</productname>,

as well as standalone Windows SDK releases 8.1a to 10.

64-bit PostgreSQL builds are supported with

<productname>Microsoft Windows SDK</productname> version 8.1a to 10 or

<productname>Visual Studio2013</productname> and above.

<productname>Visual Studio2015</productname> and above.

<!--

For 2013 requirements:

https://docs.microsoft.com/en-us/visualstudio/productinfo/vs2013-sysrequirements-vs

For 2015 requirements:

https://docs.microsoft.com/en-us/visualstudio/productinfo/vs2015-sysrequirements-vs

For 2017 requirements:

#if defined(_M_AMD64)&&_MSC_VER==1800

doubleouter_rows,

doubleinner_rows,

SpecialJoinInfo*sjinfo,

List*restrictlist_in)

List*restrictlist)

{

List*restrictlist=restrictlist_in;

JoinTypejointype=sjinfo->jointype;

Selectivityfkselec;

Selectivityjselec;

if (val==0.0||

#if !defined(HUGE_VALF)|| (defined(_MSC_VER)&& (_MSC_VER<1900))

#if !defined(HUGE_VALF)

isinf(val)

(val >=HUGE_VALF||val <=-HUGE_VALF)

#if_MSC_VER >=1900

returnNULL;

}

IsoLocaleName(constchar*winlocname)

returniso_lc_messages;

}

{

#if (_MSC_VER >=1900)/* Visual Studio 2015 or later */

returnget_iso_localename(winlocname);

_locale_tloct;

loct=_create_locale(LC_CTYPE,winlocname);

if (loct!=NULL)

{

size_trc;

char*hyphen;

rc=wchar2char(iso_lc_messages,loct->locinfo->locale_name[LC_CTYPE],

sizeof(iso_lc_messages),NULL);

_free_locale(loct);

if (rc==-1||rc==sizeof(iso_lc_messages))

returnNULL;

hyphen=strchr(iso_lc_messages,'-');

if (hyphen)

*hyphen='_';

returniso_lc_messages;

}

}

returnNULL;/* Not supported on this version of msvc/mingw */

}

#if (defined(_MSC_VER)&& (_MSC_VER<1900))|| \

defined(__MINGW32__)|| defined(__MINGW64__)

#if defined(__MINGW32__)|| defined(__MINGW64__)

win32_langinfo(constchar*ctype)

{

char*r=NULL;

#if defined(_MSC_VER)&& (_MSC_VER<1900)

_locale_tloct=NULL;

loct=_create_locale(LC_CTYPE,ctype);

if (loct!=NULL)

{

r=malloc(16);/* excess */

if (r!=NULL)

sprintf(r,"CP%u",loct->locinfo->lc_codepage);

_free_locale(loct);

}

char*codepage;

#if defined(_MSC_VER)&& (_MSC_VER >=1900)

#if defined(_MSC_VER)

uint32cp;

WCHARwctype[LOCALE_NAME_MAX_LENGTH];

}

}

}

returnr;

}

packageMSBuildProject;

return;

}

packageVC2013Project;

use strict;

use warnings;

use baseqw(MSBuildProject);

no warningsqw(redefine);## no critic

{

my$classname =shift;

my$self =$classname->SUPER::_new(@_);

bless($self,$classname);

$self->{vcver} ='12.00';

$self->{PlatformToolset} ='v120';

$self->{ToolsVersion} ='12.0';

return$self;

}

packageVC2015Project;

==========

This directory contains the tools required to build PostgreSQL using

Microsoft Visual Studio2013 - 2022. This builds the whole backend, not just

Microsoft Visual Studio2015 - 2022. This builds the whole backend, not just

the libpq frontend library. For more information, see the documentation

chapter "Installation on Windows" and the description below.

Mkvcbuild.pm module containing the code to generate the Visual

Studio build (project/solution) files

MSBuildProject.pm module containing the code to generate MSBuild based

project files (Visual Studio2013 or greater)

project files (Visual Studio2015 or greater)

Project.pm module containing the common code to generate the

Visual Studio project files. Also provides the

common interface of all project file generators

These configuration arguments are passed over to Mkvcbuild::mkvcbuild

(Mkvcbuild.pm) which creates the Visual Studio project and solution files.

It does this by using VSObjectFactory::CreateSolution to create an object

implementing the Solution interface (this could be either VS2013Solution,

implementing the Solution interface (this could be either

VS2015Solution, VS2017Solution, VS2019Solution or VS2022Solution, all in

Solution.pm, depending on the user's build environment) and adding objects

implementing the corresponding Project interface (VC2013Project,

implementing the corresponding Project interface (

VC2015Project, VC2017Project, VC2019Project or VC2022Project from

MSBuildProject.pm) to it. When Solution::Save is called, the implementations

of Solution and Project save their content in the appropriate format.

return$cfg;

}

packageVS2013Solution;

use Carp;

use strict;

use warnings;

use baseqw(Solution);

no warningsqw(redefine);## no critic

{

my$classname =shift;

my$self =$classname->SUPER::_new(@_);

bless($self,$classname);

$self->{solutionFileVersion} ='12.00';

$self->{vcver} ='12.00';

$self->{visualStudioName} ='Visual Studio 2013';

$self->{VisualStudioVersion} ='12.0.21005.1';

$self->{MinimumVisualStudioVersion} ='10.0.40219.1';

return$self;

}

packageVS2015Solution;

$visualStudioVersion = DetermineVisualStudioVersion();

}

if ($visualStudioVersioneq'12.00')

{

return new VS2013Solution(@_);

}

elsif ($visualStudioVersioneq'14.00')

if ($visualStudioVersioneq'14.00')

{

return new VS2015Solution(@_);

}

$visualStudioVersion = DetermineVisualStudioVersion();

}

if ($visualStudioVersioneq'12.00')

{

return new VC2013Project(@_);

}

elsif ($visualStudioVersioneq'14.00')

if ($visualStudioVersioneq'14.00')

{

return new VC2015Project(@_);

}