Amiga ISO Collection/AmigaDemoCD2.iso/ASCII/TEXTE/c.s.a.reviews/software/programmer/AsmOne

Text File | 1994-06-02 | 7.1 KB | 196 lines

Path: menudo.uh.edu!usenet
From: [e-mail] (Reviewer with no e-mail address)
Newsgroups: comp.sys.amiga.reviews
Subject: REVIEW: AsmOne assembler
Followup-To: comp.sys.amiga.programmer
Date: 25 Jun 1993 19:48:12 GMT
Organization: The Amiga Online Review Column - ed. Daniel Barrett
Lines: 171
Sender: [e-mail] (comp.sys.amiga.reviews moderator)
Distribution: world
Message-ID: <20fkps$[e-mail]>
Reply-To: [e-mail]
NNTP-Posting-Host: karazm.math.uh.edu
Keywords: assembler, programming, 68000 family, commercial


PRODUCT NAME

    AsmOne version 1.02

    [MODERATOR'S NOTE:  The author of this review, Tomas Nilsson,
    does not appear to have an e-mail address.  - Dan]


BRIEF DESCRIPTION

    A fast assembler/disassembler and debugger for 68000 code.


AUTHOR/COMPANY INFORMATION

    Name:        Rune Gram-Madsen
    Address:    DMV - Verlag        (the distributor)
            Postfach 250
            D-3440 Eschwege
            Germany


SPECIAL HARDWARE AND SOFTWARE REQUIREMENTS

    HARDWARE

        A half meg of memory is enough to start with, but larger
        programs require more memory.

        It works fine with any Amiga CPU available today (60000
        through 68040).

    SOFTWARE

        It runs under any Kickstart version (tested under 1.2 through
        3.1).

        The freely distributable req.library makes your life easier
        but is not required.


MACHINE USED FOR TESTING

    All available Amiga models with various Kickstart versions.  Memory
on these machines varied from a machine with 0.5 MB Chip RAM to a machine
with 2 MB Chip RAM and 6 MB Fast RAM.

REVIEW

    AsmOne looks very similar to the old K-Seka, but don't be fooled.
Under the surface of the program there is a very powerful assembler with
lots of options.

    To start with, it asks you to specify your "work memory."  This is a
fixed value in kilobytes.  Within this workspace, your source is placed
together with the assembled program.  All external files such as include
files will not be placed here.

* Writing a source file

    There is no need for some kind of external editor.  It's built in
and it's _FAST_!  It supports the basic cursor movements together with some
extra commands (such as jump 100 lines up/down).  There is block
mark/copy/save to disk/lowercase/.../...  options.  Search/search+replace,
mark place/jump to marked place... etc.

* Assembling speed

    Assembling is astonishing fast.  (Speed results for a 500 KB
disassembled file originally written in C took 10.5 seconds to assemble.  In
comparison, Devpac takes 38.2 seconds.)  If you are using include files,
that's no problem.  AsmOne does not read the files again if you don't ask it
to.  This speeds up assembling a lot on a floppy disk system.  On a fast
hard disk, it doesn't matter that much; but anyway, it's almost twice the
speed if you assemble a file with lots of include files on a standard Amiga
3000.

* Bug killing

    There are some different type of error tracing methods, but the one I
usually run is to stop assembling at an error.  If an error occurs, the line
that it occurred on is displayed together with an appropriate message.

    The assembled file can be written as an object file or be run in
memory.  The link file is somewhat broken.  If you choose to run the file
from memory (it's the normal way to do it), you can either just run it as if
it were run from disk, or run it in the debugger.

* The Debugger

    Running your program from the debugger is the real strength of
AsmOne.  In debug mode, you can see your source (as it was written in the
editor).  At the rightmost part of the screen in debugging mode are the
normal registers (D0-D7/A0-A7/SSP/USP/SR/PL/PC).  Now you can choose several
options.  The most normal is to set some kind of breakpoint somewhere within
the code.  This can be done by either setting a address or a label, or just
marking a position using the cursor.  Now, run the program.  It will stop at
the marked position.  From here is it maybe now interesting to check the
failing part of the code.  Now, you might want to know what some of
registers are pointing to.  Well, you simply add a watch(er).  Some examples
of watches are A0; A0+4; D0; $60000; (D0*3)+D1 and so on.  The watches can be
interpreted in several ways such as pointer to binary.  Now you can step N
instruction(s).  By tracing the source down like this, you can find any error
in a quite simple way.

    Since there is a built-in-debugger, it handles all faults your
program might come up to (such as TRAP-F) without a Guru.  A fun side effect
of this is that if the AsmOne code itself somehow gets destroyed, its own
debugger breaks in.

* Programming

    AsmOne is not system friendly in the same way as Devpac.  You can
freely walk around in the memory poking around to see what you might find.
This can be done either in hex+ASCII, plain ASCII, or as disassembled
memory.  You might feel, as I do, that you are on top of everything.  It's
just to peek'n'poke around just as you like and sooner or later you will
(hopefully) find your annoying bug.  AsmOne itself is programmed this way to
be fast, but unfortunately it's sometimes too fast using some rude memory
access methods.  If you're running the Enforcer together with AsmOne's debug
mode you will, each time you step an instruction, get an Enforcer hit on
address $8 to $48.

* The Program Itself

    Unlike any other assemblers (except K-Seka), you can either work with
the menus or work in a command-line mode.  All commands are short and simple
to use.  Examples are "A" (Assemble), "AO" (Assemble with Optimize) and
"h.l $60000" (look at memory address $60000 in hex mode and display it in
longwords!).  Most of these commands can be found in the menus.  One of the
commands that can't be found in the menus is the built-in calculator.  It
can calculate most of the normal programming operations such as AND, OR, NOT,
and the normal "+-/*" operations.  Results are displayed in hex, decimal,
ASCII and binary.


LIKES AND DISLIKES

    The parts that I really like are the speed of the editor/assembling
and the great debugger.

    The parts that I dislike are that it can not run at any screen wider
than 80 bytes, it can't edit more than one source at a time, and that it
can't run batchfiles upon assembling (like linking a source automatically
after assembling).


BUGS

    Well, there are no major bugs, but there's a LOT of minor bugs.  For
example, if you want to look at memory in longwords you can use "h.l
$50000".  But if you're using "h.l a0" the memory will be shown in byte
format.  I can live with this though.


CONCLUSIONS

    The product is great, especially for its speed (as I've told you
before :)).  I'll give it a 4 out of 5.  It would be a 5 if the bugs were
removed!

    My final word is: yes you should buy it.  (If you can:  it's not sold
in all countries.)  I've been using it for a long time now and I have never
regretted that I tried out this program.


COPYRIGHT NOTICE

    Copyright 1993 Tomas Nilsson.  All rights reserved.

    This text can be spread freely, but with no profit.  If your purpose
is in ANY kind to make money on this then contact me first.

---

   Daniel Barrett, Moderator, comp.sys.amiga.reviews
   Send reviews to:    [e-mail]
   Request information:    [e-mail]
   Moderator mail:    [e-mail]