Fresh Fish 9/FreshFishVol9-CD2.bin/bbs/reviews/programmer.lha/programmer/DICE3.0_2

Internet Message Format | 1994-06-02 | 23KB

Path: news.uh.edu!barrett
From: [e-mail] (Ed Berger)
Newsgroups: comp.sys.amiga.reviews
Subject: REVIEW: DICE Version 3.0
Followup-To: comp.sys.amiga.programmer
Date: 2 Jun 1994 17:44:40 GMT
Organization: The Amiga Online Review Column - ed. Daniel Barrett
Lines: 503
Sender: [e-mail] (comp.sys.amiga.reviews moderator)
Distribution: world
Message-ID: <2sl5q8$[e-mail]>
Reply-To: [e-mail] (Ed Berger)
NNTP-Posting-Host: karazm.math.uh.edu
Keywords: programming, C, compiler, commercial
Originator: [e-mail]


PRODUCT NAME

    DICE Version 3.0


BRIEF DESCRIPTION

    DICE 3.0 is the commercial version of the popular shareware DICE C
language compiler created by Matt Dillon.  The package contains a 450-page
manual and 5 disks containing two different text editors, a C compiler,
linker, debugging tools, source code management tools, source to the linker
libraries, example programs and a 1.3 AmigaDOS compatible on-line help
system.


AUTHOR/COMPANY INFORMATION

    Name:        Obvious Implementations Corporation
    Address:    P.O Box 4487
            Cary, NC  27519-4487
            USA

    Telephone:    [phone]
            [phone]

    E-mail:        [e-mail]


LIST PRICE

    Regular                $150  US dollars
    Student (any school)        $ 95  US dollars
    Owner of registered DICE    $ 75  US dollars

    I upgraded from the registered version.


SPECIAL HARDWARE AND SOFTWARE REQUIREMENTS

    HARDWARE

        1M RAM required.  More is suggested.
        2 floppy drives disk space.  Hard drive preferred.
        Battery backed clock recommended, but not required.

    SOFTWARE

        AmigaDOS 1.3 or higher required.
        AmigaDOS 2.x and 3.x compatible.


COPY PROTECTION

    None.


MACHINE USED FOR TESTING

    Amiga 3000/16, 12MB Fast RAM, 2MB Chip RAM.
    AmigaDOS 3.0 beta (purchased through the Commodore developer program)
    Seiko CM1440 VGA monitor


INSTALLATION

    The package uses Commodore's Installer program.  The installation
script can be run multiple times for any additions to be made.  A separate
installation script is available for floppy users which uses a custom
compression system.

    Installation of a large package like DICE -- with all its utilities,
AmigaDOS-dependent revisions of the Commodore include files and linker
libraries, compiler support options, numerous utilities, library source
code, and example programs -- deserves some extra attention to the
procedure, especially for beginner programmers.  Here are two examples.

    An AmigaDOS 1.3-based A500/A590 owner might want a minimal
installation.  This might consist of AmigaDOS 1.3 include files, linker
libraries, the DICE compiler with small data model and registerized
parameters support, the debugger, and library and example source code.  This
takes up 2,258,513 bytes.

    An experienced developer might want a rather full installation.
This might consist of all the include files, libraries, support of multiple
data models, source control and debug utilities, and on-line help.  This
takes up 11,415,299 bytes of hard disk space.

    I recommend reading through chapter 6 of the manual to gain some
more familiarity with the DICE programming environment before installing it.


BUILDING PROGRAMS WITH VMAKE

    One of the highlights of the commercial version of DICE over previous
releases is the new VMake utility.  It integrates the whole DICE programming
environment with a new graphic user interface (GUI).  VMake is a very
powerful and useful utility.  It offers the inexperienced user the benefits
of a 'make' program without having to learn all the strange syntax that
Makefiles require.

    To use VMake on already existing source files, you invoke it either
from the CLI or by the Workbench icon, and select "New" from the Project
menu.  A standard ASL requester appears (under AmigaDOS 2.04 and above), and
you select the directory where your source is, and type in a name for the
project.  A '.dice' extension is added to the name.  Next, you select "Scan"
from the Edit menu, and VMake scans the directory for file.  Delete any of
the unnecessary files from the listing, and save the project.  Voila:  you
have just created a Makefile!  You can then select the "Options" menu item
in the Edit menu to customize the compiler options such as OS Target, which
debug level you want, optional places to search for include files or linker
libraries, small code model or large code model.  These options may be
saved.  All the things which you would change with the various switches if
you were compiling from the CLI are available through the graphic user
interface.

    Now to compile and run your program, you press the "Make" button or
use the Compile menu, and off DICE goes, compiling your project.  You can
then run your program by hitting the Run button or selecting the appropriate
menu items.  You can simulate running your program from Workbench, or feed
CLI arguments to your program by way of the "CLI Arguments" string gadget.  A
menu option is available to run your program through the debugger as well.
It's a smooth and easy-to-use environment.

    VMake is also a lot more.  Instead of all those gadgets and menu
items being hard coded into the program, VMake uses extensible configuration
files.  If you don't like a menu hotkey, just edit dcc:config/vmake.config
to make the change.  For example, I didn't like using Amiga-Y for the
"Project New" subitem.  My VMake is now a little more Style Guide compliant
with Amiga-N in its place.  While VMake normally opens on the Workbench
screen it also supports 'jumping' from one public screen to another.  I
would have liked VMake to use the Amiga Style Guide command line keyword and
icon tooltype "PUBSCREEN" so that I could have it open automatically on the
particular screen I want.  But jumping is better than nothing.  Further
customizing of the VMake environment is available through ARexx.  VMake
comes preconfigured fairly well.


REVISION CONTROL AND EDITOR INTEGRATION

    One of the most useful features that VMake integrates into the
programming environment is revision control via the "RCS" and "UpRev"
utilities.  RCS (Revision Control System) has been used for years on UNIX
platforms, where developing large projects with multiple programmers can
lead to problems.  RCS provides a way of tracking multiple versions of a
program or its pieces.  It helps you to find newly created bugs in your
programs by allowing you to compare various revisions of a file and look
over the differences.

    VMake integrates RCS into its GUI, allowing you to concentrate on
your code and not on the command line switches required to learn RCS.  I
always told myself that I was going to learn RCS some day, but now I don't
really have to. :-)  To "check in" a file under RCS/VMake, you just click on
the filename in the VMake listview and select the RCS Menu "Check In"
subitem.  Fill in the "initial comment" prompt on the VMake console window,
followed by a line with just a period.  RCS then makes an "rcs" subdirectory
in the current directory, and sets the current file protection to
read-only.  If you then want to change that file by popping up your editor,
just double-click on the filename in the VMake listview and you are presented
with a requester telling you that the file is read-only and do you want to
check out the file from RCS?  Select "Yes", edit the file, and then check it
back in with RCS when you are done, this time entering comments about what
changes you made.  You can review the change history on demand.

    UpRev generates an Amiga User Interface Style Guide type of revision
string that you can use in your programs.  VMake has an Edit menu subitem
for UpRev.  When used the first time, it creates an include file

        PROJECTNAME_rev.h

where "PROJECTNAME" is the name of your project.  If you include this header
file in your your program file which contains main(), and add a line like:

    const char my_version_string[]=VERSTAG;

you automatically get an Amiga User Interface Style Guide compliant version
string in your program, which you can easily update any time you've made
changes to your program by simply choosing the edit menu subitem 'Update
Revision' and recompiling the program.  Together, RCS, UpRev, and VMak