Subject: REVIEW: StormC 2.0 programming environment
From: [email-masked] (Jens Kristian Jensen)
Date: 3 Apr 1997 22:52:14 GMT
Newsgroups: comp.sys.amiga.reviews

PRODUCT NAME

	StormC 2.0

BRIEF DESCRIPTION

	Integrated developer environment (hereafter IDE) for AmigaDOS.
Includes C/C++ compiler, assembler, debugger, editor (two, actually),
linker, runtime-environment with resource tracking and a visual project
manager/maker that integrates all the other programs.

AUTHOR/COMPANY INFORMATION

	Name:		HAAGE & PARTNER Computer GmbH
	Address:	HAAGE & PARTNER Computer GmbH
			Mainzer Str. 10 A
			61191 Rosbach
			Germany
	Telephone:	+49 - 6007 - 93 00 50
	FAX:		+49 - 6007 - 75 43

	E-mail:		[email-masked]
	Web:	http://ourworld.compuserve.com/homepages/haage_partner/

LIST PRICE

	From the support home page:

	  StormC (full version): 398 US$ (598 DM)
	  StormC Update 1.x -> 2.0: 115 US$ (169 DM)
	  StormC Upgrade (from any commercial programming language): 265 US$ 
								     (398 DM)
	  StormC Starter: 169 US$ (248 DM)
	  StormC Starter Bundle (with StormWIZARD 1.0): 198 US$ (298 DM)

	I paid 1795 DKr for an upgrade from SAS/C.

DEMO VERSION

	Yes! Available on the support home page. The demo will only
compile 10kB of code and link 20kB, but otherwise it is fully
functional.  The demo does not come with AmigaOS includes (because
they're copyrighted), but you can get the full demo with includes from
Haage & Partner for 30 DM or 20 US$.

SPECIAL HARDWARE AND SOFTWARE REQUIREMENTS

	From the StormC 2.0 demo .guide file

	  - Amiga with MC68020 CPU and a hard disk
	  - Kickstart and Workbench 3.0 (v39)
	  - 6 MB RAM
	  - 10 MB hard disk space

	  With this computer system you can start programming with StormC,
	  but the project size is limited. Furthermore not all debugger
	  features can be used. For this you need at least a 68030 CPU
	  with MMU and more RAM.

	  A really good configuration for StormC is the following:
	  - Amiga with 68030 including MMU
	  - Kickstart and Workbench 3.1
	  - 18 MB RAM
	  - 60 MB hard disk space

	In my opinion this is overkill. I managed to get the demo of
version 1.1 running on an A500+ with OS 2.0 and a total of
3.5MB Ram, and I could even compile HelloWorld! I don't know
if they have changed the requirements for V2.0 but I guess
they have a reason for stating so high requirements
themselves.

COPY PROTECTION

	None, installs on HD.

MACHINE USED FOR TESTING

	A4000, 40Mb Fast RAM, 2 Mb chip Ram
	CyberStorm Mk. II 040/40MHz
	HD: Maxtor 7546 520MB
	    Seagate 520MB
	Kickstart 39.29, DOpus 5.5 as workbench replacement.
	Ariadne Ethernet card
	C= 1960 monitor.

INSTALLATION

	Installation procedure uses the standard Installer program.
	Installation went smoothly.

PROJECT MANAGING

	A central part of StormC is the toolbar and the project
windows. The toolbar consists of nine icons: Text(new/open/save),
Project(new/open/save), make, run and debug. When creating a new
project (or opening an existing), a project window opens.

	The project window contains the various files the project
consists of (source codes, link libraries, executables etc.). All
these files are ordered after filetype and you can fold a section of
equal filetypes.  The project windows also has a column for the size
of the files (both as sourcefiles and as compiled .o files if it
applies). It is also possible to include projects into projects to form
huge projects of smaller ones.

	If you have multiple project windows open, the build/run/debug
icons in the toolbar refers to the last active project window.  For
each project window, there's also an extensive setting section which
allows you to configure the behaviour of the compiler/linker, runtime-
environment and the like for each project.  If a file in the project
window is double clicked, the appropriate editor for the particular
filetype is brought up if appropriate.  You can of course also add
(multiple) files, delete files/sections of file types and move files
up and down in the hierarchy.

EDITOR(S)

	StormC comes with two editors: StormEd, a nice, little editor
not being complicated or requiring many resources and GoldEd 4 PRO, a
shareware editor with almost every feature you can think of (and some,
I bet, you haven't thought of!) GoldEd comes as full install archive
with a keyfile registered to Haage & Partner. If you like, you can
also send in the registration card and receive your personal GoldEd
keyfile.

	I used StormEd in the demo of version 1.1, but I have used
GoldEd all the time I have owned StormC 2.0 so I don't know if
anything has changed in StormEd since V1.1.

STORMED

	(From my knowledge with V1.1)

	StormEd is a brilliant little editor which hasn't got many
configuration options or features, but still does exactly what you
want (at least it does what I want). It features everything you can
expect from a small editor, plus:

	-Syntax highlighting (colored text)
	-Smart indentation (context sensitive indentation)
	-Can be used as source-level debugger display (and to set breakpoints)
	-References. Context sensitive help with programming functions.

GOLDED

	GoldEd is a standalone product far too complex to be covered
in this review. I will, however, point out a few
features/peculiarities of GoldEd.

	GoldEd does NOT work like regular Amiga editors like
CygnusEd/Edge and the likes in its standard configuration. It is,
however, possible to configure GoldEd so it matches what I like,
except for the following:

	-The block handling cannot be exactly like Cygnus ed (the way I
	 prefer)
	-Real TABs are not possible. GoldEd always expands TABs to spaces. This
	 cannot be configured until Dietmar Eilert (the author of GoldEd)
	 changes this, which he stubbornly seems to refuse (I cannot imagine
	 that I am the only user who prefers it this way!)

	That said, GoldEd is full of configuration possibilities, and
if you care to set up GoldEd yourself, you can have something that
closely matches the way you see a perfect editor. For instance you can
define what should happen when the user presses any key, or picks a
menu item (the menu is of course also fully configurable). If you can
live with the way the author seems to prefer an editor, you do not
have to configure anything as there are several modes available for
different filetypes (GoldEd is filetype sensitive) such as html,
C/C++, LaTeX, plain text (with spell checking), .h files, assembler,
e-mail and the like. GoldEd can do everything StormEd can (except for
real TABs).

	Furthermore it has:

	-Folding. Can fold functions/blocks of text.
	-Automatic Phrase Completion. Finishes/spell checks phrases based on
	 dictionary or context sensitive.
	-ToolBar. Nice icons for loading/compiling etc.
	-Quickfunc. Can scan/show list of functions in current source for easy
	 overview and for finding/jumping to particular code.
	-API. Smart add on programs such as automatic showing matching
	 brackets, showing return type/parameters for a function when
	 placing the cursor over it, etc.
	-Macros. Both AREXX macros and simple recording/playing of sequences.
	-Templates. Automatically knowing what you mean when typing switch(
	 for example.

	And a dozen of other features that you will like when you see
it.  GoldEd is integrated nicely with StormC. It is started from
StormC if you doubleclick a source file in a project window (and have
chosen to use GoldEd as editor) and it can even be used as
source-level debugger.

COMPILER

	When you have written your nice C/C++ program that the world
can't be without, you usually want to compile it. With StormC's IDE
this is done by pressing the make button (or the run or debug button
if that's what you want to do after compiling). The make button calls
first the C/C++ compiler and then the linker with the options for the
current project. During compiling/linking, a window showing possible
warnings/errors is present. If any errors occur, they become visible
in a list view and you can doubleclick on the error to get to the line
containing the error in the source. If the project was successfully
compiled/linked, gadgets appear to allow you to run or debug the
program.

	The compiler is a so called optimizing compiler, which (among
many other things) means that it can generate smaller/faster code by
using the processors registers instead of using the stack. The code
generated by StormC is REALLY nice and optimized (you can watch it by
telling the compiler to also generate assembler or by disassembling
the generated code). The compiler can generate code optimized for
68000-68060 and a version for PowerPC processors is also on its way
according to Haage & Partner.

LINKER

	I haven't tested the linker's abilities that extensively, but
so far it has linked anything (well, at least anything correct) that I
have thrown at it. The linker includes all the standard options such
as which startup code to link with and which memory to relocate
to. Furthermore it includes some options I have never seen before like
Optimizing (Fold common code, optimize for near code) and linking as
ROM code. I could imagine the latter could be comfortable if you were
generating absolute code for an embedded system or in fact any place
where absolute code is needed.

	It should be mentioned, that both the compiler and the linker
can be run like regular compilers from a shell if you for some reason
don't want to use the IDE.

ASSEMBLER

	If StormC stumbles upon any assembler sources while compiling
a project, it calls an external assembler. StormC uses the freeware
version of the assembler PhxAss, FreePhxAss. This free version does
not support includes, macros and some other things, but otherwise it
does its job.  As of version 4.32, PhxAss has become freeware so you
can fetch PhxAss yourself (from Aminet in dev/asm/PhxAss435.lha) and
use the full version, which supports just about everything.

RUNTIME-ENVIRONMENT

	When running a program from within the IDE, the program is
'embedded' to allow resource tracking and catching of exceptions. As
long as the program is running, there is a window called StormShell
present. From the StormShell window you can send signals to the
program (CTRL-C, D, E and F), pause, kill and change the priority of
the program. If you kill the program or it terminates itself, the
StormShell informs you about resources that haven't been freed
properly and it can free them for you if you wish. If the project has
been compiled with the debug option on, you can also enter the
debugger at any time while running the program.

DEBUGGER

	StormC features a modern source-level debugger. Source-level
means that when you debug a file, you can single-step trough each line
of the source. In StormC, the progress in the source is shown in the
editor while debugging. This means that when you start to debug, a bar
appears over the first line of the source. When you press the
"Singlestep" button, the line below the bar is executed and the bar is
moved to the next line. If the next line is in another source code
file, the source is loaded and displayed (if you chose to step into
the function and not just have it executed silently).

	Besides the current line bar, the editor also gets a list of
checkboxes at the left of the display - one checkbox for each
executable line.  These checkboxes are used to set breakpoints in the
source. Instead of having to single-step trough each line to get to a
certain source line, you can the add a breakpoint at the particular
line by pressing the "Go to next breakpoint" button. There is also a
"Go until function is left" button, which finishes the current
function. The debug buttons appears in the StormShell
window. Naturally you can also do the things you usually can from
within the runtime-environment such as send control codes to the
program, kill it, etc.

	All these functions are very common for debuggers today. What
really makes StormC shine above everything else I have seen on the
Amiga, is the Variable window. In this window, you can get a list of
current variables (the variables that are within the scope of the
current function) and global variables. For each variable you can see
its value and its location (also if it is currently in a CPU register)
but almost more important - you can see its type. Since the debugger
knows the type of each variable (of course it does. It is a friend of
the compiler which compiled the source) it can browse through the
structure hierarchy (and classes if you use the C++mode). An example:
You have a global variable called MyIntuiMsg, defined as "struct
IntuiMessage *MyIntuiMsg". When you debug the source, you can see the
variable in the list of global variables. It has the value 0x08751588
and is currently in register A1. "Hmm I wonder how the IntuiMessage
structure that MyIntuiMsg points at looks like" you think, doubleclick
at the variables name and voila! The variable window changes to show
you the IntuiMessage structure. You can see that it consists of, among
other things, a Message structure called ExecMessage. You want to
inspect what the Message structure looks like, so you doubleclick the
ExecMessage. A Message consists of a Node, a pointer to a MsgPort and
UWORD called Length. You are curious again so you click the Node to
see its contents. When you have seen enough, you can press the "Pop
inspection stack" button to get a level up in the hierarchy or get to
the root by selecting global/local variables. Get the picture?

	Apart from the StormShell and the Variable windows which
automatically pops up when debugging, you can also get a the following
windows:

	Modules -     Shows which .o files the executable consists of. You can
		      get an overview of functions for each module and see the
		      source.
	History -     Shows the history of the debugging session (Which lines
		      have been run in which source and so forth.)
	Breakpoints - A list of breakpoints in all sources. It is possible to
		      disable certain breakpoints and remove all breakpoints.
	Stack -	      See which parameters/functions are on the stack. You can
		      see source and variables for each and set breakpoints at
		      the end of functions.
	Hex editor -  Simple Hex memory viewer/editor.
	Debugger -    Shows the program as 68000 assembler. You can also have
		      other memory locations disassembled. It is also possible
		      to debug at at assembly level and set breakpoints for
	              each instruction.

PROFILER

	The last window (phew!) is a new function in version 2.0 - a
built in profiler. With a profiler you are able to see how much time
each function takes, how many times each function is called and so
on. This makes you tune your programs because you can see where it is
necessary to optimize. The profiler in StormC lets you see the
percent time a certain functions has taken, the total, minimum and
maximum time of the calls and the number of calls. The profile report
can also be saved as ASCII. Very nice to have such a simple yet
powerful tool built into the IDE!

DOCUMENTATION

	The program comes with a single 200 pages written English
manual describing the various parts. It does a pretty good job
explaining everything including compiler options etc. but they could
really need some proof-reading (They're Germans, remember ;-).

	Unfortunately the manual I received with the 2.0 version of
the software was for version 1.1. Therefore most of the new functions
were described in a .readme and a .guide file.

	I couldn't find information about the following and therefore
had to figure it out myself:

	Documentation of ARexx commands.
	Information on how to link assembler with C.

	Haage&Partner promises that the manual will be updated with
the next update of StormC!

LIKES

	-The ease of having an IDE
	-GoldEd included instead of trying to making a perfect editor
	 themselves
	 (but StormEd included in case you don't like GoldEd).
	-The debugger/variable watcher system and its great integration with
	 both editors.
	-Built-in profiler.
	-Quality of the generated code (speed/size).

DISLIKES AND SUGGESTIONS

	Dislikes:
	-The price - although it is cheaper than an equivalent developer
	 environment for other platforms.
	-Having to run a commodity just to start on its own screen.

	Suggestions:
	- Integration with a GUI builder program (and in my opinion it should
	  not be StormWizard - why introduce yet another standard? Why not
	  settle for MUI/MUIBuilder or ClassAct?).
	- Snapshot of windows for each project, and not just globally!
	- Debugging of tasks/libraries.
	- A register watch window would be nice when debugging at assembler
	  level.
	- Improvement of the manual.
	- And a bunch of suggestions for GoldEd, but the StormC people are not
	  to blame directly here so I'll skip it.
	- Faster e-mail response.

COMPARISON TO OTHER SIMILAR PRODUCTS

	The only other development system on the Amiga that could
probably match StormC is MaxonC, but as I have no experience with
MaxonC (they don't even have a demo available) I cannot compare the
two. I used to use SAS/C and IMHO StormC is far better (perhaps except
for the compiler itself in plain C mode)

	If StormC was integrated with MUIBuilder or the like, we'd
have something that started to look like Delphi or Visual(Something)
for Windows.

BUGS

	I have found a few bugs and have reported them to Haage & Partner:

	- When dragging a drawer into the project managing window (the one
	  containing the icons) the StormC GUI doesn't respond to input
	  anymore and the CPU goes at 100%
	- The supplied fd2pragma say "No FROM file given" - no matter what
	  parameters I pass to it. I have be promised to receive a bugfixed
	  version soon.
	- When double-clicking on a file from the project management window,
	  GoldEd opens in StormC mode with C syntax parsing etc. no matter
	  what type of file it is. (This is not actually a bug, but at least
	  it should not work that way).
	- Sometimes the disassembler output text looks a bit garbled at the
	  end of the line. This depends very much on which font you use.
	- I found a bug in the compiler when using the 1.1 demo
	  (something with overloading the '+' operator for a fraction
	  class in C++) and reported it to Haage&Partner. It has still
	  not been corrected (or at least I get the same error) with
	  my version 2.00.08 of the StormC compiler. Guess I'd better
	  tell them again!?

	Furthermore I have read about some people on
comp.sys.amiga.programmer who claim to have found bugs in the StormC
compiler. I will not say that you have to worry about StormC
generating faulty code, but obviously there are a few bugs to be
fixed. Haage & Partner makes patches available on their home page.

VENDOR SUPPORT

	I have contacted Haage & Partner quite a few times by e-mail
and I must say that their response time varies very much from time to
time. Usually they respond within a week, but most times it takes just
a day or two. One time I experienced a three week reply time where I
reposted my message three times, but I hope that was a mistake (At
least they apologized politely)!.

WARRANTY

	From the StormC 2.0 demo .guide file

	  (1) The HAAGE & PARTNER COMPUTER GmbH guarantees, that up to
the point in time of delivery the data carriers are physically free of
material and manufacturing defects and the product can be used as
described in the documentation.

	  (2) Defects of the delivered product are removed by the
supplier within a warranty period of six months from delivery. This
happens through free replacement or in the form of an update, at the
discretion of the supplier.

	  (3) The HAAGE & PARTNER COMPUTER GmbH does not guarantee
that the product is suitable for the task anticipated by the customer.
The HAAGE & PARTNER COMPUTER GmbH does not take any responsibility for
any damage that may be caused.

	  (4) The user is aware that under the present state of
technology it is not possible to manufacture faultless software.

CONCLUSIONS

	The product is really a state of the art developer
environment. Although it is not perfect it implements many developer
features never seen on the Amiga before. My ratings look like this
(five stars being the best possible):

	Environment:	****
	Compiler:	****
	GoldEd:		****
	Manual:		***
	Support:	**
	General rating: ****

	The manual is not that important to me, but the support could
be better!  If you need a professional developing environment for the
Amiga, this product should be the first for you to investigate. Even
if you are a hobbyist programmer and don't want to pay that much, I
urge you to try the demo to see just how much money can buy :-) My
hobbyist programming has certainly become easier and more productive
since I got StormC.

COPYRIGHT NOTICE

	I hereby grant permission to post this document on the USENET
newsgroup comp.sys.amiga.reviews, storage at the reviews ftp site and
Aminet, and distribution to the Amiga Web Directory at CUCUG.  Haage &
Partner may also include or quote the review on their home page without
taking quotes out of their context.  Commercial magazines may quote or
include the review providing that the send me the issue in which the
quote occurs (contact me at the e-mail address below). Otherwise this
document remains copyrighted by the author.

	Copyright 1997 Jens Kristian Jensen.
	Comments are welcome at [email-masked]

---

   Accepted and posted by Daniel Barrett, comp.sys.amiga.reviews moderator
   Send reviews to:	[email-masked]
   Request information:	[email-masked]
   Moderator mail:	[email-masked]
   Anonymous ftp site:  math.uh.edu, in /pub/Amiga/comp.sys.amiga.reviews
   Web site: ftp://math.uh.edu/pub/Amiga/comp.sys.amiga.reviews/index.html