Path: utzoo!attcan!uunet!cs.utexas.edu!milano!cadillac!vaughan@mcc.com
From: vaughan@mcc.com (Paul Vaughan)
Newsgroups: comp.lang.c++
Subject: Re: Which C++ compiler?
Message-ID: <12878@cadillac.CAD.MCC.COM>
Date: 5 Nov 90 23:53:04 GMT
References: <1990Nov2.164530.1862@murdoch.acc.Virginia.EDU> <55427@brunix.UUCP>
Sender: news@cadillac.CAD.MCC.COM
Reply-To: vaughan@mcc.com (Paul Vaughan)
Organization: MCC VLSI CAD Program
Lines: 62
In-reply-to: sdm@cs.brown.edu (Scott Meyers)


   From: sdm@cs.brown.edu (Scott Meyers)
   Newsgroups: comp.lang.c++
   Date: 5 Nov 90 19:02:45 GMT
   References: <1990Nov2.164530.1862@murdoch.acc.Virginia.EDU>
   Reply-To: sdm@cs.brown.edu (Scott Meyers)
   Organization: Brown University Department of Computer Science
   Lines: 31

   In article <1990Nov2.164530.1862@murdoch.acc.Virginia.EDU> ecl2v@Virginia.EDU (Edmond C. Loyot) writes:
   >We are trying to decide which C++ compiler to purchase.  Our hardware
   >
   >	1) Does the product include a debugger (that doesn't use mangled
   >	   names)?

   Demangling names is just the tip of the iceberg.  When you look at a C++
   debugger, ask your vender these questions:

       - Can the debugger print the dynamic types of pointers and references?
       - Can it set breakpoints and/or step through:
	   - inline functions?
	   - virtual functions, including pure virtual functions?
	   - member initialization lists?
       - Can it display all the members of an object, including those that are
	 inherited?  
       - Can it display members of an object when those members are inherited
	 from a virtual base class?

No kidding. I'd add a lot of things that should be part of a complete
interpreter for interactive expressions.  The standard C subset
interpreter approach just doesn't cut it these days with C++.

	- call virtual functions on demand (inherited from virtual
							base classes?)
	- call inline functions on demand
	- deal with classes compiled without -g, including
		- call functions with arguments that are pointers to
		such classes
		- display objects inherited from them
	
	- set breakpoints on constructors and destructors
	- deal well with const member functions
	- call overloaded functions correctly
	- handle temporary objects when evaluating
		expressions interactively
	- handle type conversions in interactive expressions including
		using user defined type conversions
	
	
I've been working with g++ and gdb on a system that has the ability to
dynamically compile and load stuff and I find I sometimes have to
resort to using that capability instead of gdb just to evaluate a
simple expression. gdb does handle demangling names just fine, though.

And don't forget, the compiler/debugger combination has got to do all
this fast without bloating your code with debugging information by
more than 5 times.



 Paul Vaughan, MCC CAD Program | ARPA: vaughan@mcc.com | Phone: [512] 338-3639
 Box 200195, Austin, TX 78720  | UUCP: ...!cs.utexas.edu!milano!cadillac!vaughan