Fresh Fish 8/FreshFishVol8-CD1.bin/useful/reviews/software/programmer/dice3.0

Internet Message Format | 1994-05-17 | 22KB

Path: news.uh.edu!barrett
From: [e-mail] (Ross Smith)
Newsgroups: comp.sys.amiga.reviews
Subject: REVIEW: DICE C compiler, version 3.0
Followup-To: comp.sys.amiga.programmer
Date: 13 May 1994 18:29:44 GMT
Organization: The Amiga Online Review Column - ed. Daniel Barrett
Lines: 462
Sender: [e-mail] (comp.sys.amiga.reviews moderator)
Distribution: world
Message-ID: <2r0guo$[e-mail]>
Reply-To: [e-mail] (Ross Smith)
NNTP-Posting-Host: karazm.math.uh.edu
Keywords: programming, C, compiler, commercial
Originator: [e-mail]


PRODUCT NAME

    DICE 3.0


BRIEF DESCRIPTION

    C compiler and integrated development environment for the Amiga.


AUTHOR/COMPANY INFORMATION

    Name:        Obvious Implementations Corporation
    Address:    PO Box 4487
            Cary, NC 27519-4487
            USA
    Telephone:    [phone]
    E-mail:        [e-mail]


LIST PRICE

    Standard purchase price:                  $150.00 (US)
    Student price:                            $95.00 (US)
    For SAS C owners:                         $95.00 (US)
    For registered owners of DICE shareware:  $75.00 (US)

    Currently, DICE 3.0 is available directly from OIC only; it is not
distributed through any other source.  It can be ordered by mail from the
address above or by calling the 800 number if you have a Visa card.  (Never
send your credit card number to anyone by email!  There are too many people
who could read it along the way.)

    The shareware version of DICE is no longer available.  See below
concerning the freeware version.


SPECIAL HARDWARE AND SOFTWARE REQUIREMENTS

    HARDWARE

        Requires 1 MB RAM.
        (DICE 3.0 uses 1.5 to 8 MB; see "Installation").
        Hard drive recommended but not required.
        No CPU restrictions.

    SOFTWARE

        Requires AmigaDOS 1.3 or better.
        Works fine under AmigaDOS version 2 and 3.
        A few features require AmigaDOS 2.0 or better.


COPY PROTECTION

    None.


MACHINE USED FOR TESTING

    Model:             Amiga 2000HD
    Processors:        25 MHz 68030 CPU, 68882 FPU
    Chipset:           PAL ECS
    RAM:               5 MB (1 MB Chip, 4 MB Fast)
    Hard drive:        Quantum 50 MB internal SCSI
    Floppy drive:      One internal 880K
    Monitor:           Commodore 1084S
    Operating system:  3.0 Beta (Kickstart 39.106, Workbench 39.29)


INSTALLATION

    DICE 3.0 comes on five disks.  Installation is done by the Commodore
Installer program.  There are three Installer scripts with icons on Disk 1 of
the distribution.  One installs DICE on your hard drive, a second installs
it on floppy disks, and the third creates the freeware version (see below).

    The hard drive installation works perfectly.  It offers an
assortment of options -- whether to install the 1.3, 2.0, and/or 3.0 header
files and link libraries; whether to include all, none, or a selected subset
of the examples; which editor to install; and so on.  Anything not selected
in the initial installation can be added later; an option in the Installer
script allows the addition of selected modules to an existing installation.

    Unlike some badly-written installers, DICE's installation process
is very careful never to change or replace any existing files without
explaining exactly what it's going to do and waiting for permission.

    Depending on which options you select, DICE can take up anywhere
from 1.5 to 8 megabytes of hard drive space.  Mine took up 4.7 megs, which
is probably a fairly typical amount; few users are likely to need the full 8
megs (which assumes, for example, that you install all three complete sets of
includes and libraries).  Incidentally, although the installer and the
manual refer to "3.0", the include files actually supplied are version 3.1.

    The freeware DICE is a freely distributable version of the compiler
with floating point support and some Amiga-specific features disabled, but
otherwise a perfectly good C compiler.  Users are encouraged to distribute
the freeware version, which consists of the compiler, link libraries,
standard C include files, and the relevant documentation -- no editor or any
other tools (though DME can be found on a Fred Fish disk).

    The freeware version Installer script attempts to install DICE onto a
single floppy, which doesn't work -- it's about 1.3 megs and needs two (I
guess they must have tested it on an Amiga 4000 with high density 1.76 MB
drives and forgot that most Amigas only have 880K drives).  This is easy to
get around if you're running the installation on an Amiga with a hard drive:
just create a drawer on your hard drive and assign "Freeware_Dice:" to it
before you start.  (You'll still need a spare floppy for the install script
to format, though.)  Afterwards, you can split the installed files between
two floppies.  You can't run the freeware installation on a floppy-only
system.


COMPILER

    The actual compiler is changed little from the shareware version of
DICE, apart from a few enhancements (mostly related to the VMAKE interface
-- see below) and bug fixes.  Anyone familiar with the shareware DICE will
find no surprises here.

    The compiler was designed with quick and reliable code generation as
the primary goal, with optimisation secondary.  That's not to say DICE does
no optimisation; it doesn't do the kind of aggressive optimisation
performed by GCC or SAS C, but it produces perfectly good code for all but
the most demanding cases (where most programmers would probably switch to
assembly language anyway).

    The DICE compiler, DCC, is almost entirely conformant to the
ANSI/ISO C standard, which is only to be expected these days.  There are a
very few features and functions omitted, such as the atan2() function, and a
large number of enhancements.

    Compiler features include precompiled header files, automatic
generation of function prototypes, profiling (a special set of link
libraries that allow you to keep track of exactly how much run time each
part of your program is taking up), and a "typeof" operator.

    Most of the enhancements, of course, are related to writing
Amiga-specific code.  These include automatic opening and closing of shared
libraries; the "__chip" type qualifier to force data into Chip RAM; dynamic
stack checking (which automatically gives your program more stack space when
it runs short); the "wbmain()" function (giving a program different entry
points depending on whether it was started from the Shell or Workbench);
full control over parameter passing via registers or stack; and an extensive
set of functions that make giving your program an ARexx interface fairly
painless.

    The DICE package includes the complete set of include files and
link libraries for Workbench 1.3, 2.0, and 3.0/3.1.


INTEGRATED DEVELOPMENT ENVIRONMENT

    The centrepiece of the whole system is VMAKE, which, as you might
expect from the name, is a visual "make" tool.  It's really an integrated
development environment.  You create a "Project" and tell VMAKE what source
files belong to it.  VMAKE gives you access to the editor of your choice (see
below), compiler, debugger, and help system.  Compiler options are selected
through VOPTS, which is basically a GUI for DCC -- you use the usual
Intuition tools (gadgets, list windows, and so on) to select the compiler
options, link libraries, and so on.  If you select a source file from VMAKE,
the editor is invoked.  Once you've written the source code and set the
compile options, you hit the "Make" button to compile and link everything
that needs it, then pick one of the "Run" options to test it (there are
three options -- CLI, Workbench, or Debugger).

    VMAKE knows what to do with individual source files by looking at
their names -- a name ending in ".c" is C code, ".a" is assembler source,
and so on.  It's smart enough to know not to compile a source file that
hasn't changed since the last compile.

    If you get compile errors, the editor is automatically brought up
with the cursor positioned on the line containing the first error; when
you've fixed that, you hit Shift-F5 (or whatever alternative key you want to
define) and the cursor is moved to the next error.  The full list of errors
is visible in another window.

    VMAKE is highly customisable.  All the ga