PageRenderTime 59ms CodeModel.GetById 24ms RepoModel.GetById 0ms app.codeStats 1ms

/src/tools/msvc/Mkvcbuild.pm

https://bitbucket.org/robins/postgresql
Perl | 794 lines | 715 code | 59 blank | 20 comment | 44 complexity | 0cf101ee2bd49140b246372c68201166 MD5 | raw file
    

  1. package Mkvcbuild;
    2. 

  2. 

  3. #
    4. 

  4. # Package that generates build files for msvc build
    5. 

  5. #
    6. 

  6. # src/tools/msvc/Mkvcbuild.pm
    7. 

  7. #
    8. 

  8. use Carp;
    9. 

  9. use Win32;
    10. 

  10. use strict;
    11. 

  11. use warnings;
    12. 

  12. use Project;
    13. 

  13. use Solution;
    14. 

  14. use Cwd;
    15. 

  15. use File::Copy;
    16. 

  16. use File::Basename;
    17. 

  17. use Config;
    18. 

  18. use VSObjectFactory;
    19. 

  19. use List::Util qw(first);
    20. 

  20. 

  21. use Exporter;
    22. 

  22. our (@ISA, @EXPORT_OK);
    23. 

  23. @ISA       = qw(Exporter);
    24. 

  24. @EXPORT_OK = qw(Mkvcbuild);
    25. 

  25. 

  26. my $solution;
    27. 

  27. my $libpgport;
    28. 

  28. my $libpgcommon;
    29. 

  29. my $postgres;
    30. 

  30. my $libpq;
    31. 

  31. 

  32. my $contrib_defines = { 'refint' => 'REFINT_VERBOSE' };
    33. 

  33. my @contrib_uselibpq =
    34. 

  34.   ('dblink', 'oid2name', 'pgbench', 'pg_upgrade', 'postgres_fdw', 'vacuumlo');
    35. 

  35. my @contrib_uselibpgport = (
    36. 

  36. 	'oid2name',      'pgbench',
    37. 

  37. 	'pg_standby',    'pg_archivecleanup',
    38. 

  38. 	'pg_test_fsync', 'pg_test_timing',
    39. 

  39. 	'pg_upgrade',    'pg_xlogdump',
    40. 

  40. 	'vacuumlo');
    41. 

  41. my @contrib_uselibpgcommon = (
    42. 

  42. 	'oid2name',      'pgbench',
    43. 

  43. 	'pg_standby',    'pg_archivecleanup',
    44. 

  44. 	'pg_test_fsync', 'pg_test_timing',
    45. 

  45. 	'pg_upgrade',    'pg_xlogdump',
    46. 

  46. 	'vacuumlo');
    47. 

  47. my $contrib_extralibs = { 'pgbench' => ['wsock32.lib'] };
    48. 

  48. my $contrib_extraincludes =
    49. 

  49.   { 'tsearch2' => ['contrib/tsearch2'], 'dblink' => ['src/backend'] };
    50. 

  50. my $contrib_extrasource = {
    51. 

  51. 	'cube' => [ 'cubescan.l', 'cubeparse.y' ],
    52. 

  52. 	'seg'  => [ 'segscan.l',  'segparse.y' ], 
    53. 

  53. 	};
    54. 

  54. my @contrib_excludes = ('pgcrypto', 'intagg', 'sepgsql');
    55. 

  55. 

  56. sub mkvcbuild
    57. 

  57. {
    58. 

  58. 	our $config = shift;
    59. 

  59. 

  60. 	chdir('..\..\..') if (-d '..\msvc' && -d '..\..\..\src');
    61. 

  61. 	die 'Must run from root or msvc directory'
    62. 

  62. 	  unless (-d 'src\tools\msvc' && -d 'src');
    63. 

  63. 

  64. 	my $vsVersion = DetermineVisualStudioVersion();
    65. 

  65. 

  66. 	$solution = CreateSolution($vsVersion, $config);
    67. 

  67. 

  68. 	our @pgportfiles = qw(
    69. 

  69. 	  chklocale.c crypt.c fls.c fseeko.c getrusage.c inet_aton.c random.c
    70. 

  70. 	  srandom.c getaddrinfo.c gettimeofday.c inet_net_ntop.c kill.c open.c
    71. 

  71. 	  erand48.c snprintf.c strlcat.c strlcpy.c dirmod.c exec.c noblock.c path.c
    72. 

  72. 	  pgcheckdir.c pg_crc.c pgmkdirp.c pgsleep.c pgstrcasecmp.c pqsignal.c
    73. 

  73. 	  qsort.c qsort_arg.c quotes.c
    74. 

  74. 	  sprompt.c tar.c thread.c wait_error.c getopt.c getopt_long.c dirent.c rint.c win32env.c
    75. 

  75. 	  win32error.c win32setlocale.c);
    76. 

  76. 

  77. 	our @pgcommonallfiles = qw(
    78. 

  78. 		relpath.c);
    79. 

  79. 

  80. 	our @pgcommonfrontendfiles = (@pgcommonallfiles,
    81. 

  81. 		qw(fe_memutils.c));
    82. 

  82. 

  83. 	our @pgcommonbkndfiles = @pgcommonallfiles;
    84. 

  84. 

  85. 	$libpgport = $solution->AddProject('libpgport', 'lib', 'misc');
    86. 

  86. 	$libpgport->AddDefine('FRONTEND');
    87. 

  87. 	$libpgport->AddFiles('src\port', @pgportfiles);
    88. 

  88. 

  89. 	$libpgcommon = $solution->AddProject('libpgcommon', 'lib', 'misc');
    90. 

  90. 	$libpgcommon->AddDefine('FRONTEND');
    91. 

  91. 	$libpgcommon->AddFiles('src\common', @pgcommonfrontendfiles);
    92. 

  92. 

  93. 	$postgres = $solution->AddProject('postgres', 'exe', '', 'src\backend');
    94. 

  94. 	$postgres->AddIncludeDir('src\backend');
    95. 

  95. 	$postgres->AddDir('src\backend\port\win32');
    96. 

  96. 	$postgres->AddFile('src\backend\utils\fmgrtab.c');
    97. 

  97. 	$postgres->ReplaceFile(
    98. 

  98. 		'src\backend\port\dynloader.c',
    99. 

  99. 		'src\backend\port\dynloader\win32.c');
    100. 

  100. 	$postgres->ReplaceFile('src\backend\port\pg_sema.c',
    101. 

  101. 		'src\backend\port\win32_sema.c');
    102. 

  102. 	$postgres->ReplaceFile('src\backend\port\pg_shmem.c',
    103. 

  103. 		'src\backend\port\win32_shmem.c');
    104. 

  104. 	$postgres->ReplaceFile('src\backend\port\pg_latch.c',
    105. 

  105. 		'src\backend\port\win32_latch.c');
    106. 

  106. 	$postgres->AddFiles('src\port', @pgportfiles);
    107. 

  107. 	$postgres->AddFiles('src\common', @pgcommonbkndfiles);
    108. 

  108. 	$postgres->AddDir('src\timezone');
    109. 

  109. 	$postgres->AddFiles('src\backend\parser', 'scan.l', 'gram.y');
    110. 

  110. 	$postgres->AddFiles('src\backend\bootstrap', 'bootscanner.l',
    111. 

  111. 		'bootparse.y');
    112. 

  112. 	$postgres->AddFiles('src\backend\utils\misc', 'guc-file.l');
    113. 

  113. 	$postgres->AddFiles('src\backend\replication', 'repl_scanner.l',
    114. 

  114. 		'repl_gram.y');
    115. 

  115. 	$postgres->AddDefine('BUILDING_DLL');
    116. 

  116. 	$postgres->AddLibrary('wsock32.lib');
    117. 

  117. 	$postgres->AddLibrary('ws2_32.lib');
    118. 

  118. 	$postgres->AddLibrary('secur32.lib');
    119. 

  119. 	$postgres->AddLibrary('wldap32.lib') if ($solution->{options}->{ldap});
    120. 

  120. 	$postgres->FullExportDLL('postgres.lib');
    121. 

  121. 

  122. 	my $snowball = $solution->AddProject('dict_snowball', 'dll', '',
    123. 

  123. 		'src\backend\snowball');
    124. 

  124. 	$snowball->RelocateFiles(
    125. 

  125. 		'src\backend\snowball\libstemmer',
    126. 

  126. 		sub {
    127. 

  127. 			return shift !~ /dict_snowball.c$/;
    128. 

  128. 		});
    129. 

  129. 	$snowball->AddIncludeDir('src\include\snowball');
    130. 

  130. 	$snowball->AddReference($postgres);
    131. 

  131. 

  132. 	my $plpgsql =
    133. 

  133. 	  $solution->AddProject('plpgsql', 'dll', 'PLs', 'src\pl\plpgsql\src');
    134. 

  134. 	$plpgsql->AddFiles('src\pl\plpgsql\src', 'pl_gram.y');
    135. 

  135. 	$plpgsql->AddReference($postgres);
    136. 

  136. 

  137. 	if ($solution->{options}->{perl})
    138. 

  138. 	{
    139. 

  139. 		my $plperlsrc = "src\\pl\\plperl\\";
    140. 

  140. 		my $plperl =
    141. 

  141. 		  $solution->AddProject('plperl', 'dll', 'PLs', 'src\pl\plperl');
    142. 

  142. 		$plperl->AddIncludeDir($solution->{options}->{perl} . '/lib/CORE');
    143. 

  143. 		$plperl->AddDefine('PLPERL_HAVE_UID_GID');
    144. 

  144. 		foreach my $xs ('SPI.xs', 'Util.xs')
    145. 

  145. 		{
    146. 

  146. 			(my $xsc = $xs) =~ s/\.xs/.c/;
    147. 

  147. 			if (Solution::IsNewer("$plperlsrc$xsc", "$plperlsrc$xs"))
    148. 

  148. 			{
    149. 

  149. 				my $xsubppdir = first { -e "$_\\ExtUtils\\xsubpp" } @INC;
    150. 

  150. 				print "Building $plperlsrc$xsc...\n";
    151. 

  151. 				system( $solution->{options}->{perl}
    152. 

  152. 					  . '/bin/perl '
    153. 

  153. 					  . "$xsubppdir/ExtUtils/xsubpp -typemap "
    154. 

  154. 					  . $solution->{options}->{perl}
    155. 

  155. 					  . '/lib/ExtUtils/typemap '
    156. 

  156. 					  . "$plperlsrc$xs "
    157. 

  157. 					  . ">$plperlsrc$xsc");
    158. 

  158. 				if ((!(-f "$plperlsrc$xsc")) || -z "$plperlsrc$xsc")
    159. 

  159. 				{
    160. 

  160. 					unlink("$plperlsrc$xsc");    # if zero size
    161. 

  161. 					die "Failed to create $xsc.\n";
    162. 

  162. 				}
    163. 

  163. 			}
    164. 

  164. 		}
    165. 

  165. 		if (Solution::IsNewer(
    166. 

  166. 				'src\pl\plperl\perlchunks.h',
    167. 

  167. 				'src\pl\plperl\plc_perlboot.pl')
    168. 

  168. 			|| Solution::IsNewer(
    169. 

  169. 				'src\pl\plperl\perlchunks.h',
    170. 

  170. 				'src\pl\plperl\plc_trusted.pl'))
    171. 

  171. 		{
    172. 

  172. 			print 'Building src\pl\plperl\perlchunks.h ...' . "\n";
    173. 

  173. 			my $basedir = getcwd;
    174. 

  174. 			chdir 'src\pl\plperl';
    175. 

  175. 			system( $solution->{options}->{perl}
    176. 

  176. 				  . '/bin/perl '
    177. 

  177. 				  . 'text2macro.pl '
    178. 

  178. 				  . '--strip="^(\#.*|\s*)$$" '
    179. 

  179. 				  . 'plc_perlboot.pl plc_trusted.pl '
    180. 

  180. 				  . '>perlchunks.h');
    181. 

  181. 			chdir $basedir;
    182. 

  182. 			if ((!(-f 'src\pl\plperl\perlchunks.h'))
    183. 

  183. 				|| -z 'src\pl\plperl\perlchunks.h')
    184. 

  184. 			{
    185. 

  185. 				unlink('src\pl\plperl\perlchunks.h');    # if zero size
    186. 

  186. 				die 'Failed to create perlchunks.h' . "\n";
    187. 

  187. 			}
    188. 

  188. 		}
    189. 

  189. 		if (Solution::IsNewer(
    190. 

  190. 				'src\pl\plperl\plperl_opmask.h',
    191. 

  191. 				'src\pl\plperl\plperl_opmask.pl'))
    192. 

  192. 		{
    193. 

  193. 			print 'Building src\pl\plperl\plperl_opmask.h ...' . "\n";
    194. 

  194. 			my $basedir = getcwd;
    195. 

  195. 			chdir 'src\pl\plperl';
    196. 

  196. 			system( $solution->{options}->{perl}
    197. 

  197. 				  . '/bin/perl '
    198. 

  198. 				  . 'plperl_opmask.pl '
    199. 

  199. 				  . 'plperl_opmask.h');
    200. 

  200. 			chdir $basedir;
    201. 

  201. 			if ((!(-f 'src\pl\plperl\plperl_opmask.h'))
    202. 

  202. 				|| -z 'src\pl\plperl\plperl_opmask.h')
    203. 

  203. 			{
    204. 

  204. 				unlink('src\pl\plperl\plperl_opmask.h');    # if zero size
    205. 

  205. 				die 'Failed to create plperl_opmask.h' . "\n";
    206. 

  206. 			}
    207. 

  207. 		}
    208. 

  208. 		$plperl->AddReference($postgres);
    209. 

  209. 		my @perl_libs =
    210. 

  210. 		  grep { /perl\d+.lib$/ }
    211. 

  211. 		  glob($solution->{options}->{perl} . '\lib\CORE\perl*.lib');
    212. 

  212. 		if (@perl_libs == 1)
    213. 

  213. 		{
    214. 

  214. 			$plperl->AddLibrary($perl_libs[0]);
    215. 

  215. 		}
    216. 

  216. 		else
    217. 

  217. 		{
    218. 

  218. 			die "could not identify perl library version";
    219. 

  219. 		}
    220. 

  220. 	}
    221. 

  221. 

  222. 	if ($solution->{options}->{python})
    223. 

  223. 	{
    224. 

  224. 

  225. 		# Attempt to get python version and location.
    226. 

  226. 		# Assume python.exe in specified dir.
    227. 

  227. 		open(P,
    228. 

  228. 			$solution->{options}->{python}
    229. 

  229. 			  . "\\python -c \"import sys;print(sys.prefix);print(str(sys.version_info[0])+str(sys.version_info[1]))\" |"
    230. 

  230. 		) || die "Could not query for python version!\n";
    231. 

  231. 		my $pyprefix = <P>;
    232. 

  232. 		chomp($pyprefix);
    233. 

  233. 		my $pyver = <P>;
    234. 

  234. 		chomp($pyver);
    235. 

  235. 		close(P);
    236. 

  236. 

  237. 		# Sometimes (always?) if python is not present, the execution
    238. 

  238. 		# appears to work, but gives no data...
    239. 

  239. 		die "Failed to query python for version information\n"
    240. 

  240. 		  if (!(defined($pyprefix) && defined($pyver)));
    241. 

  241. 

  242. 		my $pymajorver = substr($pyver, 0, 1);
    243. 

  243. 		my $plpython = $solution->AddProject('plpython' . $pymajorver,
    244. 

  244. 			'dll', 'PLs', 'src\pl\plpython');
    245. 

  245. 		$plpython->AddIncludeDir($pyprefix . '\include');
    246. 

  246. 		$plpython->AddLibrary($pyprefix . "\\Libs\\python$pyver.lib");
    247. 

  247. 		$plpython->AddReference($postgres);
    248. 

  248. 	}
    249. 

  249. 

  250. 	if ($solution->{options}->{tcl})
    251. 

  251. 	{
    252. 

  252. 		my $pltcl =
    253. 

  253. 		  $solution->AddProject('pltcl', 'dll', 'PLs', 'src\pl\tcl');
    254. 

  254. 		$pltcl->AddIncludeDir($solution->{options}->{tcl} . '\include');
    255. 

  255. 		$pltcl->AddReference($postgres);
    256. 

  256. 		if (-e $solution->{options}->{tcl} . '\lib\tcl85.lib')
    257. 

  257. 		{
    258. 

  258. 			$pltcl->AddLibrary(
    259. 

  259. 				$solution->{options}->{tcl} . '\lib\tcl85.lib');
    260. 

  260. 		}
    261. 

  261. 		else
    262. 

  262. 		{
    263. 

  263. 			$pltcl->AddLibrary(
    264. 

  264. 				$solution->{options}->{tcl} . '\lib\tcl84.lib');
    265. 

  265. 		}
    266. 

  266. 	}
    267. 

  267. 

  268. 	$libpq = $solution->AddProject('libpq', 'dll', 'interfaces',
    269. 

  269. 		'src\interfaces\libpq');
    270. 

  270. 	$libpq->AddDefine('FRONTEND');
    271. 

  271. 	$libpq->AddDefine('UNSAFE_STAT_OK');
    272. 

  272. 	$libpq->AddIncludeDir('src\port');
    273. 

  273. 	$libpq->AddLibrary('wsock32.lib');
    274. 

  274. 	$libpq->AddLibrary('secur32.lib');
    275. 

  275. 	$libpq->AddLibrary('ws2_32.lib');
    276. 

  276. 	$libpq->AddLibrary('wldap32.lib') if ($solution->{options}->{ldap});
    277. 

  277. 	$libpq->UseDef('src\interfaces\libpq\libpqdll.def');
    278. 

  278. 	$libpq->ReplaceFile('src\interfaces\libpq\libpqrc.c',
    279. 

  279. 		'src\interfaces\libpq\libpq.rc');
    280. 

  280. 	$libpq->AddReference($libpgport);
    281. 

  281. 

  282. 	my $libpqwalreceiver =
    283. 

  283. 	  $solution->AddProject('libpqwalreceiver', 'dll', '',
    284. 

  284. 		'src\backend\replication\libpqwalreceiver');
    285. 

  285. 	$libpqwalreceiver->AddIncludeDir('src\interfaces\libpq');
    286. 

  286. 	$libpqwalreceiver->AddReference($postgres, $libpq);
    287. 

  287. 

  288. 	my $pgtypes = $solution->AddProject(
    289. 

  289. 		'libpgtypes', 'dll',
    290. 

  290. 		'interfaces', 'src\interfaces\ecpg\pgtypeslib');
    291. 

  291. 	$pgtypes->AddDefine('FRONTEND');
    292. 

  292. 	$pgtypes->AddReference($libpgport);
    293. 

  293. 	$pgtypes->UseDef('src\interfaces\ecpg\pgtypeslib\pgtypeslib.def');
    294. 

  294. 	$pgtypes->AddIncludeDir('src\interfaces\ecpg\include');
    295. 

  295. 

  296. 	my $libecpg = $solution->AddProject('libecpg', 'dll', 'interfaces',
    297. 

  297. 		'src\interfaces\ecpg\ecpglib');
    298. 

  298. 	$libecpg->AddDefine('FRONTEND');
    299. 

  299. 	$libecpg->AddIncludeDir('src\interfaces\ecpg\include');
    300. 

  300. 	$libecpg->AddIncludeDir('src\interfaces\libpq');
    301. 

  301. 	$libecpg->AddIncludeDir('src\port');
    302. 

  302. 	$libecpg->UseDef('src\interfaces\ecpg\ecpglib\ecpglib.def');
    303. 

  303. 	$libecpg->AddLibrary('wsock32.lib');
    304. 

  304. 	$libecpg->AddReference($libpq, $pgtypes, $libpgport);
    305. 

  305. 

  306. 	my $libecpgcompat = $solution->AddProject(
    307. 

  307. 		'libecpg_compat', 'dll',
    308. 

  308. 		'interfaces',     'src\interfaces\ecpg\compatlib');
    309. 

  309. 	$libecpgcompat->AddIncludeDir('src\interfaces\ecpg\include');
    310. 

  310. 	$libecpgcompat->AddIncludeDir('src\interfaces\libpq');
    311. 

  311. 	$libecpgcompat->UseDef('src\interfaces\ecpg\compatlib\compatlib.def');
    312. 

  312. 	$libecpgcompat->AddReference($pgtypes, $libecpg, $libpgport);
    313. 

  313. 

  314. 	my $ecpg = $solution->AddProject('ecpg', 'exe', 'interfaces',
    315. 

  315. 		'src\interfaces\ecpg\preproc');
    316. 

  316. 	$ecpg->AddIncludeDir('src\interfaces\ecpg\include');
    317. 

  317. 	$ecpg->AddIncludeDir('src\interfaces\libpq');
    318. 

  318. 	$ecpg->AddPrefixInclude('src\interfaces\ecpg\preproc');
    319. 

  319. 	$ecpg->AddFiles('src\interfaces\ecpg\preproc', 'pgc.l', 'preproc.y');
    320. 

  320. 	$ecpg->AddDefine('MAJOR_VERSION=4');
    321. 

  321. 	$ecpg->AddDefine('MINOR_VERSION=9');
    322. 

  322. 	$ecpg->AddDefine('PATCHLEVEL=0');
    323. 

  323. 	$ecpg->AddDefine('ECPG_COMPILE');
    324. 

  324. 	$ecpg->AddReference($libpgport, $libpgcommon);
    325. 

  325. 

  326. 	my $pgregress_ecpg =
    327. 

  327. 	  $solution->AddProject('pg_regress_ecpg', 'exe', 'misc');
    328. 

  328. 	$pgregress_ecpg->AddFile('src\interfaces\ecpg\test\pg_regress_ecpg.c');
    329. 

  329. 	$pgregress_ecpg->AddFile('src\test\regress\pg_regress.c');
    330. 

  330. 	$pgregress_ecpg->AddIncludeDir('src\port');
    331. 

  331. 	$pgregress_ecpg->AddIncludeDir('src\test\regress');
    332. 

  332. 	$pgregress_ecpg->AddDefine('HOST_TUPLE="i686-pc-win32vc"');
    333. 

  333. 	$pgregress_ecpg->AddDefine('FRONTEND');
    334. 

  334. 	$pgregress_ecpg->AddReference($libpgport, $libpgcommon);
    335. 

  335. 

  336. 	my $isolation_tester =
    337. 

  337. 	  $solution->AddProject('isolationtester', 'exe', 'misc');
    338. 

  338. 	$isolation_tester->AddFile('src\test\isolation\isolationtester.c');
    339. 

  339. 	$isolation_tester->AddFile('src\test\isolation\specparse.y');
    340. 

  340. 	$isolation_tester->AddFile('src\test\isolation\specscanner.l');
    341. 

  341. 	$isolation_tester->AddFile('src\test\isolation\specparse.c');
    342. 

  342. 	$isolation_tester->AddIncludeDir('src\test\isolation');
    343. 

  343. 	$isolation_tester->AddIncludeDir('src\port');
    344. 

  344. 	$isolation_tester->AddIncludeDir('src\test\regress');
    345. 

  345. 	$isolation_tester->AddIncludeDir('src\interfaces\libpq');
    346. 

  346. 	$isolation_tester->AddDefine('HOST_TUPLE="i686-pc-win32vc"');
    347. 

  347. 	$isolation_tester->AddDefine('FRONTEND');
    348. 

  348. 	$isolation_tester->AddLibrary('wsock32.lib');
    349. 

  349. 	$isolation_tester->AddReference($libpq, $libpgport);
    350. 

  350. 

  351. 	my $pgregress_isolation =
    352. 

  352. 	  $solution->AddProject('pg_isolation_regress', 'exe', 'misc');
    353. 

  353. 	$pgregress_isolation->AddFile('src\test\isolation\isolation_main.c');
    354. 

  354. 	$pgregress_isolation->AddFile('src\test\regress\pg_regress.c');
    355. 

  355. 	$pgregress_isolation->AddIncludeDir('src\port');
    356. 

  356. 	$pgregress_isolation->AddIncludeDir('src\test\regress');
    357. 

  357. 	$pgregress_isolation->AddDefine('HOST_TUPLE="i686-pc-win32vc"');
    358. 

  358. 	$pgregress_isolation->AddDefine('FRONTEND');
    359. 

  359. 	$pgregress_isolation->AddReference($libpgport, $libpgcommon);
    360. 

  360. 

  361. 	# src/bin
    362. 

  362. 	my $initdb = AddSimpleFrontend('initdb');
    363. 

  363. 	$initdb->AddIncludeDir('src\interfaces\libpq');
    364. 

  364. 	$initdb->AddIncludeDir('src\timezone');
    365. 

  365. 	$initdb->AddDefine('FRONTEND');
    366. 

  366. 	$initdb->AddLibrary('wsock32.lib');
    367. 

  367. 	$initdb->AddLibrary('ws2_32.lib');
    368. 

  368. 

  369. 	my $pgbasebackup = AddSimpleFrontend('pg_basebackup', 1);
    370. 

  370. 	$pgbasebackup->AddFile('src\bin\pg_basebackup\pg_basebackup.c');
    371. 

  371. 	$pgbasebackup->AddLibrary('ws2_32.lib');
    372. 

  372. 

  373. 	my $pgreceivexlog = AddSimpleFrontend('pg_basebackup', 1);
    374. 

  374. 	$pgreceivexlog->{name} = 'pg_receivexlog';
    375. 

  375. 	$pgreceivexlog->AddFile('src\bin\pg_basebackup\pg_receivexlog.c');
    376. 

  376. 	$pgreceivexlog->AddLibrary('ws2_32.lib');
    377. 

  377. 

  378. 	my $pgconfig = AddSimpleFrontend('pg_config');
    379. 

  379. 

  380. 	my $pgcontrol = AddSimpleFrontend('pg_controldata');
    381. 

  381. 

  382. 	my $pgctl = AddSimpleFrontend('pg_ctl', 1);
    383. 

  383. 

  384. 	my $pgreset = AddSimpleFrontend('pg_resetxlog');
    385. 

  385. 

  386. 	my $pgevent = $solution->AddProject('pgevent', 'dll', 'bin');
    387. 

  387. 	$pgevent->AddFiles('src\bin\pgevent', 'pgevent.c', 'pgmsgevent.rc');
    388. 

  388. 	$pgevent->AddResourceFile('src\bin\pgevent',
    389. 

  389. 		'Eventlog message formatter');
    390. 

  390. 	$pgevent->RemoveFile('src\bin\pgevent\win32ver.rc');
    391. 

  391. 	$pgevent->UseDef('src\bin\pgevent\pgevent.def');
    392. 

  392. 	$pgevent->DisableLinkerWarnings('4104');
    393. 

  393. 

  394. 	my $psql = AddSimpleFrontend('psql', 1);
    395. 

  395. 	$psql->AddIncludeDir('src\bin\pg_dump');
    396. 

  396. 	$psql->AddIncludeDir('src\backend');
    397. 

  397. 	$psql->AddFile('src\bin\psql\psqlscan.l');
    398. 

  398. 

  399. 	my $pgdump = AddSimpleFrontend('pg_dump', 1);
    400. 

  400. 	$pgdump->AddIncludeDir('src\backend');
    401. 

  401. 	$pgdump->AddFile('src\bin\pg_dump\pg_dump.c');
    402. 

  402. 	$pgdump->AddFile('src\bin\pg_dump\common.c');
    403. 

  403. 	$pgdump->AddFile('src\bin\pg_dump\pg_dump_sort.c');
    404. 

  404. 	$pgdump->AddFile('src\bin\pg_dump\keywords.c');
    405. 

  405. 	$pgdump->AddFile('src\backend\parser\kwlookup.c');
    406. 

  406. 

  407. 	my $pgdumpall = AddSimpleFrontend('pg_dump', 1);
    408. 

  408. 

  409. 	# pg_dumpall doesn't use the files in the Makefile's $(OBJS), unlike
    410. 

  410. 	# pg_dump and pg_restore.
    411. 

  411. 	# So remove their sources from the object, keeping the other setup that
    412. 

  412. 	# AddSimpleFrontend() has done.
    413. 

  413. 	my @nodumpall = grep { m/src\\bin\\pg_dump\\.*\.c$/ }
    414. 

  414. 	  keys %{ $pgdumpall->{files} };
    415. 

  415. 	delete @{ $pgdumpall->{files} }{@nodumpall};
    416. 

  416. 	$pgdumpall->{name} = 'pg_dumpall';
    417. 

  417. 	$pgdumpall->AddIncludeDir('src\backend');
    418. 

  418. 	$pgdumpall->AddFile('src\bin\pg_dump\pg_dumpall.c');
    419. 

  419. 	$pgdumpall->AddFile('src\bin\pg_dump\dumputils.c');
    420. 

  420. 	$pgdumpall->AddFile('src\bin\pg_dump\keywords.c');
    421. 

  421. 	$pgdumpall->AddFile('src\backend\parser\kwlookup.c');
    422. 

  422. 

  423. 	my $pgrestore = AddSimpleFrontend('pg_dump', 1);
    424. 

  424. 	$pgrestore->{name} = 'pg_restore';
    425. 

  425. 	$pgrestore->AddIncludeDir('src\backend');
    426. 

  426. 	$pgrestore->AddFile('src\bin\pg_dump\pg_restore.c');
    427. 

  427. 	$pgrestore->AddFile('src\bin\pg_dump\keywords.c');
    428. 

  428. 	$pgrestore->AddFile('src\backend\parser\kwlookup.c');
    429. 

  429. 

  430. 	my $zic = $solution->AddProject('zic', 'exe', 'utils');
    431. 

  431. 	$zic->AddFiles('src\timezone', 'zic.c', 'ialloc.c', 'scheck.c',
    432. 

  432. 		'localtime.c');
    433. 

  433. 	$zic->AddReference($libpgport, $libpgcommon);
    434. 

  434. 

  435. 	if ($solution->{options}->{xml})
    436. 

  436. 	{
    437. 

  437. 		$contrib_extraincludes->{'pgxml'} = [
    438. 

  438. 			$solution->{options}->{xml} . '\include',
    439. 

  439. 			$solution->{options}->{xslt} . '\include',
    440. 

  440. 			$solution->{options}->{iconv} . '\include' ];
    441. 

  441. 

  442. 		$contrib_extralibs->{'pgxml'} = [
    443. 

  443. 			$solution->{options}->{xml} . '\lib\libxml2.lib',
    444. 

  444. 			$solution->{options}->{xslt} . '\lib\libxslt.lib' ];
    445. 

  445. 	}
    446. 

  446. 	else
    447. 

  447. 	{
    448. 

  448. 		push @contrib_excludes, 'xml2';
    449. 

  449. 	}
    450. 

  450. 

  451. 	if (!$solution->{options}->{openssl})
    452. 

  452. 	{
    453. 

  453. 		push @contrib_excludes, 'sslinfo';
    454. 

  454. 	}
    455. 

  455. 

  456. 	if ($solution->{options}->{uuid})
    457. 

  457. 	{
    458. 

  458. 		$contrib_extraincludes->{'uuid-ossp'} =
    459. 

  459. 		  [ $solution->{options}->{uuid} . '\include' ];
    460. 

  460. 		$contrib_extralibs->{'uuid-ossp'} =
    461. 

  461. 		  [ $solution->{options}->{uuid} . '\lib\uuid.lib' ];
    462. 

  462. 	}
    463. 

  463. 	else
    464. 

  464. 	{
    465. 

  465. 		push @contrib_excludes, 'uuid-ossp';
    466. 

  466. 	}
    467. 

  467. 

  468. 	# Pgcrypto makefile too complex to parse....
    469. 

  469. 	my $pgcrypto = $solution->AddProject('pgcrypto', 'dll', 'crypto');
    470. 

  470. 	$pgcrypto->AddFiles(
    471. 

  471. 		'contrib\pgcrypto', 'pgcrypto.c',
    472. 

  472. 		'px.c',             'px-hmac.c',
    473. 

  473. 		'px-crypt.c',       'crypt-gensalt.c',
    474. 

  474. 		'crypt-blowfish.c', 'crypt-des.c',
    475. 

  475. 		'crypt-md5.c',      'mbuf.c',
    476. 

  476. 		'pgp.c',            'pgp-armor.c',
    477. 

  477. 		'pgp-cfb.c',        'pgp-compress.c',
    478. 

  478. 		'pgp-decrypt.c',    'pgp-encrypt.c',
    479. 

  479. 		'pgp-info.c',       'pgp-mpi.c',
    480. 

  480. 		'pgp-pubdec.c',     'pgp-pubenc.c',
    481. 

  481. 		'pgp-pubkey.c',     'pgp-s2k.c',
    482. 

  482. 		'pgp-pgsql.c');
    483. 

  483. 	if ($solution->{options}->{openssl})
    484. 

  484. 	{
    485. 

  485. 		$pgcrypto->AddFiles('contrib\pgcrypto', 'openssl.c',
    486. 

  486. 			'pgp-mpi-openssl.c');
    487. 

  487. 	}
    488. 

  488. 	else
    489. 

  489. 	{
    490. 

  490. 		$pgcrypto->AddFiles(
    491. 

  491. 			'contrib\pgcrypto',   'md5.c',
    492. 

  492. 			'sha1.c',             'sha2.c',
    493. 

  493. 			'internal.c',         'internal-sha2.c',
    494. 

  494. 			'blf.c',              'rijndael.c',
    495. 

  495. 			'fortuna.c',          'random.c',
    496. 

  496. 			'pgp-mpi-internal.c', 'imath.c');
    497. 

  497. 	}
    498. 

  498. 	$pgcrypto->AddReference($postgres);
    499. 

  499. 	$pgcrypto->AddLibrary('wsock32.lib');
    500. 

  500. 	my $mf = Project::read_file('contrib/pgcrypto/Makefile');
    501. 

  501. 	GenerateContribSqlFiles('pgcrypto', $mf);
    502. 

  502. 

  503. 	my $D;
    504. 

  504. 	opendir($D, 'contrib') || croak "Could not opendir on contrib!\n";
    505. 

  505. 	while (my $d = readdir($D))
    506. 

  506. 	{
    507. 

  507. 		next if ($d =~ /^\./);
    508. 

  508. 		next unless (-f "contrib/$d/Makefile");
    509. 

  509. 		next if (grep { /^$d$/ } @contrib_excludes);
    510. 

  510. 		AddContrib($d);
    511. 

  511. 	}
    512. 

  512. 	closedir($D);
    513. 

  513. 

  514. 	$mf =
    515. 

  515. 	  Project::read_file('src\backend\utils\mb\conversion_procs\Makefile');
    516. 

  516. 	$mf =~ s{\\s*[\r\n]+}{}mg;
    517. 

  517. 	$mf =~ m{SUBDIRS\s*=\s*(.*)$}m
    518. 

  518. 	  || die 'Could not match in conversion makefile' . "\n";
    519. 

  519. 	foreach my $sub (split /\s+/, $1)
    520. 

  520. 	{
    521. 

  521. 		my $mf = Project::read_file(
    522. 

  522. 			'src\backend\utils\mb\conversion_procs\\' . $sub . '\Makefile');
    523. 

  523. 		my $p = $solution->AddProject($sub, 'dll', 'conversion procs');
    524. 

  524. 		$p->AddFile('src\backend\utils\mb\conversion_procs\\' 
    525. 

  525. 			  . $sub . '\\' 
    526. 

  526. 			  . $sub
    527. 

  527. 			  . '.c');
    528. 

  528. 		if ($mf =~ m{^SRCS\s*\+=\s*(.*)$}m)
    529. 

  529. 		{
    530. 

  530. 			$p->AddFile(
    531. 

  531. 				'src\backend\utils\mb\conversion_procs\\' . $sub . '\\' . $1);
    532. 

  532. 		}
    533. 

  533. 		$p->AddReference($postgres);
    534. 

  534. 	}
    535. 

  535. 

  536. 	$mf = Project::read_file('src\bin\scripts\Makefile');
    537. 

  537. 	$mf =~ s{\\s*[\r\n]+}{}mg;
    538. 

  538. 	$mf =~ m{PROGRAMS\s*=\s*(.*)$}m
    539. 

  539. 	  || die 'Could not match in bin\scripts\Makefile' . "\n";
    540. 

  540. 	foreach my $prg (split /\s+/, $1)
    541. 

  541. 	{
    542. 

  542. 		my $proj = $solution->AddProject($prg, 'exe', 'bin');
    543. 

  543. 		$mf =~ m{$prg\s*:\s*(.*)$}m
    544. 

  544. 		  || die 'Could not find script define for $prg' . "\n";
    545. 

  545. 		my @files = split /\s+/, $1;
    546. 

  546. 		foreach my $f (@files)
    547. 

  547. 		{
    548. 

  548. 			$f =~ s/\.o$/\.c/;
    549. 

  549. 			if ($f eq 'keywords.c')
    550. 

  550. 			{
    551. 

  551. 				$proj->AddFile('src\bin\pg_dump\keywords.c');
    552. 

  552. 			}
    553. 

  553. 			elsif ($f eq 'kwlookup.c')
    554. 

  554. 			{
    555. 

  555. 				$proj->AddFile('src\backend\parser\kwlookup.c');
    556. 

  556. 			}
    557. 

  557. 			elsif ($f eq 'dumputils.c')
    558. 

  558. 			{
    559. 

  559. 				$proj->AddFile('src\bin\pg_dump\dumputils.c');
    560. 

  560. 			}
    561. 

  561. 			elsif ($f =~ /print\.c$/)
    562. 

  562. 			{    # Also catches mbprint.c
    563. 

  563. 				$proj->AddFile('src\bin\psql\\' . $f);
    564. 

  564. 			}
    565. 

  565. 			elsif ($f =~ /\.c$/)
    566. 

  566. 			{
    567. 

  567. 				$proj->AddFile('src\bin\scripts\\' . $f);
    568. 

  568. 			}
    569. 

  569. 		}
    570. 

  570. 		$proj->AddIncludeDir('src\interfaces\libpq');
    571. 

  571. 		$proj->AddIncludeDir('src\bin\pg_dump');
    572. 

  572. 		$proj->AddIncludeDir('src\bin\psql');
    573. 

  573. 		$proj->AddReference($libpq, $libpgport, $libpgcommon);
    574. 

  574. 		$proj->AddResourceFile('src\bin\scripts', 'PostgreSQL Utility');
    575. 

  575. 	}
    576. 

  576. 

  577. 	# Regression DLL and EXE
    578. 

  578. 	my $regress = $solution->AddProject('regress', 'dll', 'misc');
    579. 

  579. 	$regress->AddFile('src\test\regress\regress.c');
    580. 

  580. 	$regress->AddReference($postgres);
    581. 

  581. 

  582. 	my $pgregress = $solution->AddProject('pg_regress', 'exe', 'misc');
    583. 

  583. 	$pgregress->AddFile('src\test\regress\pg_regress.c');
    584. 

  584. 	$pgregress->AddFile('src\test\regress\pg_regress_main.c');
    585. 

  585. 	$pgregress->AddIncludeDir('src\port');
    586. 

  586. 	$pgregress->AddDefine('HOST_TUPLE="i686-pc-win32vc"');
    587. 

  587. 	$pgregress->AddReference($libpgport, $libpgcommon);
    588. 

  588. 

  589. 	# fix up pg_xlogdump once it's been set up
    590. 

  590. 	# files symlinked on Unix are copied on windows
    591. 

  591. 	my $pg_xlogdump = (grep {$_->{name} eq 'pg_xlogdump'} 
    592. 

  592. 					   @{$solution->{projects}->{contrib}} )[0];
    593. 

  593. 	$pg_xlogdump->AddDefine('FRONTEND');
    594. 

  594. 	foreach my $xf (glob('src/backend/access/rmgrdesc/*desc.c') )
    595. 

  595. 	{
    596. 

  596. 		my $bf = basename $xf;
    597. 

  597. 		copy($xf,"contrib/pg_xlogdump/$bf");
    598. 

  598. 		$pg_xlogdump->AddFile("contrib\\pg_xlogdump\\$bf");
    599. 

  599. 	}
    600. 

  600. 	copy('src/backend/access/transam/xlogreader.c',
    601. 

  601. 		 'contrib/pg_xlogdump/xlogreader.c'); 
    602. 

  602. 

  603. 	$solution->Save();
    604. 

  604. 	return $solution->{vcver};
    605. 

  605. }
    606. 

  606. 

  607. #####################
    608. 

  608. # Utility functions #
    609. 

  609. #####################
    610. 

  610. 

  611. # Add a simple frontend project (exe)
    612. 

  612. sub AddSimpleFrontend
    613. 

  613. {
    614. 

  614. 	my $n        = shift;
    615. 

  615. 	my $uselibpq = shift;
    616. 

  616. 

  617. 	my $p = $solution->AddProject($n, 'exe', 'bin');
    618. 

  618. 	$p->AddDir('src\bin\\' . $n);
    619. 

  619. 	$p->AddReference($libpgport, $libpgcommon);
    620. 

  620. 	if ($uselibpq)
    621. 

  621. 	{
    622. 

  622. 		$p->AddIncludeDir('src\interfaces\libpq');
    623. 

  623. 		$p->AddReference($libpq);
    624. 

  624. 	}
    625. 

  625. 	return $p;
    626. 

  626. }
    627. 

  627. 

  628. # Add a simple contrib project
    629. 

  629. sub AddContrib
    630. 

  630. {
    631. 

  631. 	my $n  = shift;
    632. 

  632. 	my $mf = Project::read_file('contrib\\' . $n . '\Makefile');
    633. 

  633. 

  634. 	if ($mf =~ /^MODULE_big\s*=\s*(.*)$/mg)
    635. 

  635. 	{
    636. 

  636. 		my $dn = $1;
    637. 

  637. 		$mf =~ s{\\\s*[\r\n]+}{}mg;
    638. 

  638. 		my $proj = $solution->AddProject($dn, 'dll', 'contrib');
    639. 

  639. 		$mf =~ /^OBJS\s*=\s*(.*)$/gm
    640. 

  640. 		  || croak "Could not find objects in MODULE_big for $n\n";
    641. 

  641. 		my $objs = $1;
    642. 

  642. 		while ($objs =~ /\b([\w-]+\.o)\b/g)
    643. 

  643. 		{
    644. 

  644. 			my $o = $1;
    645. 

  645. 			$o =~ s/\.o$/.c/;
    646. 

  646. 			$proj->AddFile('contrib\\' . $n . '\\' . $o);
    647. 

  647. 		}
    648. 

  648. 		$proj->AddReference($postgres);
    649. 

  649. 		if ($mf =~ /^SUBDIRS\s*:?=\s*(.*)$/mg)
    650. 

  650. 		{
    651. 

  651. 			foreach my $d (split /\s+/, $1)
    652. 

  652. 			{
    653. 

  653. 				my $mf2 = Project::read_file(
    654. 

  654. 					'contrib\\' . $n . '\\' . $d . '\Makefile');
    655. 

  655. 				$mf2 =~ s{\\\s*[\r\n]+}{}mg;
    656. 

  656. 				$mf2 =~ /^SUBOBJS\s*=\s*(.*)$/gm
    657. 

  657. 				  || croak
    658. 

  658. 				  "Could not find objects in MODULE_big for $n, subdir $d\n";
    659. 

  659. 				$objs = $1;
    660. 

  660. 				while ($objs =~ /\b([\w-]+\.o)\b/g)
    661. 

  661. 				{
    662. 

  662. 					my $o = $1;
    663. 

  663. 					$o =~ s/\.o$/.c/;
    664. 

  664. 					$proj->AddFile('contrib\\' . $n . '\\' . $d . '\\' . $o);
    665. 

  665. 				}
    666. 

  666. 			}
    667. 

  667. 		}
    668. 

  668. 		AdjustContribProj($proj);
    669. 

  669. 	}
    670. 

  670. 	elsif ($mf =~ /^MODULES\s*=\s*(.*)$/mg)
    671. 

  671. 	{
    672. 

  672. 		foreach my $mod (split /\s+/, $1)
    673. 

  673. 		{
    674. 

  674. 			my $proj = $solution->AddProject($mod, 'dll', 'contrib');
    675. 

  675. 			$proj->AddFile('contrib\\' . $n . '\\' . $mod . '.c');
    676. 

  676. 			$proj->AddReference($postgres);
    677. 

  677. 			AdjustContribProj($proj);
    678. 

  678. 		}
    679. 

  679. 	}
    680. 

  680. 	elsif ($mf =~ /^PROGRAM\s*=\s*(.*)$/mg)
    681. 

  681. 	{
    682. 

  682. 		my $proj = $solution->AddProject($1, 'exe', 'contrib');
    683. 

  683. 		$mf =~ s{\\\s*[\r\n]+}{}mg;
    684. 

  684. 		$mf =~ /^OBJS\s*=\s*(.*)$/gm
    685. 

  685. 		  || croak "Could not find objects in PROGRAM for $n\n";
    686. 

  686. 		my $objs = $1;
    687. 

  687. 		while ($objs =~ /\b([\w-]+\.o)\b/g)
    688. 

  688. 		{
    689. 

  689. 			my $o = $1;
    690. 

  690. 			$o =~ s/\.o$/.c/;
    691. 

  691. 			$proj->AddFile('contrib\\' . $n . '\\' . $o);
    692. 

  692. 		}
    693. 

  693. 		AdjustContribProj($proj);
    694. 

  694. 	}
    695. 

  695. 	else
    696. 

  696. 	{
    697. 

  697. 		croak "Could not determine contrib module type for $n\n";
    698. 

  698. 	}
    699. 

  699. 

  700. 	# Are there any output data files to build?
    701. 

  701. 	GenerateContribSqlFiles($n, $mf);
    702. 

  702. }
    703. 

  703. 

  704. sub GenerateContribSqlFiles
    705. 

  705. {
    706. 

  706. 	my $n  = shift;
    707. 

  707. 	my $mf = shift;
    708. 

  708. 	if ($mf =~ /^DATA_built\s*=\s*(.*)$/mg)
    709. 

  709. 	{
    710. 

  710. 		my $l = $1;
    711. 

  711. 

  712. 		# Strip out $(addsuffix) rules
    713. 

  713. 		if (index($l, '$(addsuffix ') >= 0)
    714. 

  714. 		{
    715. 

  715. 			my $pcount = 0;
    716. 

  716. 			my $i;
    717. 

  717. 			for ($i = index($l, '$(addsuffix ') + 12; $i < length($l); $i++)
    718. 

  718. 			{
    719. 

  719. 				$pcount++ if (substr($l, $i, 1) eq '(');
    720. 

  720. 				$pcount-- if (substr($l, $i, 1) eq ')');
    721. 

  721. 				last      if ($pcount < 0);
    722. 

  722. 			}
    723. 

  723. 			$l =
    724. 

  724. 			  substr($l, 0, index($l, '$(addsuffix ')) . substr($l, $i + 1);
    725. 

  725. 		}
    726. 

  726. 

  727. 		foreach my $d (split /\s+/, $l)
    728. 

  728. 		{
    729. 

  729. 			my $in  = "$d.in";
    730. 

  730. 			my $out = "$d";
    731. 

  731. 

  732. 			if (Solution::IsNewer("contrib/$n/$out", "contrib/$n/$in"))
    733. 

  733. 			{
    734. 

  734. 				print "Building $out from $in (contrib/$n)...\n";
    735. 

  735. 				my $cont = Project::read_file("contrib/$n/$in");
    736. 

  736. 				my $dn   = $out;
    737. 

  737. 				$dn   =~ s/\.sql$//;
    738. 

  738. 				$cont =~ s/MODULE_PATHNAME/\$libdir\/$dn/g;
    739. 

  739. 				my $o;
    740. 

  740. 				open($o, ">contrib/$n/$out")
    741. 

  741. 				  || croak "Could not write to contrib/$n/$d";
    742. 

  742. 				print $o $cont;
    743. 

  743. 				close($o);
    744. 

  744. 			}
    745. 

  745. 		}
    746. 

  746. 	}
    747. 

  747. }
    748. 

  748. 

  749. sub AdjustContribProj
    750. 

  750. {
    751. 

  751. 	my $proj = shift;
    752. 

  752. 	my $n    = $proj->{name};
    753. 

  753. 

  754. 	if ($contrib_defines->{$n})
    755. 

  755. 	{
    756. 

  756. 		foreach my $d ($contrib_defines->{$n})
    757. 

  757. 		{
    758. 

  758. 			$proj->AddDefine($d);
    759. 

  759. 		}
    760. 

  760. 	}
    761. 

  761. 	if (grep { /^$n$/ } @contrib_uselibpq)
    762. 

  762. 	{
    763. 

  763. 		$proj->AddIncludeDir('src\interfaces\libpq');
    764. 

  764. 		$proj->AddReference($libpq);
    765. 

  765. 	}
    766. 

  766. 	if (grep { /^$n$/ } @contrib_uselibpgport)
    767. 

  767. 	{
    768. 

  768. 		$proj->AddReference($libpgport);
    769. 

  769. 	}
    770. 

  770. 	if (grep { /^$n$/ } @contrib_uselibpgcommon)
    771. 

  771. 	{
    772. 

  772. 		$proj->AddReference($libpgcommon);
    773. 

  773. 	}
    774. 

  774. 	if ($contrib_extralibs->{$n})
    775. 

  775. 	{
    776. 

  776. 		foreach my $l (@{ $contrib_extralibs->{$n} })
    777. 

  777. 		{
    778. 

  778. 			$proj->AddLibrary($l);
    779. 

  779. 		}
    780. 

  780. 	}
    781. 

  781. 	if ($contrib_extraincludes->{$n})
    782. 

  782. 	{
    783. 

  783. 		foreach my $i (@{ $contrib_extraincludes->{$n} })
    784. 

  784. 		{
    785. 

  785. 			$proj->AddIncludeDir($i);
    786. 

  786. 		}
    787. 

  787. 	}
    788. 

  788. 	if ($contrib_extrasource->{$n})
    789. 

  789. 	{
    790. 

  790. 		$proj->AddFiles('contrib\\' . $n, @{ $contrib_extrasource->{$n} });
    791. 

  791. 	}
    792. 

  792. }
    793. 

  793. 

  794. 1;
    795. 

  795.