Visit Atarimax Store

Free-Net Logo
The Atari SIG Historical Archive
Created and hosted by:

Article #17 (26 is last):
Newsgroups: freenet.sci.comp.atari.product.16-32bit.summary
Subject: Lattice C v 5.5/Languages/Commercial
Posted-By: xx004 (aa400 - John J. Lehett)
Edited-By: xx004 (aa400 - John J. Lehett)
Date: Sat Jul 18 15:06:48 1992

Taken from: ST Report (#822)

 > Lattice C v5.5 STR InfoFile               Essential overview

                           Lattice C Version 5.5

 Lattice C Version 5.5 is an  extremely versatile  and powerful development
 system for  the popular C programming language, adhering extremely closely
 to the ANSI standard.

 The system is characterised by a truly flexible  environment together with
 the attainment of a very high speed of object execution.

 In  the  development  of  Lattice  C  5.5  for  the  Atari  range of 680x0
 computers, the emphasis was on producing  a  package  that  could  be used
 easily by the novice to the language as well as by the seasoned expert.

 Freedom  of  choice  for  the  user  is  essential if such a goal is to be
 attained and this has been achieved at all levels of the development cycle
 resulting in  a flexible, easy-to-use and extremely powerful collection of
 programming  tools  -  probably  the  ultimate  C  system  for  the  Atari

 The Compiler
 The Lattice  C5 compiler  is one  of the most advanced compilers available
 for 680x0 machines, having already been established on the Atari and Amiga
 computers for over two years.

 There are  two phases  of compilation (LC1 and LC2) with an optional third
 phase, the Global Optimiser.

 The code produced by the compiler is compact and executes as fast  as that
 produced by  any other  compiler that is currently available for the Atari

 In addition  to  producing  excellent  code,  Lattice  C5  also  gives you
 tremendous  flexibility  through  more  than 100 compiler options, some of
 which are listed below:-

 *   choose between large/small/mixed code and data models
 *   backward   compatibility    modes    for    nested   comments/pre-ANSI
     pre-processor etc.
 *   full xref and listing control
 *   error/warning  message  control  -  switch  messages  on  and off on a
     per-error basis
 *   full code generator optimisation control - turn on/off as required
 *   optimise for time/space
 *   pre-process only option
 *   full prototype extraction facility
 *   default  int  to short or long option
 *   define symbols on the command line
 *   full native 68030 and 68882 code generation

 All these options (and many more) can be  set from  within the  editor, in
 the program or on the command line.

 The compiler  supports pre-compiled  Header Files so that the header files
 for a project may be compiled  separately and  the resulting  symbol table
 saved to  disk, ready  for re-loading by each compilation, saving valuable
 time since the header files do  not then  have to  be read.  There is also
 support for compressed header files to save disk space.

 The ANSI  compliance of  the compiler  is strict and complete as far as we
 know including support for Trigraphs, Float as a native type  and flexible
 keyword ordering.

 Language Extensions

 The  package  supports  all  of  the ANSI keyword extensions: const, enum,
 signed, void, volatile.

 Trigraphs, float  as  a  native  type  and  support  for  flexible keyword
 ordering add to the ANSI compliance.

 There are  keywords to control how functions are called with parameters on
 the  stack/in   registers:   __asm,   __interrupt,   __regargs,  __saveds,

 Several  built-in  functions  provide  fast,  high quality inline code for
 common simple library functions:
 abs, max, memcmp, memcpy, memset, min, strcmp, strcpy and strlen.

 There is also support for direct access to the instruction stream through:
  __emit, getreg and putreg.

 Inline TRAPs and Line-A usage are achieved via  #pragma inline  - tell the
 compiler how to call the operating system and it does this
 inline without a  stub .

 In addition,  you can  use anonymous unions, C++-style // comments, signed
 and sized bit fields, zero length  arrays, pragmas  for listing  and error
 control and cast values are modifiable.

 As with most parts of the package, the compiler can be invoked from within
 the editor provided or from within a command-line  shell.   When using the
 screen editor,  there is  full interactive error reporting, allowing swift
 and easy correction of your syntactical mistakes.

 The Linker
 Lattice C5 comes with a fast,  high-performance linker  (typically linking
 in less than 5 seconds) with many powerful features such as:

 *   pre-linking -  make several  files into a partially linked object file
     ready for further linking
 *   automatic link vectors (ALVs)  for attaining  the benefits  of a small
     code model  (16 bit  jumps) without  the limitations  of a 64k maximum
 *   definition and aliasing of symbols from the command line
 *   full DR and HiSoft symbols can be included in the executable
 *   TT program flag options
 *   Common Block support
 *   complete map file printing and format control
 *   fast, compact library format including a librarian.

 The Editor

 Included in the Lattice C5 package is a complete, multi-window  (up to 7),
 GEM-based  screen  editor  which  fully  integrates  with  the rest of the

 The editor is fast, easy-to-use and friendly with a full range of search &
 replace and  block commands together with powerful menus that allow you to
 control and invoke all of the other tools in the Lattice C5 package.

 All compiler, linker, debugger, assembler  and  librarian  options  can be
 accessed through easy-to-use dialogs.

 You can  also customise  the Tools menu to run your own programs (up to 20
 of them), which will return to the editor when they terminate.

 There can be up to 7 windows open at any one time with the ability to move
 blocks of text between them and to use small fonts for up to 54 lines on a
 standard monochrome monitor.   The editor  works in  any screen resolution
 that allows 80 or more columns.

 Project Manager
 Integrated  within  the  editor  environment is a powerful project manager
 which allows efficient building  of all  types of  program (GEM,  TOS, DA,
 etc.), libraries or pre-linked object files.

 All source files (be they C or assembler) are tracked, together with their
 include dependencies and there is support for recursive  making of project

 Additional libraries,  object or  WITH files can be specified and compiler
 options may be set on a  per-file  or  per-project  basis.    All  this is
 controlled from an easy-to-use graphical project editor.

 The Shell
 For  the  traditional  user  who  may  prefer  to work from a command line
 environment, we provide a powerful MS-DOS style shell supporting:

 *   line editing with full command history
 *   support for batch files with optional parameters
 *   command re-direction
 *   full support for environment variables
 *   over 25 built-in commands

 The Debugger
 The highly-acclaimed MonST2 low-level debugger is  supplied, complete with
 extensions for supporting source line debugging.  You can single-step, set
 conditional  breakpoints,  search  memory,  move  memory  and  much  more.
 Multi-windows  allow  you  to  inspect  the  processor's registers, memory
 locations, disassembly and C source code, using line numbers to debug your
 C program.

 The Resource Editor
 The  resource  editor  supplied,  WERCS,  is  a  full  featured editor for
 designing menus and forms and includes an integral  icon editor.  It has a
 number of advanced features not found in other resource construction sets,
 such as 16 character object names, automatic naming  of objects, searching
 for strings, and no limits on the numbers of objects in a tree.

 Also supplied  are utilities  for converting  Neochrome and Degas files to
 Icons and for using the name files used by other  resource editors, making
 upgrading to WERCS a snap.

 The Assembler
 The Lattice  Macro Assembler is a full 68040/68881 assembler which handles
 the complete set of  Motorola 680x0  instruction mnemonics  as well  as an
 extensive set of assembler directives and a powerful macro facility.

 It  can,  therefore,  be  used  to  develop  complete  systems in assembly
 language. Nonetheless,  it  is  provided  primarily  to  supplement  the C
 compiler  and  has  not  really  been designed for large assembly language

 For such tasks a full assembler package, such as DevpacST,  should be used
 giving  more  power  and  greater  documentation  on the assembly language

 Global Optimiser

 Available as an optional third phase of compilation  the global optimiser,
 GO, allows  you to  hone the object code according to criteria of speed or

 Some of the optimisations performed are as follows:
 *   register  assignment  -  commonly  used  auto,  formal  and  temporary
     variables are automatically assigned to registers
 *   dead  store  elimination  -  stores  of values which are never fetched
     again are eliminated
 *   dead code elimination - code whose value is not used is removed
 *   global common  sub-expression merging  - recalculation  of values that
     have been previously computedis eliminated
 *   hoisting of invariants out of loops - a calculation performed inside a
     loop whose value is the same on each  iteration of  the loop  is moved
     outside the loop
 *   induction variable transformations - loops containing multiplications,
     usually associated  with  indexing,  have  the  operations  reduced in
     strength to addition
 *   constant propagation  and folding - references to variables whose only
     definition is a constant  are replaced  by the  constant.    Often the
     definition is  eliminated if all references are replaced.  GO performs
     constant folding to propagate new constants further
 *   very busy expression hoisting - code  size  is  reduced  by  moving an
     expression computed  along all  paths from  a point  in the  code to a
     common location
 *   strength reductions  - associative re-ordering  of additive operations
     involving constants, to reduce the operation count
 *   control  flow  transformations    - perform various transformations to
     eliminate unreachable code or  useless  control  structures  Plus many
     other powerful techniques.

 The Lattice C 5 Tools
 Lattice C5 helps the programmer in his sometimes complex task by providing
 a number of useful  utilities designed  to complement  the main  tools and
 increase the  general ease-of-use  and speed  of development.  Reset Proof
 RAM Disk

 A  full-featured  auto-loading  reset-proof   ramdisk  with  configuration

 Header file compressor

 The utility for compacting header files so that you can build your own.
 Object Module Disassembler

 A disassembler for examining the output of the compiler/assembler.  Useful
 for hand optimisation  or  for  eliminating  those  obscure  bugs  in your

 Object Module Librarian
 A full  featured auto-ordering librarian (i.e. hand ordering of modules is
 not required) for building libraries ready for linking.

 Symbol Strip Utility
 A fast utility for  removing  the  symbol  and  debugging  tables  from an
 executable program to remove the
 need to re-link.


 DERCS  is  a  utility  for  turning  a  WERCS  resource file into a set of
 initialised data structures (OBJECT,  BITBLK, ICONBLK  etc.) which  may be
 compiled to produce an embedded resource file in your program.

 This is  advantageous when  creating desk accessories since DAs should not
 call rsrc_load(), and is  essential for  writing Control  Panel eXtensions

 DERCS supports  the generation  of both C and assembly language structures
 unfortunately the initialisation support available from other languages is
 not  sufficiently  rich  to  allow  the representation of general resource
 files and so, if a language of anything  other than  C is  selected, DERCS
 will generate an assembly language file.

 The Libraries
 Lattice  C  5.5  has  an  extensive  set of library functions for all your
 needs. Here is a selection of what is available:
 In addition  to standard  UNIX library  functions, there  are many Lattice
 extensions and a full range of ANSI functions.

 Full support  for all  of the standard Atari GEM, AES and VDI functions is
 provided and, in addition, there are functions for GDOS, FONT GDOS and FSM
 GDOS, including bezier curves.
 The TOS  library includes all the GEMDOS, BIOS, XBIOS and Line-A functions
 together with support for  the new  OS calls  in the  MegaSTe and  the TT.
 There are also Cookie Jar functions, even for early-ROM machines.

 Four different  real math  packages are  supplied - a TT68882 library (for
 best performance), an I/O-only library (for a MegaSTe or SFP004  card), an
 auto-detecting library for portability and a software library.

 There are CPX, Program, Desk Accessory and Resident libraries.

 The Package
 Lattice C5.5 is supplied in attractive, rigid, protective packaging with:
 *   Multi-volume documentation  - the  User Manual  describing the use and
 function of each element of the package, the Library Manual  detailing the
 generic Unix, ANSI and Lattice libraries and the Atari

 Library Manual which deals with the ST/STE/TT-specific GEM, AES,
 VDI, XBIOS etc. libraries.

 *   An  Installation   Guide  for   easy  setting  up  on  various  system
 *   7 double-sided diskettes in an quality disk wallet.

 1Mb+ of memory and a hard disk are recommended if you wish  to use Lattice
 C5.5 to its full potential.

                              The Old School
                                 MK45 5DE

     Please,  see  Cat  3  Topic  14  on  GEnie  in  the  ST RT for further
     information & ordering details.


Visit Atarimax Store