The GPE (Graphics Programming Environment) is pivotal to all dw-2000 modules since it is used within our product architecture to link every aspect of dw-2000. Many Layout Editor commands are in fact the assembly of basic GPE commands. As a user, you benefit from this because you can assemble GPE commands and therefore easily create your own custom commands. These commands, in turn, can be invoked by typing them, or by installing them into the application menus or in static menus. Where a design phase requires repetitive editing, it is sometimes faster and certainly more convenient to write and execute a program consisting of a series of GPE commands, rather than manually carrying out the repetitions.

In essence, the GPE was created with two objectives in mind: to perform powerful tasks and to minimize the amount of code writing needed to create such programs. For applications requiring a deeper control, an optional module is available to enable you to integrate "C" programs as well as create your own custom Graphical User Interfaces (GUIs).

Programs created with the GPE can also be saved as objects, therefore hiding away the source code. This is helpful for users wishing to create and share their own GPE applications while protecting the associated Intellectual Property (IP).

Editor and Compiler

Working with the GPE involves the writing of program scripts (or texts). A text editor is supplied with the GPE, but you can use any editor that produces unformatted ASCII text. The GPE programs are then compiled, meaning that once they are loaded, the original text is no longer needed. Instead, objects (chunks of binary code) are generated and can be either saved or executed. dw-2000 supplies a browser to manage the various GPE programs.

Command Line Interpreter

Another important aspect of the GPE is its ability to interpret typed command lines. A command line can be the name of a GPE or user command, or it can be a full expression. For example, you could type: "SCALE (sin 45) * 2". In this example, the SCALE command would execute and use as a parameter the evaluation of "(sin 45) * 2".

Run-Time Library

Programs written in the GPE can be made with an infinite number of combinations. These programs can be as simple as writing every command you want to execute as a sequence, to more complex constructions involving decisions, calculations and user interaction. The GPE supplies you a rich collection of run-time elements, varying from data query commands to database manipulations. Each supplementary module such as XDRC and HLVS supplies its own set of run-time executable elements. The net result is that the very same environment used to create a simple Layout Editor macro program can be used to create a complex DRC verification script or a Layout extraction.

Advanced GPE Extensions

The optional Advanced GPE Extensions was designed for users whose applications require a deeper level of programming and consists of two parts: the C Developer's Kit and the Dialog Module interface.

C Developer's Kit

The C Developer's Kit is designed for users who want to modify existing C programs or write new ones to take full advantage of the high performance of a combined (dw-2000 and C) environment for automatic layout generation. To accommodate this, the Kit provides C programs access to a group of GPE commands.

The dw-2000 C Developer's Kit contains an Application Programming Interface or API, which acts as an interface between the user's C executables and the dw-2000 kernel. These C "executables" or Shared Libraries (also known as DLLs on the Windows and "code fragments" on the Power PC), can contain calls to a group of exported C functions in this API which in turn access a group of GPE commands ? commands which can be used to create the physical layout of an entire integrated circuit. Once loaded into dw-2000, the user's Shared Libraries can be run like any GPE program thereby making GPE programming and the power of dw-2000 immediately accessible to experienced C programmers.

Dialog Module Interface

The Dialog Module interface is a collection of GPE commands that allows you to create GUIs (Graphical User Interfaces) from GPE programs. You can create both modal and modeless windows, and each type of interface window can support buttons, lists, editable and static text fields, pull-down menus, etc. The Dialog module has been designed so that the actual creation of the dialog is done at run time rather than at compile time, with the effective result that GPE-defined dialogs look good on any platform. This offers big time savings for interface creators whose GPE applications are required to be portable. Like any other GPE programs, those containing dialogs can be assigned a place in the dw-2000 menus or remain resident until called by the user or another GPE program.

GPE Features:

• Application-level programming
  
• IP protection
  
• Rich run-time library
  
• Integrated editor, compiler
  
• Command Line interpreter
  
• Access to every part of dw-2000
  
• Expandable to C functions
  
• Ability to create cross-platform GUIs