Navigation

← Previous Changeset
Next Changeset →

Changeset 18593

Timestamp:

04/12/06 11:17:47 (3 years ago)

Author:

patrick

Message:

Bug fixed: The *-config scripts did not handle the case of returning

32-bit (i.e., IA32) compiler and linker arguments on the
x86_64 architecture.

SF Bug#: 1347662

Files:

juggler/trunk/modules/gadgeteer/configure.in (modified) (2 diffs)
juggler/trunk/modules/gadgeteer/gadgeteer-config.in (modified) (7 diffs)
juggler/trunk/modules/jackal/configure.in (modified) (2 diffs)
juggler/trunk/modules/jackal/jccl-config.in (modified) (8 diffs)
juggler/trunk/modules/sonix/configure.in (modified) (2 diffs)
juggler/trunk/modules/sonix/sonix-config.in (modified) (7 diffs)
juggler/trunk/modules/tweek/configure.in (modified) (2 diffs)
juggler/trunk/modules/tweek/tweek-config.in (modified) (7 diffs)
juggler/trunk/modules/vapor/configure.in (modified) (2 diffs)
juggler/trunk/modules/vapor/vpr-config.in (modified) (6 diffs)
juggler/trunk/modules/vrjuggler/configure.in (modified) (2 diffs)
juggler/trunk/modules/vrjuggler/vrjuggler-config.in (modified) (7 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

juggler/trunk/modules/gadgeteer/configure.in

r18416	r18593
367	367
368	368	if test "x$PLATFORM" = "xIRIX" -a "x$USE_GCC" != "xyes" ; then
369		gadget_n32_flags='-n32'
370		gadget_64_flags='-64'
	369	gadget32_flags='-n32'
	370	gadget64_flags='-64'
	371	elif test "x$GCC" = "xyes" ; then
	372	gadget32_flags='-m32'
	373	gadget64_flags='-m64'
371	374	fi
372	375
…	…
409	412	AC_SUBST(gadget_extra_ldflags_linker)
410	413	AC_SUBST(gadget_extra_libs)
411		AC_SUBST(gadget_n32_flags)
412		AC_SUBST(gadget_64_flags)
	414	AC_SUBST(gadget32_flags)
	415	AC_SUBST(gadget64_flags)
413	416	AC_SUBST(gadget_use_x11)
414	417

juggler/trunk/modules/gadgeteer/gadgeteer-config.in

r18340	r18593
39	39	$ECHO_PREFIX);
40	40	use vars qw($exec_prefix $EXEC_PREFIX_SET $prefix $PREFIX_SET $LIBBITSUF
41		$GADGET_ABI_FLAGS $GADGET_ISA_FLAGS $Win32);
	41	$PLATFORM $GADGET_ABI_FLAGS $GADGET_ISA_FLAGS $Win32);
42	42
43	43	use File::Basename;
…	…
63	63	my $gadget_default_abi = qq(@ABI@);
64	64	my $gadget_default_isa = qq(@ISA@);
65		my $gadget_n32_flags = qq(@gadget_n32_flags@);
66		my $gadget_64_flags = qq(@gadget_64_flags@);
67		$LIBBITSUF = qq(@LIBBITSUF@);
	65	my $gadget32_flags = qq(@gadget32_flags@);
	66	my $gadget64_flags = qq(@gadget64_flags@);
	67	$LIBBITSUF = qq(@LIBBITSUF@);
	68	$PLATFORM = qq(@PLATFORM@);
68	69
69	70	my $use_gcc = '@USE_GCC@';
…	…
71	72	$GADGET_ABI_FLAGS = '';
72	73
73		if ( $gadget_default_abi =~ /n32/i )
74		{
75		$GADGET_ABI_FLAGS = "$gadget_n32_flags";
76		}
77		elsif ( $gadget_default_abi =~ /64/ )
78		{
79		$GADGET_ABI_FLAGS = "$gadget_64_flags";
	74	# The default ABI is IRIX N32 or the default ISA is i386.
	75	if ( $gadget_default_abi =~ /32$/i \|\| "$gadget_default_isa" eq 'i386' )
	76	{
	77	$GADGET_ABI_FLAGS = "$gadget32_flags";
	78	}
	79	# The default ABI or ISA is 64-bit.
	80	elsif ( "$gadget_default_abi" eq '64' \|\| "$gadget_default_isa" eq 'x86_64' )
	81	{
	82	$GADGET_ABI_FLAGS = "$gadget64_flags";
80	83	}
81	84
…	…
204	207	printing paths
205	208	[--version] Print the installed Gadgeteer's version number
206		[--cxxflags [~~N32\|64]]~~ Print the Gadgeteer-specific flags for the C++
	209	[--cxxflags [32\|64]] Print the Gadgeteer-specific flags for the C++
207	210	compiler
208	211	[--includes] Print out only the header path extension
209	212	arguments
210		[--libs [~~N32\|64]]~~ Print the basic Gadgeteer-specific libraries
211		[--extra-libs [~~N32\|64]]~~ Print the extra linker options needed for
	213	[--libs [32\|64]] Print the basic Gadgeteer-specific libraries
	214	[--extra-libs [32\|64]] Print the extra linker options needed for
212	215	making an executable
213	216	[--linker] Print libraries as direct arguments to the
…	…
290	293	my $gadget_extra_cxxflags = qq(@gadget_extra_cxxflags@);
291	294
292		if ( $cxxflags_arg =~ /~~n32~~/i )
293		{
294		$gadget_extra_cxxflags = "$gadget_extra_cxxflags $gadget_n32_flags $GADGET_ISA_FLAGS";
295		}
296		elsif ( ~~$cxxflags_arg =~ /64/~~ )
297		{
298		$gadget_extra_cxxflags = "$gadget_extra_cxxflags $gadget_64_flags $GADGET_ISA_FLAGS";
	295	if ( $cxxflags_arg =~ /32$/i )
	296	{
	297	$gadget_extra_cxxflags = "$gadget_extra_cxxflags $gadget32_flags $GADGET_ISA_FLAGS";
	298	}
	299	elsif ( "$cxxflags_arg" eq '64' )
	300	{
	301	$gadget_extra_cxxflags = "$gadget_extra_cxxflags $gadget64_flags $GADGET_ISA_FLAGS";
299	302	}
300	303	elsif ( "$cxxflags_arg" eq '' )
…	…
349	352	my $ldflags = '';
350	353
351		if ( $libs_arg =~ /~~n32~~/i )
352		{
353		$ldflags = "$gadget_n32_flags $GADGET_ISA_FLAGS";
354		$LIBBITSUF = ~~'32'~~;
355		}
356		elsif ( ~~$libs_arg =~ /64/~~ )
357		{
358		$ldflags = "$gadget_64_flags $GADGET_ISA_FLAGS";
	354	if ( $libs_arg =~ /32$/i )
	355	{
	356	$ldflags = "$gadget32_flags $GADGET_ISA_FLAGS";
	357	$LIBBITSUF = ("$PLATFORM" eq 'IRIX' ? '32' : '');
	358	}
	359	elsif ( "$libs_arg" eq '64' )
	360	{
	361	$ldflags = "$gadget64_flags $GADGET_ISA_FLAGS";
359	362	$LIBBITSUF = '64';
360	363	}
…	…
405	408	}
406	409
407		if ( $extra_libs_arg =~ /~~n32~~/i )
408		{
409		$LIBBITSUF = ~~'32'~~;
410		}
411		elsif ( ~~$extra_libs_arg =~ /64/~~ )
	410	if ( $extra_libs_arg =~ /32$/i )
	411	{
	412	$LIBBITSUF = ("$PLATFORM" eq 'IRIX' ? '32' : '');
	413	}
	414	elsif ( "$extra_libs_arg" eq '64' )
412	415	{
413	416	$LIBBITSUF = '64';

juggler/trunk/modules/jackal/configure.in

r18336	r18593
343	343
344	344	if test "x$PLATFORM" = "xIRIX" -a "x$USE_GCC" != "xyes" ; then
345		jccl_n32_flags='-n32'
346		jccl_64_flags='-64'
	345	jccl32_flags='-n32'
	346	jccl64_flags='-64'
	347	elif test "x$GCC" = "xyes" ; then
	348	jccl32_flags='-m32'
	349	jccl64_flags='-m64'
347	350	fi
348	351
…	…
409	412	AC_SUBST(jccl_extra_ldflags)
410	413	AC_SUBST(jccl_extra_libs)
411		AC_SUBST(jccl_n32_flags)
412		AC_SUBST(jccl_64_flags)
	414	AC_SUBST(jccl32_flags)
	415	AC_SUBST(jccl64_flags)
413	416	AC_SUBST(jccl_java_api_jars)
414	417

juggler/trunk/modules/jackal/jccl-config.in

r18336	r18593
39	39	$ECHO_PREFIX);
40	40	use vars qw($exec_prefix $EXEC_PREFIX_SET $prefix $PREFIX_SET $LIBBITSUF
41		$JCCL_ABI_FLAGS $JCCL_ISA_FLAGS $Win32);
	41	$PLATFORM $JCCL_ABI_FLAGS $JCCL_ISA_FLAGS $Win32);
42	42
43	43	use File::Basename;
…	…
56	56	sub groupLibdirArgs($);
57	57
58		~~# TODO: Do not use @prefix@ if possible. Make use of @LOCAL_BOOST@.~~
59
60	58	usage(1) if $#ARGV == -1;
61	59
…	…
64	62	my $jccl_default_abi = qq(@ABI@);
65	63	my $jccl_default_isa = qq(@ISA@);
66		my $jccl~~_n32_flags = qq(@jccl_n~~32_flags@);
67		my $jccl~~_64_flags = qq(@jccl_~~64_flags@);
	64	my $jccl32_flags = qq(@jccl32_flags@);
	65	my $jccl64_flags = qq(@jccl64_flags@);
68	66	$LIBBITSUF = qq(@LIBBITSUF@);
	67	$PLATFORM = qq(@PLATFORM@);
69	68
70	69	my $use_gcc = '@USE_GCC@';
…	…
72	71	$JCCL_ABI_FLAGS = '';
73	72
74		if ( $jccl_default_abi =~ /n32/i )
75		{
76		$JCCL_ABI_FLAGS = "$jccl_n32_flags";
77		}
78		elsif ( $jccl_default_abi =~ /64/ )
79		{
80		$JCCL_ABI_FLAGS = "$jccl_64_flags";
	73	# The default ABI is IRIX N32 or the default ISA is i386.
	74	if ( $jccl_default_abi =~ /32$/i \|\| "$jccl_default_isa" eq 'i386' )
	75	{
	76	$JCCL_ABI_FLAGS = "$jccl32_flags";
	77	}
	78	# The default ABI or ISA is 64-bit.
	79	elsif ( "$jccl_default_abi" eq '64' \|\| "$jccl_default_isa" eq 'x86_64' )
	80	{
	81	$JCCL_ABI_FLAGS = "$jccl64_flags";
81	82	}
82	83
…	…
221	222	printing paths
222	223	[--version] Print the installed JCCL's version number
223		[--cxxflags [~~N32\|64]]~~ Print the JCCL-specific flags for the C++
	224	[--cxxflags [32\|64]] Print the JCCL-specific flags for the C++
224	225	compiler
225	226	[--includes] Print out only the header path extension
226	227	arguments
227		[--libs [~~N32\|64]]~~ Print the basic JCCL-specific libraries
228		[--extra-libs [~~N32\|64]]~~ Print the extra linker options needed for
	228	[--libs [32\|64]] Print the basic JCCL-specific libraries
	229	[--extra-libs [32\|64]] Print the extra linker options needed for
229	230	making an executable
230	231	[--linker] Print libraries as direct arguments to the
…	…
305	306	my $jccl_extra_cxxflags = qq(@jccl_extra_cxxflags@);
306	307
307		if ( $cxxflags_arg =~ /~~n32~~/i )
308		{
309		$jccl_extra_cxxflags = "$jccl_extra_cxxflags $jccl_n32_flags $JCCL_ISA_FLAGS";
310		}
311		elsif ( ~~$cxxflags_arg =~ /64/~~ )
312		{
313		$jccl_extra_cxxflags = "$jccl_extra_cxxflags $jccl_64_flags $JCCL_ISA_FLAGS";
	308	if ( $cxxflags_arg =~ /32$/i )
	309	{
	310	$jccl_extra_cxxflags = "$jccl_extra_cxxflags $jccl32_flags $JCCL_ISA_FLAGS";
	311	}
	312	elsif ( "$cxxflags_arg" eq '64' )
	313	{
	314	$jccl_extra_cxxflags = "$jccl_extra_cxxflags $jccl64_flags $JCCL_ISA_FLAGS";
314	315	}
315	316	elsif ( "$cxxflags_arg" eq '' )
…	…
352	353	my $ldflags = '';
353	354
354		if ( $libs_arg =~ /~~n32~~/i )
355		{
356		$ldflags = "$jccl_n32_flags $JCCL_ISA_FLAGS";
357		$LIBBITSUF = ~~'32'~~;
358		}
359		elsif ( ~~$libs_arg =~ /64/~~ )
360		{
361		$ldflags = "$jccl_64_flags $JCCL_ISA_FLAGS";
	355	if ( $libs_arg =~ /32$/i )
	356	{
	357	$ldflags = "$jccl32_flags $JCCL_ISA_FLAGS";
	358	$LIBBITSUF = ("$PLATFORM" eq 'IRIX' ? '32' : '');
	359	}
	360	elsif ( "$libs_arg" eq '64' )
	361	{
	362	$ldflags = "$jccl64_flags $JCCL_ISA_FLAGS";
362	363	$LIBBITSUF = '64';
363	364	}
…	…
407	408	}
408	409
409		if ( $extra_libs_arg =~ /~~n32~~/i )
410		{
411		$LIBBITSUF = ~~'32'~~;
412		}
413		elsif ( ~~$extra_libs_arg =~ /64/~~ )
	410	if ( $extra_libs_arg =~ /32$/i )
	411	{
	412	$LIBBITSUF = ("$PLATFORM" eq 'IRIX' ? '32' : '');
	413	}
	414	elsif ( "$extra_libs_arg" eq '64' )
414	415	{
415	416	$LIBBITSUF = '64';

juggler/trunk/modules/sonix/configure.in

r18338	r18593
292	292
293	293	if test "x$PLATFORM" = "xIRIX" -a "x$USE_GCC" != "xyes" ; then
294		snx_n32_flags='-n32'
295		snx_64_flags='-64'
	294	snx32_flags='-n32'
	295	snx64_flags='-64'
	296	elif test "x$GCC" = "xyes" ; then
	297	snx32_flags='-m32'
	298	snx64_flags='-m64'
296	299	fi
297	300
…	…
332	335	AC_SUBST(snx_extra_ldflags_linker)
333	336	AC_SUBST(snx_extra_libs)
334		AC_SUBST(snx_n32_flags)
335		AC_SUBST(snx_64_flags)
	337	AC_SUBST(snx32_flags)
	338	AC_SUBST(snx64_flags)
336	339
337	340	# -----------------------------------------------------------------------------

juggler/trunk/modules/sonix/sonix-config.in

r18338	r18593
48	48	$ECHO_PREFIX);
49	49	use vars qw($exec_prefix $EXEC_PREFIX_SET $prefix $PREFIX_SET $LIBBITSUF
50		$SNX_ABI_FLAGS $SNX_ISA_FLAGS $Win32);
	50	$PLATFORM $SNX_ABI_FLAGS $SNX_ISA_FLAGS $Win32);
51	51
52	52	use File::Basename;
…	…
71	71	my $snx_default_abi = qq(@ABI@);
72	72	my $snx_default_isa = qq(@ISA@);
73		my $snx~~_n32_flags = qq(@snx_n~~32_flags@);
74		my $snx~~_64_flags = qq(@snx_~~64_flags@);
	73	my $snx32_flags = qq(@snx32_flags@);
	74	my $snx64_flags = qq(@snx64_flags@);
75	75	$LIBBITSUF = qq(@LIBBITSUF@);
	76	$PLATFORM = qq(@PLATFORM@);
76	77
77	78	my $use_gcc = '@USE_GCC@';
…	…
79	80	$SNX_ABI_FLAGS = '';
80	81
81		if ( $snx_default_abi =~ /n32/i )
82		{
83		$SNX_ABI_FLAGS = "$snx_n32_flags";
84		}
85		elsif ( $snx_default_abi =~ /64/ )
86		{
87		$SNX_ABI_FLAGS = "$snx_64_flags";
	82	# The default ABI is IRIX N32 or the default ISA is i386.
	83	if ( $snx_default_abi =~ /32$/i \|\| "$snx_default_isa" eq 'i386' )
	84	{
	85	$SNX_ABI_FLAGS = "$snx32_flags";
	86	}
	87	# The default ABI or ISA is 64-bit.
	88	elsif ( "$snx_default_abi" eq '64' \|\| "$snx_default_isa" eq 'x86_64' )
	89	{
	90	$SNX_ABI_FLAGS = "$snx64_flags";
88	91	}
89	92
…	…
207	210	printing paths
208	211	[--version] Print the installed Sonix' version number
209		[--cxxflags [~~N32\|64]]~~ Print the Sonix-specific flags for the C++
	212	[--cxxflags [32\|64]] Print the Sonix-specific flags for the C++
210	213	compiler
211	214	[--includes] Print out only the header path extension
212	215	arguments
213		[--libs [~~N32\|64]]~~ Print the basic Sonix-specific libraries
214		[--extra-libs [~~N32\|64]]~~ Print the extra linker options needed for
	216	[--libs [32\|64]] Print the basic Sonix-specific libraries
	217	[--extra-libs [32\|64]] Print the extra linker options needed for
215	218	making an executable
216	219	[--linker] Print libraries as direct arguments to the
…	…
291	294	my $snx_extra_cxxflags = qq(@snx_extra_cxxflags@);
292	295
293		if ( $cxxflags_arg =~ /~~n32~~/i )
294		{
295		$snx_extra_cxxflags = "$snx_extra_cxxflags $snx_n32_flags $SNX_ISA_FLAGS";
296		}
297		elsif ( ~~$cxxflags_arg =~ /64/~~ )
298		{
299		$snx_extra_cxxflags = "$snx_extra_cxxflags $snx_64_flags $SNX_ISA_FLAGS";
	296	if ( $cxxflags_arg =~ /32$/i )
	297	{
	298	$snx_extra_cxxflags = "$snx_extra_cxxflags $snx32_flags $SNX_ISA_FLAGS";
	299	}
	300	elsif ( "$cxxflags_arg" eq '64' )
	301	{
	302	$snx_extra_cxxflags = "$snx_extra_cxxflags $snx64_flags $SNX_ISA_FLAGS";
300	303	}
301	304	elsif ( "$cxxflags_arg" eq '' )
…	…
350	353	my $ldflags = '';
351	354
352		if ( $libs_arg =~ /~~n32~~/i )
353		{
354		$ldflags = "$snx_n32_flags $SNX_ISA_FLAGS";
355		$LIBBITSUF = ~~'32'~~;
356		}
357		elsif ( ~~$libs_arg =~ /64/~~ )
358		{
359		$ldflags = "$snx_64_flags $SNX_ISA_FLAGS";
	355	if ( $libs_arg =~ /32$/i )
	356	{
	357	$ldflags = "$snx32_flags $SNX_ISA_FLAGS";
	358	$LIBBITSUF = ("$PLATFORM" eq 'IRIX' ? '32' : '');
	359	}
	360	elsif ( "$libs_arg" eq '64' )
	361	{
	362	$ldflags = "$snx64_flags $SNX_ISA_FLAGS";
360	363	$LIBBITSUF = '64';
361	364	}
…	…
406	409	}
407	410
408		if ( $extra_libs_arg =~ /~~n32~~/i )
409		{
410		$LIBBITSUF = ~~'32'~~;
411		}
412		elsif ( ~~$extra_libs_arg =~ /64/~~ )
	411	if ( $extra_libs_arg =~ /32$/i )
	412	{
	413	$LIBBITSUF = ("$PLATFORM" eq 'IRIX' ? '32' : '');
	414	}
	415	elsif ( "$extra_libs_arg" eq '64' )
413	416	{
414	417	$LIBBITSUF = '64';

juggler/trunk/modules/tweek/configure.in

r18415	r18593
1274	1274
1275	1275	if test "x$PLATFORM" = "xIRIX" -a "x$USE_GCC" != "xyes" ; then
1276		tweek_n32_flags='-n32'
1277		tweek_64_flags='-64'
	1276	tweek32_flags='-n32'
	1277	tweek64_flags='-64'
	1278	elif test "x$GCC" = "xyes" ; then
	1279	tweek32_flags='-m32'
	1280	tweek64_flags='-m64'
1278	1281	fi
1279	1282
…	…
1380	1383	AC_SUBST(tweek_extra_ldflags)
1381	1384	AC_SUBST(tweek_extra_libs)
1382		AC_SUBST(tweek_n32_flags)
1383		AC_SUBST(tweek_64_flags)
	1385	AC_SUBST(tweek32_flags)
	1386	AC_SUBST(tweek64_flags)
1384	1387	AC_SUBST(tweek_idlflags_cxx)
1385	1388	AC_SUBST(tweek_idl_incflag_cxx)

juggler/trunk/modules/tweek/tweek-config.in

r18333	r18593
43	43	$ECHO_PREFIX);
44	44	use vars qw($exec_prefix $EXEC_PREFIX_SET $prefix $PREFIX_SET $LIBBITSUF
45		$TWEEK_ABI_FLAGS $TWEEK_ISA_FLAGS $Win32);
	45	$PLATFORM $TWEEK_ABI_FLAGS $TWEEK_ISA_FLAGS $Win32);
46	46
47	47	use File::Basename;
…	…
66	66	my $tweek_default_abi = qq(@ABI@);
67	67	my $tweek_default_isa = qq(@ISA@);
68		my $tweek~~_n32_flags = qq(@tweek_n~~32_flags@);
69		my $tweek~~_64_flags = qq(@tweek_~~64_flags@);
	68	my $tweek32_flags = qq(@tweek32_flags@);
	69	my $tweek64_flags = qq(@tweek64_flags@);
70	70	$LIBBITSUF = qq(@LIBBITSUF@);
	71	$PLATFORM = qq(@PLATFORM@);
71	72
72	73	my $use_gcc = qq(@USE_GCC@);
…	…
74	75	$TWEEK_ABI_FLAGS = '';
75	76
76		if ( $tweek_default_abi =~ /n32/i )
77		{
78		$TWEEK_ABI_FLAGS = "$tweek_n32_flags";
79		}
80		elsif ( $tweek_default_abi =~ /64/ )
81		{
82		$TWEEK_ABI_FLAGS = "$tweek_64_flags";
	77	# The default ABI is IRIX N32 or the default ISA is i386.
	78	if ( $tweek_default_abi =~ /32$/i \|\| "$tweek_default_isa" eq 'i386' )
	79	{
	80	$TWEEK_ABI_FLAGS = "$tweek32_flags";
	81	}
	82	# The default ABI or ISA is 64-bit.
	83	elsif ( "$tweek_default_abi" eq '64' \|\| "$tweek_default_isa" eq 'x86_64' )
	84	{
	85	$TWEEK_ABI_FLAGS = "$tweek64_flags";
83	86	}
84	87
…	…
315	318	printing paths
316	319	[--version] Print the installed Tweek's version number
317		[--cxxflags [~~N32\|64]]~~ Print the Tweek-specific flags for the C++
	320	[--cxxflags [32\|64]] Print the Tweek-specific flags for the C++
318	321	compiler
319	322	[--includes] Print out only the header path extension
320	323	arguments
321		[--libs [~~N32\|64]]~~ Print the basic Tweek-specific libraries
322		[--extra-libs [~~N32\|64]]~~ Print the extra linker options needed for
	324	[--libs [32\|64]] Print the basic Tweek-specific libraries
	325	[--extra-libs [32\|64]] Print the extra linker options needed for
323	326	making an executable
324	327	[--linker] Print libraries as direct arguments to the
…	…
422	425	my $tweek_extra_cxxflags = qq(@tweek_extra_cxxflags@);
423	426
424		if ( $cxxflags_arg =~ /~~n32~~/i )
425		{
426		$tweek_extra_cxxflags = "$tweek_extra_cxxflags $tweek_n32_flags $TWEEK_ISA_FLAGS";
427		}
428		elsif ( ~~$cxxflags_arg =~ /64/~~ )
429		{
430		$tweek_extra_cxxflags = "$tweek_extra_cxxflags $tweek_64_flags $TWEEK_ISA_FLAGS";
	427	if ( $cxxflags_arg =~ /32$/i )
	428	{
	429	$tweek_extra_cxxflags = "$tweek_extra_cxxflags $tweek32_flags $TWEEK_ISA_FLAGS";
	430	}
	431	elsif ( "$cxxflags_arg" eq '64' )
	432	{
	433	$tweek_extra_cxxflags = "$tweek_extra_cxxflags $tweek64_flags $TWEEK_ISA_FLAGS";
431	434	}
432	435	elsif ( "$cxxflags_arg" eq '' )
…	…
481	484	my $ldflags = '';
482	485
483		if ( $libs_arg =~ /~~n32~~/i )
484		{
485		$ldflags = "$tweek_n32_flags $TWEEK_ISA_FLAGS";
486		$LIBBITSUF = ~~'32'~~;
487		}
488		elsif ( ~~$libs_arg =~ /64/~~ )
489		{
490		$ldflags = "$tweek_64_flags $TWEEK_ISA_FLAGS";
	486	if ( $libs_arg =~ /32$/i )
	487	{
	488	$ldflags = "$tweek32_flags $TWEEK_ISA_FLAGS";
	489	$LIBBITSUF = ("$PLATFORM" eq 'IRIX' ? '32' : '');
	490	}
	491	elsif ( "$libs_arg" eq '64' )
	492	{
	493	$ldflags = "$tweek64_flags $TWEEK_ISA_FLAGS";
491	494	$LIBBITSUF = '64';
492	495	}
…	…
537	540	}
538	541
539		if ( $extra_libs_arg =~ /~~n32~~/i )
540		{
541		$LIBBITSUF = ~~'32'~~;
542		}
543		elsif ( ~~$extra_libs_arg =~ /64/~~ )
	542	if ( $extra_libs_arg =~ /32$/i )
	543	{
	544	$LIBBITSUF = ("$PLATFORM" eq 'IRIX' ? '32' : '');
	545	}
	546	elsif ( "$extra_libs_arg" eq '64' )
544	547	{
545	548	$LIBBITSUF = '64';

juggler/trunk/modules/vapor/configure.in

r18334	r18593
1000	1000
1001	1001	if test "x$PLATFORM" = "xIRIX" -a "x$USE_GCC" != "xyes" ; then
1002		vpr_n32_flags='-n32'
1003		vpr_64_flags='-64'
	1002	vpr32_flags='-n32'
	1003	vpr64_flags='-64'
1004	1004	vpr_extra_include_dirs='boost/compatibility/cpp_c_headers'
	1005	elif test "x$GCC" = "xyes" ; then
	1006	vpr32_flags='-m32'
	1007	vpr64_flags='-m64'
1005	1008	fi
1006	1009
…	…
1055	1058	AC_SUBST(vpr_extra_ldflags_linker)
1056	1059	AC_SUBST(vpr_extra_libs)
1057		AC_SUBST(vpr_n32_flags)
1058		AC_SUBST(vpr_64_flags)
	1060	AC_SUBST(vpr32_flags)
	1061	AC_SUBST(vpr64_flags)
1059	1062
1060	1063	# -----------------------------------------------------------------------------

juggler/trunk/modules/vapor/vpr-config.in

r18331	r18593
67	67	my $vpr_default_abi = qq(@ABI@);
68	68	my $vpr_default_isa = qq(@ISA@);
69		my $vpr~~_n32_flags = qq(@vpr_n~~32_flags@);
70		my $vpr~~_64_flags = qq(@vpr_~~64_flags@);
	69	my $vpr32_flags = qq(@vpr32_flags@);
	70	my $vpr64_flags = qq(@vpr64_flags@);
71	71	$LIBBITSUF = qq(@LIBBITSUF@);
72	72	$PLATFORM = qq(@PLATFORM@);
…	…
76	76	$VPR_ABI_FLAGS = '';
77	77
78		if ( $vpr_default_abi =~ /n32/i )
79		{
80		$VPR_ABI_FLAGS = "$vpr_n32_flags";
81		}
82		elsif ( $vpr_default_abi =~ /64/ )
83		{
84		$VPR_ABI_FLAGS = "$vpr_64_flags";
	78	# The default ABI is IRIX N32 or the default ISA is i386.
	79	if ( $vpr_default_abi =~ /32$/i \|\| "$vpr_default_isa" eq 'i386' )
	80	{
	81	$VPR_ABI_FLAGS = "$vpr32_flags";
	82	}
	83	# The default ABI or ISA is 64-bit.
	84	elsif ( "$vpr_default_abi" eq '64' \|\| "$vpr_default_isa" eq 'x86_64' )
	85	{
	86	$VPR_ABI_FLAGS = "$vpr64_flags";
85	87	}
86	88
…	…
205	207	printing paths
206	208	[--version] Print the installed VPR's version number
207		[--cxxflags [~~N32\|64]]~~ Print the VPR-specific flags for the C++
	209	[--cxxflags [32\|64]] Print the VPR-specific flags for the C++
208	210	compiler
209	211	[--includes] Print out only the header path extension
210	212	arguments
211		[--libs [~~N32\|64]]~~ Print the basic VPR-specific libraries
212		[--extra-libs [~~N32\|64]]~~ Print the extra linker options needed for
	213	[--libs [32\|64]] Print the basic VPR-specific libraries
	214	[--extra-libs [32\|64]] Print the extra linker options needed for
213	215	making an executable
214	216	[--linker] Print libraries as direct arguments to the
…	…
248	250	my $vpr_extra_cxxflags = qq(@vpr_extra_cxxflags@);
249	251
250		if ( $cxxflags_arg =~ /~~n32~~/i )
251		{
252		$vpr_extra_cxxflags = "$vpr_extra_cxxflags $vpr_n32_flags $VPR_ISA_FLAGS";
253		}
254		elsif ( ~~$cxxflags_arg =~ /64/~~ )
255		{
256		$vpr_extra_cxxflags = "$vpr_extra_cxxflags $vpr_64_flags $VPR_ISA_FLAGS";
	252	if ( $cxxflags_arg =~ /32$/i )
	253	{
	254	$vpr_extra_cxxflags = "$vpr_extra_cxxflags $vpr32_flags $VPR_ISA_FLAGS";
	255	}
	256	elsif ( "$cxxflags_arg" eq '64' )
	257	{
	258	$vpr_extra_cxxflags = "$vpr_extra_cxxflags $vpr64_flags $VPR_ISA_FLAGS";
257	259	}
258	260	elsif ( "$cxxflags_arg" eq '' )
…	…
306	308	my $ldflags = '';
307	309
308		if ( $libs_arg =~ /~~n32~~/i )
309		{
310		$ldflags = "$vpr_n32_flags $VPR_ISA_FLAGS";
311		$LIBBITSUF = ~~'32'~~;
312		}
313		elsif ( ~~$libs_arg =~ /64/~~ )
314		{
315		$ldflags = "$vpr_64_flags $VPR_ISA_FLAGS";
	310	if ( $libs_arg =~ /32$/i )
	311	{
	312	$ldflags = "$vpr32_flags $VPR_ISA_FLAGS";
	313	$LIBBITSUF = ("$PLATFORM" eq 'IRIX' ? '32' : '');
	314	}
	315	elsif ( "$libs_arg" eq '64' )
	316	{
	317	$ldflags = "$vpr64_flags $VPR_ISA_FLAGS";
316	318	$LIBBITSUF = '64';
317	319	}
…	…
336	338	my $use_linker = shift \|\| 0;
337	339
338		if ( $extra_libs_arg =~ /~~n32~~/i )
339		{
340		$LIBBITSUF = ~~'32'~~;
341		}
342		elsif ( ~~$extra_libs_arg =~ /64/~~ )
	340	if ( $extra_libs_arg =~ /32$/i )
	341	{
	342	$LIBBITSUF = ("$PLATFORM" eq 'IRIX' ? '32' : '');
	343	}
	344	elsif ( "$extra_libs_arg" eq '64' )
343	345	{
344	346	$LIBBITSUF = '64';

juggler/trunk/modules/vrjuggler/configure.in

r18343	r18593
551	551
552	552	if test "x$PLATFORM" = "xIRIX" -a "x$USE_GCC" != "xyes" ; then
553		vrj_n32_flags='-n32'
554		vrj_64_flags='-64'
	553	vrj32_flags='-n32'
	554	vrj64_flags='-64'
	555	elif test "x$GCC" = "xyes" ; then
	556	vrj32_flags='-m32'
	557	vrj64_flags='-m64'
555	558	fi
556	559
…	…
603	606	AC_SUBST(vrj_extra_ldflags_linker)
604	607	AC_SUBST(vrj_extra_libs)
605		AC_SUBST(vrj_n32_flags)
606		AC_SUBST(vrj_64_flags)
	608	AC_SUBST(vrj32_flags)
	609	AC_SUBST(vrj64_flags)
607	610
608	611	AC_SUBST(vrj_lib)

juggler/trunk/modules/vrjuggler/vrjuggler-config.in

r18343	r18593
39	39	$ECHO_PREFIX);
40	40	use vars qw($exec_prefix $EXEC_PREFIX_SET $prefix $PREFIX_SET $LIBBITSUF
41		$VRJ_ABI_FLAGS $VRJ_ISA_FLAGS $Win32 %LIBS);
	41	$PLATFORM $VRJ_ABI_FLAGS $VRJ_ISA_FLAGS $Win32 %LIBS);
42	42
43	43	use File::Basename;
…	…
66	66	my $vrj_default_abi = qq(@ABI@);
67	67	my $vrj_default_isa = qq(@ISA@);
68		my $vrj~~_n32_flags = qq(@vrj_n~~32_flags@);
69		my $vrj~~_64_flags = qq(@vrj_~~64_flags@);
	68	my $vrj32_flags = qq(@vrj32_flags@);
	69	my $vrj64_flags = qq(@vrj64_flags@);
70	70	$LIBBITSUF = qq(@LIBBITSUF@);
	71	$PLATFORM = qq(@PLATFORM@);
71	72
72	73	my $use_gcc = '@USE_GCC@';
…	…
74	75	$VRJ_ABI_FLAGS = '';
75	76
76		if ( $vrj_default_abi =~ /n32/i )
77		{
78		$VRJ_ABI_FLAGS = "$vrj_n32_flags";
79		}
80		elsif ( $vrj_default_abi =~ /64/ )
81		{
82		$VRJ_ABI_FLAGS = "$vrj_64_flags";
	77	# The default ABI is IRIX N32 or the default ISA is i386.
	78	if ( $vrj_default_abi =~ /32$/i \|\| "$vrj_default_isa" eq 'i386' )
	79	{
	80	$VRJ_ABI_FLAGS = "$vrj32_flags";
	81	}
	82	# The default ABI or ISA is 64-bit.
	83	elsif ( "$vrj_default_abi" eq '64' \|\| "$vrj_default_isa" eq 'x86_64' )
	84	{
	85	$VRJ_ABI_FLAGS = "$vrj64_flags";
83	86	}
84	87
…	…
230	233	printing paths
231	234	[--version] Print the installed VR Juggler's version number
232		[--cxxflags [~~N32\|64]]~~ Print the VR Juggler-specific flags for the C++
	235	[--cxxflags [32\|64]] Print the VR Juggler-specific flags for the C++
233	236	compiler
234	237	[--includes] Print out only the header path extension
235	238	arguments
236		[--libs [~~N32\|64]]~~ Print the basic VR Juggler-specific libraries
237		[--extra-libs [~~N32\|64]]~~ Print the extra linker options needed for
	239	[--libs [32\|64]] Print the basic VR Juggler-specific libraries
	240	[--extra-libs [32\|64]] Print the extra linker options needed for
238	241	making an executable
239	242	[--linker] Print libraries as direct arguments to the
…	…
315	318	my $vrj_extra_cxxflags = qq(@vrj_extra_cxxflags@);
316	319
317		if ( $cxxflags_arg =~ /~~n32~~/i )
318		{
319		$vrj_extra_cxxflags = "$vrj_extra_cxxflags $vrj_n32_flags $VRJ_ISA_FLAGS";
320		}
321		elsif ( ~~$cxxflags_arg =~ /64/~~ )
322		{
323		$vrj_extra_cxxflags = "$vrj_extra_cxxflags $vrj_64_flags $VRJ_ISA_FLAGS";
	320	if ( $cxxflags_arg =~ /32$/i )
	321	{
	322	$vrj_extra_cxxflags = "$vrj_extra_cxxflags $vrj32_flags $VRJ_ISA_FLAGS";
	323	}
	324	elsif ( "$cxxflags_arg" eq '64' )
	325	{
	326	$vrj_extra_cxxflags = "$vrj_extra_cxxflags $vrj64_flags $VRJ_ISA_FLAGS";
324	327	}
325	328	elsif ( "$cxxflags_arg" eq '' )
…	…
374	377	my $ldflags = '';
375	378
376		if ( $libs_arg =~ /~~n32~~/i )
377		{
378		$ldflags = "$vrj_n32_flags $VRJ_ISA_FLAGS";
379		$LIBBITSUF = ~~'32'~~;
380		}
381		elsif ( ~~$libs_arg =~ /64/~~ )
382		{
383		$ldflags = "$vrj_64_flags $VRJ_ISA_FLAGS";
	379	if ( $libs_arg =~ /32$/i )
	380	{
	381	$ldflags = "$vrj32_flags $VRJ_ISA_FLAGS";
	382	$LIBBITSUF = ("$PLATFORM" eq 'IRIX' ? '32' : '');
	383	}
	384	elsif ( "$libs_arg" eq '64' )
	385	{
	386	$ldflags = "$vrj64_flags $VRJ_ISA_FLAGS";
384	387	$LIBBITSUF = '64';
385	388	}
…	…
448	451	}
449	452
450		if ( $extra_libs_arg =~ /~~n32~~/i )
451		{
452		$LIBBITSUF = ~~'32'~~;
453		}
454		elsif ( ~~$extra_libs_arg =~ /64/~~ )
	453	if ( $extra_libs_arg =~ /32$/i )
	454	{
	455	$LIBBITSUF = ("$PLATFORM" eq 'IRIX' ? '32' : '');
	456	}
	457	elsif ( "$extra_libs_arg" eq '64' )
455	458	{
456	459	$LIBBITSUF = '64';

Download in other formats: