[Search for users] [Overall Top Noters] [List of all Conferences] [Download this site]

Conference hydra::amiga_v1

Title:AMIGA NOTES
Notice:Join us in the *NEW* conference - HYDRA::AMIGA_V2
Moderator:HYDRA::MOORE
Created:Sat Apr 26 1986
Last Modified:Wed Feb 05 1992
Last Successful Update:Fri Jun 06 1997
Number of topics:5378
Total number of notes:38326

1873.0. "Lattice Amiga C V5.0 announced, with source debugger" by CANIS::RIES (Frank W. Ries Jr.) Sun Nov 13 1988 20:27

11/08/88
  
Lattice Releases Major Upgrade of Lattice C for Amiga
---------------------------------------------------------

   Lombard, IL -- Lattice, Incorporated announces Version 5.0 of its 
AmigaDOS C Compiler which features an integrated editor and compiler, a 
new source-level debugger, global optimizer, significant enhancements to 
the compiler and Blink overlay linker, plus many new utilities.

  Available November 1988, Lattice C for AmigaDOS Version 5.0 gives full 
support for 68020 and 68030 processors and 68881 math co-processor 
chips.  It features many faster library routines resulting from improved 
algorithms and assembly-language coding, and it offers improved ANSI 
compliance.  Several new keywords are introduced in this version 
including "near" and "far" which allow programmers to mix the way 
data is addressed regardless of the memory model used.  New options give 
users the ability to instruct the compiler to generate code sequences 
optimized for either program size or execution speed.

   The Lattice Screen Editor (LSE) is now part of the compiler package.  
The compiler can be called from within LSE to compile a C source file 
from memory and display any error messages with the cursor positioned on 
the offending line.  Programmers can stop the compiler and make the 
change immediately or can continue the compilation; LSE will redisplay 
the errors and reposition the cursor and lines containing errors.  

   For users with an additional 20 kilobytes memory, Lattice includes a 
"big" version of the compiler which will generate prototype files of all 
functions encountered in a module.  The big compiler also provides full 
listing abilities including macro expansion display, nest level 
counting, and include file listing.  

   Improved error handling and error recovery are provided, and users now 
have the option to disable error messages.  A separate file contains all 
messages so messages can be customized for international users.  Version 5.0 
also features several new built-in functions, many other optimizations and 
enhancements, plus a completely new two-volume set of documentation.

   With Version 5.0, Lattice introduces CodeProbe, Lattice's new full-screen 
source-level debugger with symbolic and concurrent process support.  The new 
debugger allows programmers to open multiple windows and single step through 
programs, set breakpoints on C source lines, examine variables and code at 
the C language or assembly language level, display memory, view and manipulate 
register data, and much more.  Users can take advantage of the Amiga's menus 
or choose a command line interface.  An additional debugging aid is composed 
of a special new start-up routine that avoids gurus on exceptions such as 
division by zero and illegal address or instructions and, Traceback, which 
reads back program debugging information generated at the time of the program 
crash.

   Other utilities provided with the compiler include an improved assembler 
that will generate 68020 and 68881 instructions; an improved disassembler, a 
new global optimizer that provides improvements of up to 25 per cent; a 
powerful new code profiler that gives a performance analysis to help users 
locate areas of their programs that would benefit from more efficient 
routines; and a utility to convert Commodore FD files into pragma statements 
that can be used in a C program.  In addition Lattice includes its Compiler 
Companion which consists of the UNIX-like utilities DIFF, EXTRACT, BUILD, 
FILES, GREP, LMK (Make), SPLAT, TOUCH, WC, and CXREF. 

   "All the standard benchmarks we have run show Lattice C Version 5.0 is the 
fastest, most efficient compiler and language for the Amiga in terms of both 
compiler speed and efficiency of the programs produced," said Wayne Nartker, 
Lattice vice president of sales and marketing.  "With Lattice's unlimited 
technical support plus the complete set of programming tools included with 
the compiler, we believe Lattice C also gives Amiga programmers the best value 
of any other language."

Release information:
-----------------------------
   The suggested price of the complete Lattice C package is $300.00.  
Registered users of version 4 of Lattice C may upgrade to Version 5.0 
for $ 75.00.  Registered customers with versions eariler than 4.0 can
update to version 5 for $100.00. Registered users of version 3.4 or later 
of the Manx Aztec C Compiler may upgrade to Lattice C for $150.00 plus 
their Manx manuals and distribution diskettes.

* Registered Lattice Compiler Companion owners can knock off $30.00 from 
  the above listed prices.
  
   For further information, contact: Lattice, Inc. 2500 South Highland 
Avenue, Lombard, IL  60148.  Telephone (312) 916-1600.  FAX (312) 916-1190.
T.RTitleUserPersonal
Name
DateLines
1873.1CANIS::RIESFrank W. Ries Jr.Sun Nov 13 1988 20:368
The preceding information was downloaded last night from the Lattice BBS.
Another note said that they will be sending update notices to all registered
users. Also, you may order your upgrade by phone using a credit card.

At last, a source level debugger......yeah!!!

Frank

1873.2Wow!ANT::SMCAFEESteve McAfeeFri Nov 18 1988 16:1035
    
    I received my Lattice V5.0 update two nights ago.  I haven't had
    much time to really dig into it but here are my first impressions:
    
    1.  Excellent documentation!  Two of the small 3-ring binders. 
        The presentation looks very professional.  The content looks
    	good too, but like I said I haven't really dug in yet...
    
    2.  CodePRobe (aka CPR) worked great on the small programs I tried.
        To use VAX Debug terms you can:  Go, Examine, Deposit, Set Break,
        SET BREAK where WHEN (exp) DO (exp).  You can also break when
        a particular variable changes.  Multiple break points are allowed.
    	You can examine variables defined as structures and it will
        show the structure contents.  You can also get type definitions.

    3.  Many other convenient features including:
    
          - C, ASM, and Mixed display.
          - Breakpoints can be set with the mouse.  "Go" can be performed
    	    with a double click on a source line.
    	  - Compiler companion included.  Lattice Screen Editor is
            included and is coupled with the compiler.  You can compile
    	    from within LSE and it will goto the errors in the source.
            (I didn't have a chance to try this yet.)
          - They've defined exactly what needs to be done to make a
    	    program reentrant so that it can be used with "resident".
            In fact most of the tools including the compiler, editor
    	    and linker are all "pure".
    
    I really could go on and on.  Are their any features in particular
    someone would like me to check out?
    
    regards,
    
    steve
1873.3I've got mine!!ANT::GERBERRobert GerberFri Nov 18 1988 20:332
    I just got home and found mine waiting at my door.  Now to see how
    much better it is than V4.
1873.4Debugger example?VTHRAX::KIPMon Nov 21 1988 11:479
Has anyone tried running the first example given in the Debugger manual
(lines.c)?  I compiled/linked it with: "lc -d3 -La lines" then ran: "cpr lines";
but don't seem to be able to duplicate their examples.  I get just assembler
code (no C) even though lines.c is in my current directory, along with a message
stating "not in any module".  I can "go" and lines will execute; just can't get
to the source code like in the example.  I've also tried increasing stack
size...no help.

Anyone else try this?
1873.5I found a couple of bugs already...ANT::GERBERRobert GerberTue Nov 22 1988 14:4128
    I have already found two bugs in the new Lattice compiler.
    
    1) When using the new CHIP keyword, you will get a module produced
       with invalid hunk id's.
    
    2) Under certain conditions (not yet determined) the following code
       segment will not generate correct code.
    
    	void sub_function()
        {
             <fill in some code>
        }
    
        main_function(var)
        int var;
        {
            <some code>
            sub_function();   <--- does not always generate subroutine
                                   calling code.
            <some more code>
        }
                                                
    This code did work under version 4.0 and 4.01 of Lattice.  I am
    going to send Lattice sample code tomorrow.  (I already talked to
    them.)
    
    Other than that, a couple of other programs I tried seem to work
    ok, and did generate smaller code with out the new Global Optimizer.
1873.6Some more bugsCANIS::RIESFrank W. Ries Jr.Wed Nov 23 1988 17:4033
    I have also run into a few bugs. I had a similar problem to .-1 with
    a subroutine call. I had a call like:

		FOO (&A,&B,C)

    and the compiler generated code that pushed A on the stack twice, followed
    by C. It did NOT push B! I haven't been able to determine what made it do
    this since most of the time it does generate the proper code. By the way,
    this was easy to find using the new debugger since you can have it display
    the C source code along with the assembly code.

    I have also run into a few debugger bugs. If you set a watch point and
    open the watch point window, when you hit the watch point the contents
    of what you are watching is display in the window. However, if the window
    is not wide enough to contain the display, the data will be lobed off at
    the right. Scrolling the window will not display the rest of the data.
    You must make the window larger.

    Also, the dialogue window does not seem to support xon/xoff. This is a
    major pain if you display a large structure or something cause it scrolls
    off the screen. Booo!

    I have also had it die with a fatal error a couple of times. However, it
    is a version 1 product, and overall I think its a great debugger.

    Oh, there is one other minor pick on the compiler. I got an error 143:
    Object has no address. However, the highest documented error number is 95!

    More reviews to come. It will be interesting to see how quickly Lattice
    comes up with fixes for this stuff. The major one is the compiler
    generating bad code (ie non-working).

    Frank
1873.7tell LatticeWJG::GUINEAUMon Nov 28 1988 14:368
Are you reporting this stuff on the Lattice BBS?

Sounds like your doing some good work finding out exactly what's wrong, let
Lattice know so they can fix it!
(In fact there may even be an update on the BBS already...)


John
1873.8LSE bug...Lattice LSE(TM) ??HPSTEK::SENNAMon Nov 28 1988 15:038
    This is a minor bug...but important to those of us who like to squint!
    
    LSE has a problem with interlace mode. While in interlace mode the
    scroll bar goes to a solid bar if you go to the bottom. Once this
    happens you are forced to use the arrow keys or toggle interlace
    twice to reset it.
    
    Tom
1873.9LSE -> COMPILE?WJG::GUINEAUSun Dec 04 1988 20:4613
Anyone got a file to compile from LSE yet?

I was getting problems because (I think) I as running out of memory. So I 
redefined QUAD:. Then a file that took 20 seconds or so to compile
normally (i.e. CLI) took about 5 seconds (WOW I thought!). Hoewever,
no object gets generated (I know about the compiler option -oram:)

Then I can put deliberate errors in a program, compile and get
"error: compiler reported errors". Then I F5 to see the errors
and it says "No more lc errors"???


John