Lattice Logo Image Lattice Home Page Lattice Corporate Profile Products & Services Career Opportunities Search Site Site Map

Tools ImagePROGRAMMING TOOLS

Programming
Links


ES68 C
Compiler


Z80 C
Compiler


dbc III
Library


Comm
Library
DOS & OS/2 COMPILER

A Complete Programming Environment

Satellite Image
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:

BulletIntegrated, Programmable Screen Editor

BulletOverlay Linker

BulletMacro Assembler

BulletObject Module Disassembler

BulletObject Module Librarian

BulletMake Utility

BulletBIND Utility

BulletCross Reference Generator

BulletEXTRACT & BUILD batch file utilities

BulletDIFF compare utility

BulletFILES locator

BulletGREP search and print

BulletSPLAT search and replace

BulletTOUCH file attribute editor

BulletWC Word Count


Lattice provides a complete programming environment with ALL the tools you need including:

BulletMultiple 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

BulletLattice Optimizing C Compiler

BulletCodePRobe Source-Level, Native & Cross Debugger

BulletLSE Integrated, Programmable Screen Editor

BulletLattice Overlay Linker

BulletMacro Assembler

BulletObject Module Disassembler

BulletObject Module Librarian

BulletMake Utility

BulletExpanded Standard Lattice C Library

BulletLattice Curses Screen Management Library

BulletLattice Communications Library

BulletGraphics Library

BulletdBC III Database Library

BulletAPI Library and BIND Utility

BulletCross Reference Generator

BulletAutomatic Installation Program

BulletProgram Maintenance & File Management Utilities

BulletExtensive Header & Macro Files

BulletHelpful Sample Programs & Examples

BulletComprehensive 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.

BulletCode-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.

BulletAutomatic 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.

BulletBuilt-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.

BulletSupport 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.

BulletNew Optimized Libraries and faster floating point functions give you the fastest possible program execution.

BulletGet 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.

BulletLattice'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.

BulletMenu 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.

BulletCross Debugging Support eliminates memory constraints by letting you find bugs in large programs using CodePRobe remotely from a different PC.

BulletIndependent Display Windows simultaneously show your code, a dialog box, register contents, and selected variables. Each window can be independently resized, scrolled, overlapped, and moved.

BulletCommand Logging lets you repeat commands without repeating keystrokes.

BulletOn-Line Help with useful examples gives you easy access to CodePRobe's many special features.

BulletThree 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:

Bullet100% 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.

BulletLanguage 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
BulletMore 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:

BulletCharacter and String Manipulation

BulletDate and Time Manipulation

BulletFormatted I/O

BulletStream I/O

BulletLow-Level I/O

BulletConsole and Port I/O

BulletData Conversion and Formatting

BulletSearching and Sorting

BulletProcess Control

BulletHardware Testing

BulletPointer Validation and Manipulation

BulletMemory Management

BulletArgument Processing

BulletFile System Manipulation

BulletDOS and OS/2 Interface

BulletAddress Manipulation

BulletPC 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:

BulletSpecial 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.
BulletOptionally 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.

BulletMulti-Threaded Libraries to give you re-entrant functions for your OS/2 applications.

BulletDynamic Link Library Support which allows you to create your own dynamic link libraries for smaller OS/2 programs.

BulletObject 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:

BulletIntegrated 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.

BulletOverlay 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.

BulletLASM 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.

BulletLMK 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.

BulletAPI Library and BIND Utility let you create family mode applications without requiring the purchase of a separate OS/2 programmer's toolkit.

BulletFile 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

BulletCPU — IBM PC, XT, AT, PS/2 or 100% compatible

BulletOperating System — MS-DOS or PC-DOS Ver. 2.1 or later; OS/2 Ver. 1.0 or later

BulletMemory — DOS: 512 KB minimum; OS/2: 2.5 MB minimum

BulletHard disk recommended


Info Request ImageRequest Information


© 1998-2006 Lattice, Incorporated. All rights reserved. Top Of Page