Programming Links
ES68 C Compiler
Z80 C Compiler
dbc III Library
Comm Library |
DOS & OS/2 COMPILER
A Complete Programming Environment
The Lattice Optimizing C Compiler consistently produces winning benchmark results. Unlike
compilers that are designed to optimize benchmark tests, the Lattice C Compiler will do
even better with "real life" applications. The global optimizer combined with
register variables, in-line function support, and super-fast library functions, ensure
your applications are as compact and fast as possible.
Lattice C includes LASM, a blazing fast macro assembler that lets you performance tune your
applications with assembly language modules. With all the features and functions found in
expensive stand-alone assemblers, LASM can also be used to write complete applications.
Lattice C gives you 100% ANSI compatibility with 100% ANSI compatible syntax and
semantics plus 100% ANSI compatible libraries. In addition, Lattice C Compilers and Cross
Compilers available for a wide range of operating systems on micros, minis, and mainframes
give you have unmatched portability for the programs you create. CodePRobe Source Level
Debugger gives you menu and mouse support that makes it easier than ever for you to
complete bug-free programs. For large programs, CodePRobe's cross debugging features let
you find and eliminate bugs in any DOS program that will run on a 600 KB system!
Lattice's library of more than 800 functions means there is less software that you have
to write! You get the standard Lattice C library plus special libraries for graphics,
database, communications, screen management, and OS/2 API functions.
The Lattice C Compiler offers more than 100 command line options that give you complete
control and unmatched versatility to tailor the compiler for your exact needs.
Configuration files let you can take advantage of this extra power without extra work. Get
up to speed as fast as possible with Lattice's automated installation, numerous sample
files and examples, plus comprehensive four-volume documentation in convenient binders
that stay open while you work.
Lattice supplies a total programming environment so you won't need to make any other
purchases. The Lattice C Development System provides an extensive set of utilities including:
Integrated,
Programmable Screen Editor
Overlay Linker
Macro Assembler
Object Module Disassembler
Object Module Librarian
Make Utility
BIND Utility
Cross Reference Generator
EXTRACT & BUILD
batch file utilities
DIFF compare utility
FILES locator
GREP search and print
SPLAT search and replace
TOUCH file attribute editor
WC Word Count
Lattice provides a complete programming environment with ALL the tools
you need including:
Multiple source
members, each with a different syntax format, which may be opened. For example, you can
open the RPG and DDS members for external files to compare field name usage
Lattice Optimizing
C Compiler
CodePRobe Source-Level,
Native & Cross Debugger
LSE Integrated,
Programmable Screen Editor
Lattice Overlay Linker
Macro Assembler
Object Module Disassembler
Object Module Librarian
Make Utility
Expanded Standard
Lattice C Library
Lattice Curses Screen
Management Library
Lattice Communications Library
Graphics Library
dBC III Database Library
API Library and BIND Utility
Cross Reference Generator
Automatic Installation Program
Program Maintenance
& File Management Utilities
Extensive Header &
Macro Files
Helpful Sample Programs
& Examples
Comprehensive
Four-Volume Documentation
Enjoy New Levels Of Speed
Benchmarks prove that Lattice C produces consistently faster, smaller executable
programs. With new features and options, the Lattice C Compiler lets you take advantage of
the very latest compiler technology.
Code-Enhancing Global
Optimizer speeds your programs up to 30%! The Lattice global optimizer analyzes your
program to perform one or more of its many code-enhancing operations whenever beneficial.
Optimizing techniques employed including:
- Convert functions to in-line code
- Assign variables to registers for all or part of their lifetime according to usage.
- Eliminate stores of values which are never fetched
- Eliminate code with values that are not used
- Eliminate recalculation of values that have been previously computed
- Move calculations outside a loop when they are the same on each iteration
- Eliminate unused auto variables
The global optimizer also employs many other optimizing techniques beyond these listed
to make your programs as efficient as possible. In addition, you can direct the compiler
to enhance your program for either optimum program size or execution speed.
Automatic Register
Variable Support ensures that your programs have the fastest access to function variables.
Special keywords also allow you to declare which variables will be placed in registers.
Built-In Function
Support makes your programs smaller and faster by having the compiler perform many
functions in-line to reduce the need for library calls. Built-in functions include:
- strlen
- memcpy
- emchr
- memset
- inp
- outp
- STI
- CLI
The inline keyword lets you create your own built-in functions for operations you want
the compiler to perform without calling a library routine.
Support for Mixed
Memory Models lets you select your program's best combination of size, speed, and
addressability by allowing you to link and run program modules that have been compiled
under different memory models. Lattice supports five memory models: Small Program and Data
Model , Large Program Model, Large Data Model, Large Program and Data Model, and the Huge
Model. In addition to these memory models, Lattice provides the near and far keywords and
compiler switches that let you select the most efficient pointer manipulations within your
program modules.
New Optimized Libraries
and faster floating point functions give you the fastest possible program execution.
Get up to speed quickly
with Comprehensive, Four-Volume Documentation that is thoroughly indexed and organized to
help you find and grasp information easily. Because the manuals are in ring binders, they
stay open on your desk for quick reference while you work.
Lattice's automatic
installation procedure configures the compiler, yet it allows you to specify
configurations unique to your system.
Accelerate Program Debugging
The CodePRobe source level debugger speeds your work with its powerful, easy-to-use
features. You can single-step through programs, set breakpoints, examine and change
variables, display memory, view and manipulate register data, and more. You can use
CodePRobe to continuously watch any C variable, array element, or structure member; assign
a value to C variables; fill an area of memory with values according to the type of
objects occupying that memory; copy one C array or structure to another; copy a string
from one place to another; and much more.
Menu or Command Modes
let you debug in a style that suits you best. Menus support a mouse or accelerator keys
for fast selection and execution.
Cross Debugging Support
eliminates memory constraints by letting you find bugs in large programs using CodePRobe
remotely from a different PC.
Independent Display
Windows simultaneously show your code, a dialog box, register contents, and selected
variables. Each window can be independently resized, scrolled, overlapped, and moved.
Command Logging lets
you repeat commands without repeating keystrokes.
On-Line Help with
useful examples gives you easy access to CodePRobe's many special features.
Three Display Modes let
you view your C source code, assembly language code or both.
Wield Power With Finesse
Lattice provides the most flexible development system possible. The Lattice C Compiler,
Assembler, Linker, Debugger, Editor, and all Utilities run under both DOS and OS/2 and
allow you to generate DOS, OS/2 or Family Mode programs. Because Lattice supplies the
bindings and header files, you do not need to purchase an expensive OS/2 development kit.
In addition, Lattice provides:
100% ANSI Compatibility
of the compiler and libraries that ensures your programs will be able to take advantage of
a large selection of add-in products and libraries as well as future compiler technology advances.
Language Extensions
that give you added power to tailor your programs for specific environments and embedded
systems applications. Special keywords provided include:
- private-defines data that must be replicated for each execution thread
- critical-defines a function that must run as a critical section
- inline-lets you create your own built-in functions
- interrupt-simplifies the development of DOS interrupt handlers and TSR programs
More Than 100 Compiler
Command Line Options that let you specify all details of the compiler's performance.
Frequently-used command line options can be stored in a configuration file to save time
and effort in later compilations. Command line switches give you tremendous flexibility.
Among other controls, you can:
- change the default padding and alignment options
- allow the compiler to continue with the next source file when a fatal error is reported
- allow deviations from the ANSI C language standard
- activate the debugging mode when no variable field is given
- define preprocessor symbols as if they had been included in the source file
- generate in-line 8087 or 80287 floating point operations
- produce files with function prototypes
- set whether the compiler will generate DOS, Family Mode, OS/2, OS/2 PM, or Rommable code
- automatically invoke the Lattice linker
- cause the compiler to compile only source files which are newer than the corresponding
object files
- automatically insert object modules into a library file
- change the default segment names generated by the compiler
- undefine all preprocessor symbols that are normally predefined by the compiler
Compiler switches can be entered in any combination on the command line, and all your
frequently-used command line options can be stored in a configuration file to save you
time and effort in later compilations. Selection an option by using a "-!"
before that switch causes the compiler to do the opposite of that option -- thereby giving
you an easy method to override the selections in your configuration file.
Create Programs Faster With The Largest Set Of Library Functions
The Lattice C Development System for DOS & OS/2 includes more than 800 C Library
Functions! No other compiler package includes more pre-written functions. You save many
hours of time using functions that Lattice programmers have already written, debugged, and
refined. The standard Lattice C library includes many functions for:
Character and
String Manipulation
Date and Time Manipulation
Formatted I/O
Stream I/O
Low-Level I/O
Console and Port I/O
Data Conversion and
Formatting
Searching and Sorting
Process Control
Hardware Testing
Pointer Validation and
Manipulation
Memory Management
Argument Processing
File System Manipulation
DOS and OS/2 Interface
Address Manipulation
PC BIOS Functions
Many library functions have been rewritten and all library functions have been
recompiled using Lattice's new global optimizer to give you the fastest possible program
execution. In addition, Lattice provides:
Special Libraries that
make it easier than ever to add new capabilities to your applications.
- GFX Graphics Library lets you take advantage of Hercules, CGA, MDA, EGA, and VGA
graphics cards for creating and manipulating graphic images as well as opening movable
windows for graphic work.
- dBC III Database Library lets you create, access, and update files that are compatible
with dBASE III. dBC III includes all the functions you need to create complete ISAM
database programs.
- Lattice Communications Library lets you add asynchronous communications to your
applications. The library includes functions that provide complete control of the
computer's serial ports as well as high-level functions for popular file transfer
protocols.
- Curses Screen Management Library Curses lets you write text to a Unix System V
compatible virtual screen, move the cursor, scroll the screen,m overlay screens, outline,
insert, delete, clear, highlight, and much more.
Optionally available
Source Code so you can examine the inner workings of the library functions or add
customized functions that tailor the library for your specific requirements, compiler, or
operating system.
Multi-Threaded
Libraries to give you re-entrant functions for your OS/2 applications.
Dynamic Link Library
Support which allows you to create your own dynamic link libraries for smaller OS/2 programs.
Object Module Librarian
that lets you create and manage your custom libraries.
No Other Tools Needed
All the powerful programming tools you need are included in the Lattice C Development
System for DOS & OS/2. All Lattice tools are designed with the features used most by
professional programmers to automate file handling and other programming-related tasks:
Integrated Lattice
Screen Editor (LSE) has all the powerful editing capabilities plus it is completely
programmable so you can customize the editor to adapt any keystroke, menu, help message,
or prompt to fit your preference. In addition, you can compile your source files from
within LSE. On errors, the compiler will stop and display any error messages with the
cursor positioned on the offending line to let you make immediate corrections. Or you can
save all error messages and LSE will automatically match them with the source code.
Overlay Linker converts
your object files into executable DOS, OS/2, or Family Mode programs. Lattice's linker
gives you many options including the ability to create true overlays, insert or remove
debugging information, output map files and much more.
LASM Lattice Macro
Assembler is a fast, full-featured Assembler for the assembly language modules. Output is
compatible with CodePRobe so you can also debug assembly language programs at source level.
LMK Lattice Make
Utility automates project management and guarantees that all the correct files are
compiled with the correct options whenever changes are made in any of a complex application's modules.
API Library and BIND
Utility let you create family mode applications without requiring the purchase of a
separate OS/2 programmer's toolkit.
File Management
Utilities save hours of time and reduce the possibilities for errors. UNIX-like utilities
include: EXTRACT, BUILD, DIFF, FILES, GREP, SPLAT, TOUCH, CXREF, and WC.
Requirements
CPU IBM PC, XT,
AT, PS/2 or 100% compatible
Operating System
MS-DOS or PC-DOS Ver. 2.1 or later; OS/2 Ver. 1.0 or later
Memory DOS: 512
KB minimum; OS/2: 2.5 MB minimum
Hard disk recommended
|