Xref: utzoo comp.lang.c:30868 comp.compilers:1099
Path: utzoo!utgpu!news-server.csri.toronto.edu!mailrus!uunet!samsung!usc!snorkelwacker!spdcc!esegue!compilers-sender
From: stiller@cmx.npac.syr.edu (Lewis Stiller)
Newsgroups: comp.lang.c,comp.compilers
Subject: How to augment C with new datatypes painlessly?
Keywords: C, question, OOP, design
Message-ID: <1990Aug07.152904.8535@esegue.segue.boston.ma.us>
Date: 7 Aug 90 15:29:04 GMT
Sender: compilers-sender@esegue.segue.boston.ma.us
Reply-To: stiller@cmx.npac.syr.edu (Lewis Stiller)
Organization: Northeast Parallel Architectures Center, Syracuse NY
Lines: 48
Approved: compilers@esegue.segue.boston.ma.us

I would like to augment C to handle certain machine dependent types.

Ideally, a preprocessor should look at the source code, and emit the same
source, except that whenever certain arithmetic operations and declarations
are performed on a variable in one of these new types, the appropriate
standard C function calls are emitted. The only trickiness comes in handling
complicated type declarations, and I don't want to recode the wheel here.

I don't need a whole C compiler, just an interface to C that will cleanly
handle the new types: GNU C or whatever can handle the new functions. But
for debugging and optimization (by hand) the preprocessor must output stuff
similar to the C source.

For example, suppose I have special hardware to handle superlong ints, of
say > 1024 bits. I would want to code in standard C, except declare some
variables to be of type

	superlong x,y,z; /* x,y,z are superlong ints in the special
			    hardware*/

or even have some syntax for variable-width superlong ints.  Then, when the
compiler sees code like:

	printf("unchanged\n"); /* stuff unchanged*/
	superlong x,y,z;
	if (x==y) z=x+y;

it should output code like:
	printf("unchanged\n"); /* stuff unchanged*/
	_special_hardware_allocate(x,LONG);
	_special_hardware_allocate(y,LONG);	
	_special_hardware_allocate(z,LONG);
	if (_special_hardware_equal_longs (x,y)) 
		_special_hardware_plus_longs_3(z,x,y);
	....

It must handle superlongs that are members of complicated struct/typedef
constructions correctly.

Anyway, I imagine this problem comes up a lot, and wonder if there are any
Unix sources for handling it. A well-written and easy to modify parser for C
should do the trick.

lewis
[This sounds to me exactly like operator overloading in C++. -John]
-- 
Send compilers articles to compilers@esegue.segue.boston.ma.us
{spdcc | ima | lotus| world}!esegue.  Meta-mail to compilers-request@esegue.