Path: utzoo!attcan!uunet!snorkelwacker!apple!hercules!fernwood!lia!steve
From: steve@lia (Stephen Williams)
Newsgroups: comp.lang.c++
Subject: Re: More cfront -> ANSI C compiler problems
Keywords: cfront ANSI
Message-ID: <1990Jul22.234908.2820@lia>
Date: 22 Jul 90 23:49:08 GMT
References: <511@pete.abccam.abcl.co.uk>
Reply-To: steve@lia.com (Stephen Williams)
Organization: Litton/Integrated Automation, Alameda, California
Lines: 136

In article <511@pete.abccam.abcl.co.uk> pete@abccam.abcl.co.uk (Peter Cockerell) writes:
>It's like this. When you have a static class member, eg
>
>class fred {
>	static int jim;
>	...
>};
>
>
>it gets ouput in the ..c file as
>
>int _fred_jim;
>
>ie an uninitialized extern variable.

I have encountered a similar problem while using cfront 2.0
on a SUN sparc.  My code involves a class that looks like
this:
	struct pair { short a, b; };

	class foo {
	    public:
		foo();

	    private:
		int x;
		static pair y[];
	};

The code for "y" looks like:

	struct mangled_pair y[];

which the "C" compiler rejects, claiming "unknown size."
In a sense this is true.  The code that is should generate
should look like:
	extern struct mangled_pair y[];

Whose fault is this?

A shar of the complete example follows.  Can anyone tell
me if this problem is universal?

--Steve Williams

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of shell archive."
# Contents:  Makefile foo.h foo.C bar.C
# Wrapped by steve@ararat on Sun Jul 22 16:44:47 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f Makefile -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"Makefile\"
else
echo shar: Extracting \"Makefile\" \(263 characters\)
sed "s/^X//" >Makefile <<'END_OF_Makefile'
X
X# --
X#  What is wrong with foo.h?  When foo.C is compiled, all is
X#  as it should be.  When bar.C is compiled, cc (not CC)
X#  reports an error.  What gives?
X#
Xbar: bar.o foo.o
X
Xfoo.o: foo.C foo.h
X	CC -c $(CFLAGS) foo.C
X
Xbar.o: bar.C foo.h
X	CC -c $(CFLAGS) bar.C
END_OF_Makefile
if test 263 -ne `wc -c <Makefile`; then
    echo shar: \"Makefile\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f foo.h -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"foo.h\"
else
echo shar: Extracting \"foo.h\" \(220 characters\)
sed "s/^X//" >foo.h <<'END_OF_foo.h'
X
Xstruct pair { short a, b; };
X
Xclass foo {
X
X    public:
X	foo();
X
X    private:
X	int x;
X
X		// This statement generates an error if the
X		// actual definition of foo::y's value is
X		// in another file.
X	static pair y[];
X};
END_OF_foo.h
if test 220 -ne `wc -c <foo.h`; then
    echo shar: \"foo.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f foo.C -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"foo.C\"
else
echo shar: Extracting \"foo.C\" \(61 characters\)
sed "s/^X//" >foo.C <<'END_OF_foo.C'
X
X# include "foo.h"
X
Xpair foo::y[] = { {1,1}, {2,2}, {3,3} };
END_OF_foo.C
if test 61 -ne `wc -c <foo.C`; then
    echo shar: \"foo.C\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f bar.C -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"bar.C\"
else
echo shar: Extracting \"bar.C\" \(19 characters\)
sed "s/^X//" >bar.C <<'END_OF_bar.C'
X
X# include "foo.h"
END_OF_bar.C
if test 19 -ne `wc -c <bar.C`; then
    echo shar: \"bar.C\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: End of shell archive.
exit 0