Require C99 (and thus MSCV 2013 upwards).

In 86d78ef50e I enabled configure to check for C99 support, with the
goal of checking which platforms support C99.  While there are a few
machines without C99 support among our buildfarm animals,
de-supporting them for v12 was deemed acceptable.

While not tested in aforementioned commit, the biggest increase in
minimum compiler version comes from MSVC, which gained C99 support
fairly late. The subset in MSVC 2013 is sufficient for our needs, at
this point. While that is a significant increase in minimum version,
the existing windows binaries are already built with a new enough
version.

Make configure error out if C99 support could not be detected. For
MSVC builds, increase the minimum version to 2013.

The increase to MSVC 2013 allows us to get rid of VCBuildProject.pm,
as that was only required for MSVC 2005/2008.

Author: Andres Freund
Discussion: https://postgr.es/m/97d4b165-192d-3605-749c-f614a0c4e783@2ndquadrant.com
This commit is contained in:
Andres Freund 2018-08-23 18:33:40 -07:00
parent a569eea699
commit d9dd406fe2
11 changed files with 112 additions and 558 deletions

49
configure vendored
View File

@ -4602,6 +4602,13 @@ if test "x$ac_cv_prog_cc_c99" != xno; then :
fi
# Error out if the compiler does not support C99, as the codebase
# relies on that.
if test "$ac_cv_prog_cc_c99" = no; then
as_fn_error $? "C compiler \"$CC\" does not support C99" "$LINENO" 5
fi
ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
@ -5361,6 +5368,48 @@ fi
# -Wdeclaration-after-statement isn't applicable for C++
# Really don't want VLAs to be used in our dialect of C
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} supports -Werror=vla, for CFLAGS" >&5
$as_echo_n "checking whether ${CC} supports -Werror=vla, for CFLAGS... " >&6; }
if ${pgac_cv_prog_CC_cflags__Werror_vla+:} false; then :
$as_echo_n "(cached) " >&6
else
pgac_save_CFLAGS=$CFLAGS
pgac_save_CC=$CC
CC=${CC}
CFLAGS="${CFLAGS} -Werror=vla"
ac_save_c_werror_flag=$ac_c_werror_flag
ac_c_werror_flag=yes
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
pgac_cv_prog_CC_cflags__Werror_vla=yes
else
pgac_cv_prog_CC_cflags__Werror_vla=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_c_werror_flag=$ac_save_c_werror_flag
CFLAGS="$pgac_save_CFLAGS"
CC="$pgac_save_CC"
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $pgac_cv_prog_CC_cflags__Werror_vla" >&5
$as_echo "$pgac_cv_prog_CC_cflags__Werror_vla" >&6; }
if test x"$pgac_cv_prog_CC_cflags__Werror_vla" = x"yes"; then
CFLAGS="${CFLAGS} -Werror=vla"
fi
# -Wvla is not applicable for C++
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} supports -Wendif-labels, for CFLAGS" >&5
$as_echo_n "checking whether ${CC} supports -Wendif-labels, for CFLAGS... " >&6; }

View File

@ -359,6 +359,13 @@ esac
AC_PROG_CC([$pgac_cc_list])
AC_PROG_CC_C99()
# Error out if the compiler does not support C99, as the codebase
# relies on that.
if test "$ac_cv_prog_cc_c99" = no; then
AC_MSG_ERROR([C compiler "$CC" does not support C99])
fi
AC_PROG_CXX([$pgac_cxx_list])
# Check if it's Intel's compiler, which (usually) pretends to be gcc,
@ -477,6 +484,9 @@ if test "$GCC" = yes -a "$ICC" = no; then
# These work in some but not all gcc versions
PGAC_PROG_CC_CFLAGS_OPT([-Wdeclaration-after-statement])
# -Wdeclaration-after-statement isn't applicable for C++
# Really don't want VLAs to be used in our dialect of C
PGAC_PROG_CC_CFLAGS_OPT([-Werror=vla])
# -Wvla is not applicable for C++
PGAC_PROG_CC_CFLAGS_OPT([-Wendif-labels])
PGAC_PROG_CXX_CFLAGS_OPT([-Wendif-labels])
PGAC_PROG_CC_CFLAGS_OPT([-Wmissing-format-attribute])

View File

@ -22,7 +22,7 @@
Microsoft tools is to install <productname>Visual Studio Express 2017
for Windows Desktop</productname> and use the included
compiler. It is also possible to build with the full
<productname>Microsoft Visual C++ 2005 to 2017</productname>.
<productname>Microsoft Visual C++ 2013 to 2017</productname>.
In some cases that requires the installation of the
<productname>Windows SDK</productname> in addition to the compiler.
</para>
@ -77,20 +77,24 @@
<para>
Both 32-bit and 64-bit builds are possible with the Microsoft Compiler suite.
32-bit PostgreSQL builds are possible with
<productname>Visual Studio 2005</productname> to
<productname>Visual Studio 2013</productname> to
<productname>Visual Studio 2017</productname> (including Express editions),
as well as standalone Windows SDK releases 6.0 to 8.1.
64-bit PostgreSQL builds are supported with
<productname>Microsoft Windows SDK</productname> version 6.0a to 8.1 or
<productname>Visual Studio 2008</productname> and above. Compilation
is supported down to <productname>Windows XP</productname> and
<productname>Windows Server 2003</productname> when building with
<productname>Visual Studio 2005</productname> to
<productname>Visual Studio 2013</productname>. Building with
<productname>Visual Studio 2015</productname> is supported down to
<productname>Windows Vista</productname> and <productname>Windows Server 2008</productname>.
Building with <productname>Visual Studio 2017</productname> is supported
down to <productname>Windows 7 SP1</productname> and <productname>Windows Server 2008 R2 SP1</productname>.
<productname>Visual Studio 2013</productname> and above. Compilation
is supported down to <productname>Windows 7</productname> and
<productname>Windows Server 2008 R2 SP1</productname> when building with
<productname>Visual Studio 2013</productname> to
<productname>Visual Studio 2017</productname>.
<!--
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:
https://docs.microsoft.com/en-us/visualstudio/productinfo/vs2017-system-requirements-vs
-->
</para>
<para>

View File

@ -85,7 +85,7 @@ su - postgres
<listitem>
<para>
You need an <acronym>ISO</acronym>/<acronym>ANSI</acronym> C compiler (at least
C89-compliant). Recent
C99-compliant). Recent
versions of <productname>GCC</productname> are recommended, but
<productname>PostgreSQL</productname> is known to build using a wide variety
of compilers from different vendors.

View File

@ -867,19 +867,30 @@ BETTER: unrecognized node type: 42
<title>C Standard</title>
<para>
Code in <productname>PostgreSQL</productname> should only rely on language
features available in the C89 standard. That means a conforming
C89 compiler has to be able to compile postgres, at least aside
from a few platform dependent pieces. Features from later
revision of the C standard or compiler specific features can be
used, if a fallback is provided.
features available in the C99 standard. That means a conforming
C99 compiler has to be able to compile postgres, at least aside
from a few platform dependent pieces.
</para>
<para>
For example <literal>static inline</literal> and
<literal>_StaticAssert()</literal> are currently used, even
though they are from newer revisions of the C standard. If not
available we respectively fall back to defining the functions
without inline, and to using a C89 compatible replacement that
performs the same checks, but emits rather cryptic messages.
A few features included in the C99 standard are, at this time, not be
permitted to be used in core <productname>PostgreSQL</productname>
code. This currently includes variable length arrays, intermingled
declarations and code, <literal>//</literal> comments, universal
character names. Reasons for that include portability and historical
practices.
</para>
<para>
Features from later revision of the C standard or compiler specific
features can be used, if a fallback is provided.
</para>
<para>
For example <literal>_StaticAssert()</literal> and
<literal>__builtin_constant_p</literal> are currently used, even though
they are from newer revisions of the C standard and a
<productname>GCC</productname> extension respectively. If not available
we respectively fall back to using a C99 compatible replacement that
performs the same checks, but emits rather cryptic messages and do not
use <literal>__builtin_constant_p</literal>.
</para>
</simplesect>

View File

@ -1,7 +1,7 @@
package MSBuildProject;
#
# Package that encapsulates a MSBuild project file (Visual C++ 2010 or greater)
# Package that encapsulates a MSBuild project file (Visual C++ 2013 or greater)
#
# src/tools/msvc/MSBuildProject.pm
#
@ -257,6 +257,7 @@ sub WriteConfigurationPropertyGroup
<UseOfMfc>false</UseOfMfc>
<CharacterSet>MultiByte</CharacterSet>
<WholeProgramOptimization>$p->{wholeopt}</WholeProgramOptimization>
<PlatformToolset>$self->{PlatformToolset}</PlatformToolset>
</PropertyGroup>
EOF
return;
@ -391,75 +392,6 @@ EOF
return;
}
package VC2010Project;
#
# Package that encapsulates a Visual C++ 2010 project file
#
use strict;
use warnings;
use base qw(MSBuildProject);
no warnings qw(redefine); ## no critic
sub new
{
my $classname = shift;
my $self = $classname->SUPER::_new(@_);
bless($self, $classname);
$self->{vcver} = '10.00';
return $self;
}
package VC2012Project;
#
# Package that encapsulates a Visual C++ 2012 project file
#
use strict;
use warnings;
use base qw(MSBuildProject);
no warnings qw(redefine); ## no critic
sub new
{
my $classname = shift;
my $self = $classname->SUPER::_new(@_);
bless($self, $classname);
$self->{vcver} = '11.00';
$self->{PlatformToolset} = 'v110';
return $self;
}
# This override adds the <PlatformToolset> element
# to the PropertyGroup labeled "Configuration"
sub WriteConfigurationPropertyGroup
{
my ($self, $f, $cfgname, $p) = @_;
my $cfgtype =
($self->{type} eq "exe")
? 'Application'
: ($self->{type} eq "dll" ? 'DynamicLibrary' : 'StaticLibrary');
print $f <<EOF;
<PropertyGroup Condition="'\$(Configuration)|\$(Platform)'=='$cfgname|$self->{platform}'" Label="Configuration">
<ConfigurationType>$cfgtype</ConfigurationType>
<UseOfMfc>false</UseOfMfc>
<CharacterSet>MultiByte</CharacterSet>
<WholeProgramOptimization>$p->{wholeopt}</WholeProgramOptimization>
<PlatformToolset>$self->{PlatformToolset}</PlatformToolset>
</PropertyGroup>
EOF
return;
}
package VC2013Project;
#
@ -468,7 +400,7 @@ package VC2013Project;
use strict;
use warnings;
use base qw(VC2012Project);
use base qw(MSBuildProject);
no warnings qw(redefine); ## no critic
@ -493,7 +425,7 @@ package VC2015Project;
use strict;
use warnings;
use base qw(VC2012Project);
use base qw(MSBuildProject);
no warnings qw(redefine); ## no critic
@ -518,7 +450,7 @@ package VC2017Project;
use strict;
use warnings;
use base qw(VC2012Project);
use base qw(MSBuildProject);
no warnings qw(redefine); ## no critic

View File

@ -4,7 +4,7 @@ MSVC build
==========
This directory contains the tools required to build PostgreSQL using
Microsoft Visual Studio 2005 - 2017. This builds the whole backend, not just
Microsoft Visual Studio 2013 - 2017. 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.
@ -67,14 +67,12 @@ Install.pm module containing the install logic
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 Studio 2010 or greater)
project files (Visual Studio 2013 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
Solution.pm module containing the code to generate the Visual
Studio solution files.
VCBuildProject.pm module containing the code to generate VCBuild based
project files (Visual Studio 2005/2008)
VSObjectFactory.pm factory module providing the code to create the
appropriate project/solution files for the current
environment
@ -90,14 +88,12 @@ config_default.pl to create the configuration arguments.
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 a VS2005Solution,
a VS2008Solution, a VS2010Solution or a VS2012Solution or a VS2013Solution,
implementing the Solution interface (this could be either a VS2013Solution,
or a VS2015Solution or a VS2017Solution, all in Solution.pm, depending on
the user's build environment) and adding objects implementing the corresponding
Project interface (VC2005Project or VC2008Project from VCBuildProject.pm or
VC2010Project or VC2012Project or VC2013Project or VC2015Project or VC2017Project
from MSBuildProject.pm) to it.
Project interface (VC2013Project or VC2015Project or VC2017Project from
MSBuildProject.pm) to it.
When Solution::Save is called, the implementations of Solution and Project
save their content in the appropriate format.
The final step of starting the appropriate build program (msbuild or vcbuild)
is performed in build.pl again.
The final step of starting the appropriate build program (msbuild) is
performed in build.pl again.

View File

@ -760,108 +760,6 @@ sub GetFakeConfigure
return $cfg;
}
package VS2005Solution;
#
# Package that encapsulates a Visual Studio 2005 solution file
#
use strict;
use warnings;
use base qw(Solution);
no warnings qw(redefine); ## no critic
sub new
{
my $classname = shift;
my $self = $classname->SUPER::_new(@_);
bless($self, $classname);
$self->{solutionFileVersion} = '9.00';
$self->{vcver} = '8.00';
$self->{visualStudioName} = 'Visual Studio 2005';
return $self;
}
package VS2008Solution;
#
# Package that encapsulates a Visual Studio 2008 solution file
#
use strict;
use warnings;
use base qw(Solution);
no warnings qw(redefine); ## no critic
sub new
{
my $classname = shift;
my $self = $classname->SUPER::_new(@_);
bless($self, $classname);
$self->{solutionFileVersion} = '10.00';
$self->{vcver} = '9.00';
$self->{visualStudioName} = 'Visual Studio 2008';
return $self;
}
package VS2010Solution;
#
# Package that encapsulates a Visual Studio 2010 solution file
#
use Carp;
use strict;
use warnings;
use base qw(Solution);
no warnings qw(redefine); ## no critic
sub new
{
my $classname = shift;
my $self = $classname->SUPER::_new(@_);
bless($self, $classname);
$self->{solutionFileVersion} = '11.00';
$self->{vcver} = '10.00';
$self->{visualStudioName} = 'Visual Studio 2010';
return $self;
}
package VS2012Solution;
#
# Package that encapsulates a Visual Studio 2012 solution file
#
use Carp;
use strict;
use warnings;
use base qw(Solution);
no warnings qw(redefine); ## no critic
sub new
{
my $classname = shift;
my $self = $classname->SUPER::_new(@_);
bless($self, $classname);
$self->{solutionFileVersion} = '12.00';
$self->{vcver} = '11.00';
$self->{visualStudioName} = 'Visual Studio 2012';
return $self;
}
package VS2013Solution;
#

View File

@ -1,309 +0,0 @@
package VCBuildProject;
#
# Package that encapsulates a VCBuild (Visual C++ 2005/2008) project file
#
# src/tools/msvc/VCBuildProject.pm
#
use Carp;
use strict;
use warnings;
use base qw(Project);
no warnings qw(redefine); ## no critic
sub _new
{
my $classname = shift;
my $self = $classname->SUPER::_new(@_);
bless($self, $classname);
$self->{filenameExtension} = '.vcproj';
return $self;
}
sub WriteHeader
{
my ($self, $f) = @_;
print $f <<EOF;
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject ProjectType="Visual C++" Version="$self->{vcver}" Name="$self->{name}" ProjectGUID="$self->{guid}">
<Platforms><Platform Name="$self->{platform}"/></Platforms>
<Configurations>
EOF
$self->WriteConfiguration(
$f, 'Debug',
{
defs => "_DEBUG;DEBUG=1",
wholeopt => 0,
opt => 0,
strpool => 'false',
runtime => 3
});
$self->WriteConfiguration(
$f,
'Release',
{
defs => "",
wholeopt => 0,
opt => 3,
strpool => 'true',
runtime => 2
});
print $f <<EOF;
</Configurations>
EOF
$self->WriteReferences($f);
return;
}
sub WriteFiles
{
my ($self, $f) = @_;
print $f <<EOF;
<Files>
EOF
my @dirstack = ();
my %uniquefiles;
foreach my $fileNameWithPath (sort keys %{ $self->{files} })
{
confess "Bad format filename '$fileNameWithPath'\n"
unless ($fileNameWithPath =~ m!^(.*)/([^/]+)\.(c|cpp|y|l|rc)$!);
my $dir = $1;
my $file = $2;
# Walk backwards down the directory stack and close any dirs
# we're done with.
while ($#dirstack >= 0)
{
if (join('/', @dirstack) eq
substr($dir, 0, length(join('/', @dirstack))))
{
last if (length($dir) == length(join('/', @dirstack)));
last
if (substr($dir, length(join('/', @dirstack)), 1) eq '/');
}
print $f ' ' x $#dirstack . " </Filter>\n";
pop @dirstack;
}
# Now walk forwards and create whatever directories are needed
while (join('/', @dirstack) ne $dir)
{
my $left = substr($dir, length(join('/', @dirstack)));
$left =~ s/^\///;
my @pieces = split /\//, $left;
push @dirstack, $pieces[0];
print $f ' ' x $#dirstack
. " <Filter Name=\"$pieces[0]\" Filter=\"\">\n";
}
# VC builds do not like file paths with forward slashes.
my $fileNameWithPathFormatted = $fileNameWithPath;
$fileNameWithPathFormatted =~ s/\//\\/g;
print $f ' ' x $#dirstack
. " <File RelativePath=\"$fileNameWithPathFormatted\"";
if ($fileNameWithPath =~ /\.y$/)
{
my $of = $fileNameWithPath;
$of =~ s/\.y$/.c/;
$of =~
s{^src/pl/plpgsql/src/gram.c$}{src/pl/plpgsql/src/pl_gram.c};
print $f '>'
. $self->GenerateCustomTool(
'Running bison on ' . $fileNameWithPath,
"perl src/tools/msvc/pgbison.pl $fileNameWithPath", $of)
. '</File>' . "\n";
}
elsif ($fileNameWithPath =~ /\.l$/)
{
my $of = $fileNameWithPath;
$of =~ s/\.l$/.c/;
print $f '>'
. $self->GenerateCustomTool(
'Running flex on ' . $fileNameWithPath,
"perl src/tools/msvc/pgflex.pl $fileNameWithPath", $of)
. '</File>' . "\n";
}
elsif (defined($uniquefiles{$file}))
{
# File already exists, so fake a new name
my $obj = $dir;
$obj =~ s!/!_!g;
print $f
"><FileConfiguration Name=\"Debug|$self->{platform}\"><Tool Name=\"VCCLCompilerTool\" ObjectFile=\".\\debug\\$self->{name}\\$obj"
. "_$file.obj\" /></FileConfiguration><FileConfiguration Name=\"Release|$self->{platform}\"><Tool Name=\"VCCLCompilerTool\" ObjectFile=\".\\release\\$self->{name}\\$obj"
. "_$file.obj\" /></FileConfiguration></File>\n";
}
else
{
$uniquefiles{$file} = 1;
print $f " />\n";
}
}
while ($#dirstack >= 0)
{
print $f ' ' x $#dirstack . " </Filter>\n";
pop @dirstack;
}
print $f <<EOF;
</Files>
EOF
return;
}
sub Footer
{
my ($self, $f) = @_;
print $f <<EOF;
<Globals/>
</VisualStudioProject>
EOF
return;
}
sub WriteConfiguration
{
my ($self, $f, $cfgname, $p) = @_;
my $cfgtype =
($self->{type} eq "exe") ? 1 : ($self->{type} eq "dll" ? 2 : 4);
my $libs = $self->GetAdditionalLinkerDependencies($cfgname, ' ');
my $targetmachine = $self->{platform} eq 'Win32' ? 1 : 17;
print $f <<EOF;
<Configuration Name="$cfgname|$self->{platform}" OutputDirectory=".\\$cfgname\\$self->{name}" IntermediateDirectory=".\\$cfgname\\$self->{name}"
ConfigurationType="$cfgtype" UseOfMFC="0" ATLMinimizesCRunTimeLibraryUsage="FALSE" CharacterSet="2" WholeProgramOptimization="$p->{wholeopt}">
<Tool Name="VCCLCompilerTool" Optimization="$p->{opt}"
AdditionalIncludeDirectories="$self->{prefixincludes}src/include;src/include/port/win32;src/include/port/win32_msvc;$self->{includes}"
PreprocessorDefinitions="WIN32;_WINDOWS;__WINDOWS__;__WIN32__;EXEC_BACKEND;WIN32_STACK_RLIMIT=4194304;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE$self->{defines}$p->{defs}"
StringPooling="$p->{strpool}"
RuntimeLibrary="$p->{runtime}" DisableSpecificWarnings="$self->{disablewarnings}"
AdditionalOptions="/MP"
EOF
print $f <<EOF;
AssemblerOutput="0" AssemblerListingLocation=".\\$cfgname\\$self->{name}\\" ObjectFile=".\\$cfgname\\$self->{name}\\"
ProgramDataBaseFileName=".\\$cfgname\\$self->{name}\\" BrowseInformation="0"
WarningLevel="3" SuppressStartupBanner="TRUE" DebugInformationFormat="3" CompileAs="0"/>
<Tool Name="VCLinkerTool" OutputFile=".\\$cfgname\\$self->{name}\\$self->{name}.$self->{type}"
AdditionalDependencies="$libs"
LinkIncremental="0" SuppressStartupBanner="TRUE" AdditionalLibraryDirectories="" IgnoreDefaultLibraryNames="libc"
StackReserveSize="4194304" DisableSpecificWarnings="$self->{disablewarnings}"
GenerateDebugInformation="TRUE" ProgramDatabaseFile=".\\$cfgname\\$self->{name}\\$self->{name}.pdb"
GenerateMapFile="FALSE" MapFileName=".\\$cfgname\\$self->{name}\\$self->{name}.map"
RandomizedBaseAddress="FALSE"
SubSystem="1" TargetMachine="$targetmachine"
EOF
if ($self->{disablelinkerwarnings})
{
print $f
"\t\tAdditionalOptions=\"/ignore:$self->{disablelinkerwarnings}\"\n";
}
if ($self->{implib})
{
my $l = $self->{implib};
$l =~ s/__CFGNAME__/$cfgname/g;
print $f "\t\tImportLibrary=\"$l\"\n";
}
if ($self->{def})
{
my $d = $self->{def};
$d =~ s/__CFGNAME__/$cfgname/g;
print $f "\t\tModuleDefinitionFile=\"$d\"\n";
}
print $f "\t/>\n";
print $f
"\t<Tool Name=\"VCLibrarianTool\" OutputFile=\".\\$cfgname\\$self->{name}\\$self->{name}.lib\" IgnoreDefaultLibraryNames=\"libc\" />\n";
print $f
"\t<Tool Name=\"VCResourceCompilerTool\" AdditionalIncludeDirectories=\"src\\include\" />\n";
if ($self->{builddef})
{
print $f
"\t<Tool Name=\"VCPreLinkEventTool\" Description=\"Generate DEF file\" CommandLine=\"perl src\\tools\\msvc\\gendef.pl $cfgname\\$self->{name} $self->{platform}\" />\n";
}
print $f <<EOF;
</Configuration>
EOF
return;
}
sub WriteReferences
{
my ($self, $f) = @_;
print $f " <References>\n";
foreach my $ref (@{ $self->{references} })
{
print $f
" <ProjectReference ReferencedProjectIdentifier=\"$ref->{guid}\" Name=\"$ref->{name}\" />\n";
}
print $f " </References>\n";
return;
}
sub GenerateCustomTool
{
my ($self, $desc, $tool, $output, $cfg) = @_;
if (!defined($cfg))
{
return $self->GenerateCustomTool($desc, $tool, $output, 'Debug')
. $self->GenerateCustomTool($desc, $tool, $output, 'Release');
}
return
"<FileConfiguration Name=\"$cfg|$self->{platform}\"><Tool Name=\"VCCustomBuildTool\" Description=\"$desc\" CommandLine=\"$tool\" AdditionalDependencies=\"\" Outputs=\"$output\" /></FileConfiguration>";
}
package VC2005Project;
#
# Package that encapsulates a Visual C++ 2005 project file
#
use strict;
use warnings;
use base qw(VCBuildProject);
no warnings qw(redefine); ## no critic
sub new
{
my $classname = shift;
my $self = $classname->SUPER::_new(@_);
bless($self, $classname);
$self->{vcver} = '8.00';
return $self;
}
package VC2008Project;
#
# Package that encapsulates a Visual C++ 2008 project file
#
use strict;
use warnings;
use base qw(VCBuildProject);
no warnings qw(redefine); ## no critic
sub new
{
my $classname = shift;
my $self = $classname->SUPER::_new(@_);
bless($self, $classname);
$self->{vcver} = '9.00';
return $self;
}
1;

View File

@ -13,7 +13,6 @@ use warnings;
use Exporter;
use Project;
use Solution;
use VCBuildProject;
use MSBuildProject;
our (@ISA, @EXPORT);
@ -31,23 +30,7 @@ sub CreateSolution
$visualStudioVersion = DetermineVisualStudioVersion();
}
if ($visualStudioVersion eq '8.00')
{
return new VS2005Solution(@_);
}
elsif ($visualStudioVersion eq '9.00')
{
return new VS2008Solution(@_);
}
elsif ($visualStudioVersion eq '10.00')
{
return new VS2010Solution(@_);
}
elsif ($visualStudioVersion eq '11.00')
{
return new VS2012Solution(@_);
}
elsif ($visualStudioVersion eq '12.00')
if ($visualStudioVersion eq '12.00')
{
return new VS2013Solution(@_);
}
@ -78,23 +61,7 @@ sub CreateProject
$visualStudioVersion = DetermineVisualStudioVersion();
}
if ($visualStudioVersion eq '8.00')
{
return new VC2005Project(@_);
}
elsif ($visualStudioVersion eq '9.00')
{
return new VC2008Project(@_);
}
elsif ($visualStudioVersion eq '10.00')
{
return new VC2010Project(@_);
}
elsif ($visualStudioVersion eq '11.00')
{
return new VC2012Project(@_);
}
elsif ($visualStudioVersion eq '12.00')
if ($visualStudioVersion eq '12.00')
{
return new VC2013Project(@_);
}

View File

@ -53,16 +53,12 @@ elsif (uc($ARGV[0]) ne "RELEASE")
# ... and do it
if ($buildwhat and $vcver >= 10.00)
if ($buildwhat)
{
system(
"msbuild $buildwhat.vcxproj /verbosity:normal $msbflags /p:Configuration=$bconf"
);
}
elsif ($buildwhat)
{
system("vcbuild $msbflags $buildwhat.vcproj $bconf");
}
else
{
system(