Form T138-0594 POSXBIND.TXT Available Ada Bindings Portable Operating System Interface for Computer Environments (POSIX) Guest editor: David Emery, The MITRE Corporation, Burlington Road, Bedford, MA 01730; tel: 617/271-2815; e-mail: emery@mitre.org 6.1 Description and standardization efforts The POSIX Program The Portable Operating System Interface for Computer Environments (POSIX) is the collective name for a set of standards providing applications portability at the source-code level. Most POSIX standards define either an Application Program Interface (API) or a Profile -- which can be used by an applications programmer to write portable applications. An API is a specification of types, operations, etc, to be used by an applications program, along with their associated semantics. A Profile selects one or more standards and identifies options, restrictions, interoperability, etc, to support a specific applications domain. The POSIX program grew from the effort by Unix users to develop a "standard" definition of the Unix system interface. The Institute of Electrical and Electronics Engineers (IEEE) Computer Society's Technical Committee on Operating Systems started work on this project in the 1985-1986 time frame. Later, the International Organization for Standardization/International Electrotechnical Commission (ISO/IEC) decided to provide international standardization for POSIX standards, delegating the development work to the existing IEEE group. Currently, the IEEE group is the Portable Applications Standards Committee (PASC), and the ISO/IEC group is Working Group 15 of Subcommittee 22 of Joint Technical Committee 1 (ISO/IEC JTC1 SC22 WG15). Generally, POSIX standards are developed by a working group within PASC, and submitted for concurrent IEEE and ISO/IEC ballots. The intent is to have a single document as both an IEEE and an ISO/IEC standard. There are many different POSIX projects currently under way. To date, six POSIX standards have been adopted by the IEEE. These are: * IEEE Std 1003.1-1990, IEEE Standard for Information Technology -- Portable Operating System Interface (POSIX) -- Part 1: System Application Program Interface (API), POSIX Basic System Services * IEEE Std 1003.2-1992, IEEE Standard for Information Technology -- Portable Operating System Interface (POSIX) -- Part 2: Shell and Utilities. * IEEE Std 1003.3-1991, IEEE Standard for Information Technology -- Test Methods for Measuring Conformance to POSIX. * IEEE Std 1003.3.1-1992, IEEE Standard for Information Technology -- Test Methods for Measuring Conformance to POSIX -- Part 1: System Interfaces. * IEEE Std 1003.5-1992, IEEE Standard for Information Technology -- POSIX Ada Language Interfaces -- Part 1: Binding for System Application Program Interface (API). * IEEE Std 1003.9-1992, IEEE Standard for Information Technology -- POSIX Fortran 77 Language Interfaces -- Part 1: Binding for System Application Program Interface (API). Other projects are in varying stages of development, including P1003.4 for real-time extensions, P1003.6 for system security, P1003.7 for system administration, P1003.8 for network file access, P1003.10 for supercomputing profile, P1003.12 for protocol-independent networking, P1003.13 for real-time profile, and at least 10 other projects. Some (but not all) of the IEEE standards are also ISO/IEC standards. IEEE Std 1003.1 has been adopted by ISO/IEC as ISO 9945-1, and IEEE Std 1003.2 has been adopted by ISO/IEC as ISO 9945-2. The National Institute for Standards and Technology (NIST) has also adopted POSIX as a Federal Information Processing Standard (FIPS). However, there has been a problem with the FIPS and the IEEE/ISO Standards. IEEE 1003.1 has undergone several revisions since it was first approved by the IEEE in 1988. The current version is ISO/IEC 9945-1:1989/IEEE Std 1003.1-1990, which corresponds to FIPS 151-1. However, a revision to the IEEE/ISO standard is underway. The problem is that the approval cycle for FIPS is not synchronized with the approval cycle for IEEE/ISO POSIX standards. In general, FIPS approval has lagged behind IEEE/ISO approval by at least one year. Ada Bindings Initially, because of its Unix heritage, POSIX API standards were specified in terms of the C language. However, as the POSIX effort grew, it became clear that other languages besides C could make effective use of the POSIX APIs. Projects to develop Ada and FORTRAN bindings were approved around 1986. PASC Working Group P1003.5 was chartered to develop Ada bindings for POSIX standards, with its first project being the Ada binding to IEEE 1003.1. The P1003.5 Working Group made several initial decisions that influenced the resulting document. The group decided that it was inappropriate for the Ada binding to depend on the C binding, so IEEE Std. 1003.5 was specified as a self-contained "thick" binding document. (The alternative, a "thin binding document", would have contained pointers to text in IEEE Std. 1003.1). The other major decision was to provide Ada abstractions for the facilities in IEEE Std. 1003.1, rather than provide direct Ada analogs to each and every C type and function. The IEEE approved IEEE Std. 1003.5 in July 1992. Due to a disagreement between the IEEE and ISO/IEC on how language bindings would be described, IEEE Std. 1003.5 was not initially accepted by ISO/IEC JTC1/SC22/WG15 for ISO/IEC standardization. However, IEEE Std. 1003.5 is now being submitted to ISO/IEC for standardization using a "fast-track" approach, and ISO/IEC standardization is likely in 1993. The IEEE standard is available from the IEEE as document #SH 15354, from the IEEE Services Center, 445 Hoes Lane, Piscataway, NJ 08855, 800/678-4333. IEEE Std. 1003.5 represents only one of many possible Ada bindings for IEEE standards. PASC Working Group P1003.5 is currently working on Ada bindings for the POSIX Real-Time standards, IEEE Projects P1003.4 (real-time extensions), and P1003.4a (threads extensions). The Ada Real-Time bindings project is IEEE P1003.20, and an Ada binding to the facilities in P1003.4 has entered IEEE ballot. This work is being synchronized with both POSIX developments, including balloting of both IEEE P1003.4 and P1003.4a, as well as with Ada 9X and related ISO Ada work. An overview of IEEE Std. 1003.5-1992 IEEE Std. 1003.5-1992 (commonly called POSIX/Ada) provides an Ada programer with access to operating-system services in the area of process control, process environment (including command line parameters), files and input/output (I/O), terminal devices and serial line control, and user and group databases. The binding is organized as a series of packages, where each package provides access to a set of related services. For instance, facilities for controlling files are contained in the package POSIX_FILES, and the POSIX I/O operations are defined in package POSIX_IO. To avoid library-level name conflicts with user packages, all of the POSIX packages begin with "POSIX_" (except for the one package called "POSIX"). The package POSIX contains several common definitions for the binding, including the type POSIX_CHARACTER. An implementation may provide a character set (such as EBCDIC or IBM-PC character sets) that is different from Ada's predefined set. The type POSIX_CHARACTER allows access to the host environment's character set. The standard defines an interoperable subset of characters that are in both Ada's STANDARD.CHARACTER and POSIX.POSIX_CHARACTER. This package also defines various parameters on the POSIX implementation, such as the maximum number of open file descriptors and the maximum length of a filename. Error handling is an important part of any binding. Errors are generally reported back to the user via the exception POSIX.POSIX_ERROR. The type POSIX.ERROR_CODE represents the predefined error conditions, such as FILE_EXISTS or PERMISSION_DENIED. When POSIX_ERROR is raised by the call to a POSIX operation, the program can call POSIX.GET_ERROR_CODE to retrieve the error code associated with the failed operation. Error status is kept on a per-task basis, to prevent race conditions between the call to a POSIX operation that fails and the call to GET_ERROR_CODE within a single task. POSIX models the entire Ada program as a single POSIX process. For instance, all calls to POSIX_PROCESS_IDENTIFICATION.GET_PROCESS_ID from tasks within the same main program must return the same process ID. However, this does not prevent implementations from using multiple processes to support Ada tasking, as long as this does not change the behavior of POSIX/Ada operations. Tasking safety was a major concern of the P1003.5 Working Group. In general, POSIX/Ada operations are required to be "reentrant" in the face of tasks. For instance, two calls to POSIX_IO.WRITE should not interfere with each other. (One should be completed before the other starts.) However, POSIX/Ada does not guarantee task-related blocking semantics. If one task performs I/O, the entire process/program may be blocked. The basic definition of POSIX (IEEE Std. 1003.1:1990) does not provide sufficient functionality for POSIX/Ada to require or specify per-task blocking for I/O and other blocking situations. POSIX/Ada does provide a facility that allows the program to determine if the entire program/process or just the calling task will be blocked when doing I/O. A "smart" program can modify its behavior depending on the facilities provided by the implementation. The IEEE Standard contains a very detailed rationale explaining the the reasoning and analysis that led to the final shape of the binding. The rationale discusses most of the issues that confront any binding developer, including packaging, documentation style (e.g., "thick" vs "thin") and tasking safety. Conformance Issues POSIX conformance is defined both for implementations and for applications. Implementation conformance basically means that the implementation correctly implements the POSIX API and its semantics. Application conformance means that the application uses only facilities defined within POSIX or other IEEE or ISO standards. In particular, a strictly conforming POSIX application may not use implementation extensions to POSIX. IEEE Std. 1003.5 places specific restrictions on conforming implementations. A conforming implementation has to implement the API as defined by the standard -- i.e., POSIX_IO.OPEN has to work as described, etc. Since POSIX portability is defined at the source-code level, IEEE Std. 1003.5 places restrictions on an implementation's actual definition of the standard POSIX packages. For instance, an implementation may not add an operation to the visible part of a standard package. The intent of these restrictions is to make sure that applications code can be moved from one conforming implementation to another without encountering compiler errors due to inadvertent overloading, etc. Currently there is no test suite to measure implementation conformance to IEEE Std. 1003.5. (NIST has certified several test suites for measuring conformance for the C binding, IEEE Std. 1003.1.) Also, it is possible for an implementor to provide an interface to POSIX that does not claim conformance to IEEE Std. 1003.5. Finally, it is quite possible for a system to claim "POSIX conformance" because it conforms to the IEEE 1003.1 (or 1003.9) standard, but no Ada binding is provided. Therefore, when specifying or discussing "POSIX compliance", it is important to ensure that the system provides a conforming implementation of IEEE Std. 1003.5. An implementation that claims conformance only to IEEE Std. 1003.1 will not be of much use for Ada programming. Some available resources Ada Interfaces to POSIX This report considers the appiicability of POSIX in the development of the Defense Department's Software Technology for Adaptable Reliable Systems (STARS) Software Engineering Environment, comparing it to the Common APSE Interface Set, version A (CAIS-A). (This report is available from ASSET as ASSET_A_155. For more information on ASSET, see Appendix C.) The POSIX/Ada Binding Tutorial A tutorial on IEEE Std. 1003.5-1992 was presented at the Tri-Ada 1992 and Tri-Ada 1993 conferences, as well as Ada Europe 1993 and Ada UK 1992. Copies of the tutorial slides were printed in the Tri-Ada tutorial proceedings document. A Prototype Implementation of the POSIX/Ada Binding A paper on a prototype of an early verion of POSIX/Ada was presented by David Emery at Tri-Ada 1990. A copy of this paper can be found in the Tri-Ada 1990 proceedings. The paper describes techniques used to implement POSIX/Ada via pragma interface calls to the POSIX C library. 6.2 POSIX resources available from repositories/software-reuse libraries Note: You may also wish to see Section 10, Other Specifications and Standards, for the references to the "Ada/Operating System Interface", which provides tools to interface between Ada and an operating system. The package is modeled on the POSIX interface for AIX but may be implemented on other environments as well. 6.2.1 The Ada Joint Program Office host computer on the Internet The following information was taken from files on the Ada Joint Program Office's host computer (ajpo.sei.cmu.edu). A file name and subdirectory are noted at the beginning of each reference. For more information on the AJPO host, see Appendix C. POSIX Ada Language Interfaces -- package specifications This file: ajpo.sei.cmu.edu/public/dev-tool/POSIX/README Last updated: 11/5/93 The following statement is provided by the IEEE and governs the use of this code: These package specifications were extracted from IEEE Std 1003.5-1992, IEEE Standard for Information Technology -- POSIX Ada Language Interfaces -- Part 1: Binding System Application Program Interface, copyright (c) 1992 by the Institute of Electrical and Electronics Engineers, Inc. These package specifications represent only a portion of the document and are not to be interpreteted as the approved consensus standard. The IEEE Std 1003.5-1992 must be used in conjunction with these package specifications in order to claim conformance. The IEEE takes no responsibility for and will assume no liability for damages resulting from the reader's misinterpretation of said information resulting from its out of context nature. To order copies of the IEEE Std 1003.5-1992, please contact the IEEE Service Center at 445 Hoes Lane, PO Box 1331, Piscataway, NJ 08855-1331; via phone at 1-800-678-IEEE, 908-981-1393; or via fax at 908-981-9667. Note that these specifications are incomplete, in that the standard identifies some declarations as implementation-defined. In addition, no package bodies are provided. This standard was developed by IEEE Working Group P1003.5. For more information on this group, contact the Chairman, James Lonjers, lonjers@vfl.paramax.com or (805) 987-9457. Formal requests for interpretations of this standard should be addressed to the IEEE, as specified in the document. An e-mail list discussing ongoing POSIX/Ada binding work is available as "posix-ada@verdix.com". Send e-mail to "posix-ada-request@verdix.com" to be included on the list. Current work in IEEE P1003.5 consists of the Ada Binding to POSIX Real-Time Extensions (IEEE Project P1003.20) and current interpretations of IEEE Std 1003.5-1992. File names and size in bytes are: README (2402); calendar.a (2968); file_lck.a (2157); file_lim.a (4142); file_sta.a (3112); files.a (4396); group_db.a (2383); permiss.a (2947); posix.a (12759); posix_io.a (5963); prims.a (4677); proc_env.a (3818); proc_id.a (3716); proc_prm.a (6529); proc_time.a (2009); signals.a (7734); supp_io.a (3160); sys_limit.a (2075); terminal.a (7676); unsafe.a (2253); user_db.a (2188); and posixada.zip (27192) POSIX Ada Run-Time System Librarys (PART) This file: ajpo.sei.cmu.edu: /public/atip/PART_pointer Last updated 9/10/93 This is a pointer file to the POSIX Ada Run-Time System Librarys (PART), which contains code from one of the projects supported by the Ada Joint Program Office's FY91 Ada Technology Insertion Program (ATIP). PART is available to the public from Florida State University (FSU) for non-commercial use. See copyright note near end. PART can be obtained by anonymous FTP from FSU's ftp server (ftp.cs.fsu.edu). PART Version 1.2: Release on ftp The POSIX / Ada-Runtime project is happy to announce that the sources of the POSIX Ada Run-Time System Librarys (PART) are now available to the public for non-commercial use (see copyright). ftp-site: ftp.cs.fsu.edu internet#: 128.186.121.27 directory: /pub/PART files: part.tar.Z, part_README Related publications as well as an implementation of POSIX threads are also available on this site in the mentioned directory (see file INDEX). What is PART? This is version 1.2 of the POSIX Ada Run-Time System Library (PART) using a CARTS interface [3]. It is implemented over the POSIX 1003.4a Threads Extension (Pthreads) [1], and requires access to an interface compliant with that standard. The purpose of this release of PART is to demonstrate the feasibility of implementing an Ada '83 run-time system over POSIX threads, and disclose the full details of one such implementation. By mapping Ada tasks onto POSIX threads, this approach should enhance the portability of Ada runtime systems and provide a platform for exploiting shared-memory multiprocessors. The interface between PART and an Ada compiler is a procedural interface using link-time entries via an external name pragma. The interface is mostly CARTS compliant. Nevertheless, a number of small extensions to the CARTS interface have been added, to allow interaction with a commercial Ada compiler and to provide a base for subsequent extensions such as for Ada 9X. PART has been tested at FSU using a commercial Ada compiler. The specific interface code (glue) to this commercial compiler is NOT part of this release. Also excluded from this release are the bodies of certain machine- and compiler-dependent packages used by the runtime implementation: Compiler_Exceptions, Machine_Specifics, and Compiler_Dependencies. In the testing done at FSU, this release of PART passed the Chapter 9 portion of the ACVC 1.11 validation suite. PART has only been tested on SunOS running on a SPARCstation, using a library to supply the required Pthreads support. This library is available from the Florida State University by anonymous ftp from ftp.cs.fsu.edu in /pub/PART and is documented in the literature [5]. PART accesses Pthreads operations through a C interface using INTERFACE pragmas. Use of PART on other Pthreads compliant platforms should be possible provided that they can provide all Pthreads operations as procedure calls. Nevertheless, PART is distributed without any warranty, expressed or implied, including warranty of merchantability or fitness for any particular purpose. PART is based on previous Ada runtime systems developed at FSU, including CORSET/LACE [6,7], which was developed with funds from Boeing, and MRTSI [2], which was partially funded by the HQ U.S. Army CECOM, Software Engineering Directorate. The PART runtime system-to-compiler interface is based on the CARTS interface [3], which was derived from the experience gained with MRTSI. Most of the PART code was produced by FSU students and faculty under the POSIX/Ada Real-Time (PART) project, funded by the Ada Joint Program Office (AJPO) under the Ada Technology Insertion Program (ATIP), through the U.S. CECOM, Software Engineering Directorate, subcontracted through the Telos Corporation. See the separate file "AJPO.DISCLAIMER" for general term and conditions applicable to software developed under the AJPO's ATIP. PART project members have included Ted Baker (Principal Investigator), Ted Giering (Chief Programmer), Pratit Santiprabhob (Research Associate), Offer Pazy (Consultant), and Ganesh Rangarajan, R. Ramesh, Frank Mueller, Teguh Ghazalie, Viresh Rustagi, and Seung-jin Moon (Graduate Research Assistants). This software contains known bugs. The user assumes all risks associated with its use. Further Information For information on the CARTS interface, contact solomon@eclus.bwi.wec.com. For information on availability of the PART project final report, contact mbender@ajpo.sei.cmu.edu. References [1] Threads Extension for Portable Operating Systems (Draft 6). IEEE, Feb 26, 1992, P1003.4a/D6. [2] Ada Runtime Environment Working Group: MRTSI Task Force. A Model Runtime System Interface for Ada. By ACM SIGAda, 1990. Technical Report. [3] T.P. Baker. Requirements Specification for the Common Ada Run-Time System. February 1991. Prepared for Westinghouse Electric Corporation. [4] E.W. Giering, T.P. Baker. Using POSIX Threads to Implement Ada Tasking: Description of Work in Progress. In TRI-Ada '92 Proceedings, November 1992. p. 518-529. [5] Frank Mueller. A Library Implementation of POSIX Threads under UNIX. In Proceedings of the USENIX Conference, Winter 1993. p. 29-41. [6] T.P. Baker. A Corset for Ada. Technical Report TR-86-09-06, Computer Science Department, University of Washington, 1986. [7] T.P. Baker and K. Jeffay. Corset and Lace: Adapting Ada Runtime Support to Real-Time Systems. Proceedings of the Real-Time Systems Symposium, December, 1987. pp. 158-169. [Note: The AJPO file from which the text above was taken also contains disclaimers from both the AJPO and FSU stating such things as that the software is distributed "as-is", without any warranty expressed or implied, and that general permission to copy and distribute the code is granted provided that this is not done for commercial advantage.] 6.2.2 AdaNet The following abstracts were taken from AdaNet, and describe software available in source-code form. For more information on AdaNet, see Appendix C. Title: POSIX Ada Run-Time System Librarys (PART) This is the POSIX Ada Run-Time System Library (PART) using a CARTS interface. It is implemented over the POSIX 1003.4a Threads Extension (Pthreads), and requires access to an interface compliant with that standard. The purpose of this release of PART is to demonstrate the feasibility of implementing an Ada '83 run-time system over POSIX threads, and disclose the full details of one such implementation. By mapping Ada tasks onto POSIX threads, this approach should enhance the portability of Ada runtime systems and provide a platform for exploiting shared-memory multiprocessors. 6.2.3 Asset Source for Software Engineering Technology (ASSET) The following information was taken from the ASSET Library Repository Catalog. For more information on ASSET, see Appendix C. POSIX/Ada Interface Specifications Order Number: ASSET_A_395 Alternate Name: ADA/POSIX BINDINGS Version: OCT 93 Release Date: 01-OCT-93 Producer: IEEE Author: IEEE Working Group P1003.5 Reference: IEEE Standard 1003.5-1992 Asset Type: SOFTWARE - BUNDLE Size: 132 Kbytes, 22 Files Domains: ADA STANDARDS AND BINDINGS Keywords: ADA, BINDING, IEEE, INTERFACE, POSIX, STANDARD Distribution: Approved for public release, distribution is unlimited This asset contains Ada package specifications for a binding to POSIX which conforms to the IEEE standard. These package specifications were extracted from IEEE Std 1003.5-1992, IEEE Standard for Information Technology--POSIX Ada Language Interfaces--Part 1: Binding System Application Program Interface, copyright 1992 by the Institute of Electrical and Electronics Engineers, Inc. These package specifications represent only a portion of the document and are not to be interpreteted as the approved consensus standard. The IEEE Std 1003.5-1992 must be used in conjunction with these package specifications in order to claim conformance. Note that these specifications are incomplete, in that the standard identifies some declarations as implementation-defined. In addition, no package bodies are provided. 6.3 POSIX products available from vendors AETECH, Inc. Available Ada bindings for AETECH Ada compilers: Microsoft Windows, PHIGS, POSIX, SQL (Supra), X-Windows (Motif, Open Look). Host/Target: 80386 (& 80486) PCs. For more information, contact: Jim Dorman, AETECH, Inc., 5841 Edison Place, Suite 110, Carlsbad, CA 92008, USA; tel: 619/431-7714; fax: 619/431-0860. Alsys, Inc. The Alsys Ada Software Development Environment for 386 UNIX is a production-quality Ada environment capable of handling very large Ada applications (over 500,000 lines of code). The product includes the Compiler; Multi-Library Environment, which provides a powerful and flexible way to manage Ada development effort and share program units; Binder, which supports unused subprograms elimination; High- and Low-Level Optimizers for improving code quality and performance; and Run-Time Executive for efficient support for executing Ada programs. Also included is the Developer's Toolset including: Ada Probe, a symbolic source-level debugger and program viewer; AdaXref, a cross-reference generator; AdaMake, a recompilation aid; AdaReformat, a source reformatter. Alsys currently has Ada bindings to POSIX, X-Windows (OSF Motif), and the Generic Package of Elementary Functions for the Alsys Ada Software Development Environment, running on 386 UNIX 386/486-based machines supported as both host and target and running 386/ix or SCO UNIX. They are also planning a binding to SQL for 386/486 machines. Host/Target: 386/486 PC under IX UNIX, 386/486 PC under SCO UNIX. Alsys' RISC Ada/SPARC is a complete Ada development and execution environment combining ease of use, excellent compilation and execution performance, powerful debugging and performance tuning capabilities, support for developing large applications and bindings to industry standards. It includes an X Window-based GUI, an optimizing Ada compiler, library manager and tools, the AdaTracer source-level debugger, the ARCS 2.0 Toolbox with graphical system browser, language-sensitive editor and other integrated tools, a dynamic application profiler for isolating performance bottlenecks and Ada bindings to Xview and POSIX. Optionally available are interfaces to X, OSF/Motif, Sybase, Oracle, and TCP/IP. Alsys' TeleGen2 Ada Host Development Systems contain fast, easy-to-use development tools to create Ada applications while generating efficient applications code. The tools include an Ada compiler with global optimizer, source-level debugger, profiler for dynamic analysis, source formatter, cross-reference, automatic system builders, library manager and tools, etc. Also included are interfaces to standards: POSIX, MacIntosh toolbox (Mac only), Sunview (Sun only), and NUMWG math libraries. For more information, contact: Alsys Sales, Alsys, Inc., 67 South Bedford Street, Burlington, MA 01803, USA; tel: 617/270-0030, fax: 617/270-6882, e-mail: marketing@alsys.com. Silicon Graphics, Inc. Silicon Graphics, Inc.'s (SGI's) MP/Ada 6.2 provides a multiprocess Ada development system built using the POSIX-compliant threads model for Ada tasking. A joint engineering development between Verdix and SGI, MP/Ada is designed to permit full use of SGI's multiprocessor technology and symmetric multiprocessing operating system. Ada tasks are mapped one-to-one with POSIX-compliant threads. These threads are executed dynamically by a pool of kernel processes that are further scheduled on all available processors (an M-by-N mapping). Since each task can be bound to an independent kernel process, all of SGI's REACT (realtime extensions to IRIX) capababilities are now accessible to Ada programs. Host/Target: SGI systems under IRIX 4.0.5, IRIX 5.0.1, IRIX 5.1. For more information, contact: David McAllister, Silicon Graphics, Inc., 2011 North Shoreline Boulevard, Mountain View, 94039-7311, USA; tel: 415/390-3238; fax: 415/390-6218; e-mail: davemc@sgi.com. SL Corporation SL Corporation provides Ada binding support for its SL-GMS toolkit; this includes support for GPEF, GPPF, POSIX, SQL, TCP/IP, OSF/Motif, and Open Look. SL-GMS is a toolkit for developing dynamic graphics screens for real-time or highly interactive applications. Non-programmers can design application screens in a standard drawing-tool mode, connect them to real-time data sources and animate screen objects to visualize changing data values. SL-GMS allows the design of custom "GISMOs" to input values or control the application and supports Motif, Open Look, and other X toolkit widgets. SL-GMS is used to provide real-time graphics for applications in the fields of manufacturing, process control, network management, avionics and financial tracking. Host/Target: Validated Verdix and DEC compilers support SL-GMS for the following machines as both host and target: DEC-DECstation/ULTRIX 4.0; DEC-VAXstation/ULTRIX 4.0; DEC-VAXstation/VMS 5.4; DEC-VAXstation/VMS 5.5; DEC Alpha PCs/Windows NT; IBM-RS6000/AIX; HP-9000/300/UNIX; HP-9000/400/UNIX; HP-9000/700/UNIX; HP-9000/800/UNIX; PC-386/IX UNIX; PC-386/SCO UNIX; PC-386/Lynx; PC-386/0S2; PC-386/System 5.4; SGI-4D/IRIX 3.3; Sun-3/SunOS 4.1; SunSPARC/SunOS 4.1 and Solaris; 88 Open/BCS Compliant; and Intel PCs/Windows NT. For more information, contact: Mike Meagher, SL Corporation, 240 Tamal Vista Boulevard, Corte Madera, CA 94926, USA; tel: 415/927-1724; fax: 415/927-0878. ***** The views, opinions, and findings contained in this report are those of the author(s) and should not be construed as an official Agency position, policy, or decision, unless so designated by other official documentation. Copyright 1995. IIT Research Institute. All rights assigned to the US Government (Ada Joint Program Office). Permission to reprint this flyer, in whole or in part, is granted, provided the AdaIC is acknowledged as the source. ***** Ada Information Clearinghouse(AdaIC) PO Box 1866 Falls Church, VA 22204 Telephone: 1-800-AdaIC-11, 1-800/232-4211 or 703/681-2466 Fax: 703/681-2869 Email: adainfo@sw-eng.falls-church.va.us The AdaIC is sponsored by the Ada Joint Program Office and operated by IIT Research Institute.