[Date Prev] | [Thread Prev] | [Thread Next] | [Date Next] -- [Date Index] | [Thread Index] | [List Home]
Subject: RE: [docbook-apps] profile chunking
Thank you Jirka - it works.
Now my problem is I have the profiling attributes at the Chapter level; sect1 level, para level, programlisting level and also the informaltable level.
If I use the following attributes in my customization layer:
<xsl:template match="chapter[not(@os)]" mode="profile">
</xsl:template>
<xsl:template match="section[not(@os)]" mode="profile">
</xsl:template>
<xsl:template match="sect1[not(@os)]" mode="profile">
</xsl:template>
<xsl:template match="sect2[not(@os)]" mode="profile">
</xsl:template>
<xsl:template match="sect3[not(@os)]" mode="profile">
</xsl:template>
<xsl:template match="sect4[not(@os)]" mode="profile">
</xsl:template>
<xsl:template match="para[not(@os)]" mode="profile">
</xsl:template>
<xsl:template match="phrase[not(@os)]" mode="profile">
</xsl:template>
<xsl:template match="informaltable[not(@os)]" mode="profile">
</xsl:template>
<xsl:template match="programlisting[not(@os)]" mode="profile">
</xsl:template>
Then my problem is compounded if I have a profiling attribute of help at the lower level which could perhaps be a para. One more problem is the TOC.
I am giving you a sample of my input and output.
Please let me know if I have to change the way I am organizing my content.
Input:
programmersguide.xml
Output:
VMS.ZIP
Command I am using:
C:\>xsltproc --stringparam base.dir C:/htmltest/PG/VMS/ --stringparam profile.os
"VMS" --stringparam profile.condition "help" C:/e-novative_book_chunk.xsl progr
ammersguide.xml
I tweaked the e-novative stylesheets and remodelled them but left the name of xsl file as it is.
The reason I need to chunk the content that has the help attribute separately, is that I have about 30,000 lines of XML code out of which 10,000 lines will be shared code between VMS and UNIX manual and 10,000 lines UNIX specific with a split of probably 1000 lines common in UNIX help and UNIX manual; 2000 lines only UNIX help and the remaining UNIX manual. The same applies to VMS.
And I need to chunk the help XML preferably as a XML file (one each for VMS-help and UNIX-help) so I would prefer a 2-pass processing, in which case I can apply my customized stylesheet only after the first step. Hence, do you recommend I use the attribute customizations for the stylesheet at the first pass and the general stylesheet i.e., (e-novative_book_chunk.xsl ) at the second pass.
Please kindly recommend.
Appreciate your time.
Thanks & Regards,
Sarah
-----Original Message-----
From: Jirka Kosek [mailto:jirka@kosek.cz]
Sent: Tuesday, November 08, 2005 4:37 PM
To: SIRIGINA Saraswathi
Cc: Mauritz Jeanson; docbook-apps@lists.oasis-open.org
Subject: Re: [docbook-apps] profile chunking
SIRIGINA Saraswathi wrote:
> I tried to apply Mauritz's suggestions but then it gives me "ambiguous errors"
You are using single pass profiling probably (the stylesheet name is profile-xxx.xsl). Then add following template into your customization layer:
<xsl:template match="section[not(@os)]" mode="profile"> </xsl:template>
Please note added mode="profile"
Jirka
--
------------------------------------------------------------------
Jirka Kosek e-mail: jirka@kosek.cz http://www.kosek.cz
------------------------------------------------------------------
Profesionální školení a poradenství v oblasti technologií XML.
Podívejte se na náš nově spuštěný web http://DocBook.cz
Podrobný přehled školení http://xmlguru.cz/skoleni/
------------------------------------------------------------------
Nejbližší termíny školení: XML schémata (včetně RELAX NG) 7.-9.11.
*** DocBook 5.-7.12. *** XSL-FO 19.-20.12. ***
------------------------------------------------------------------
Confidentiality Statement:
This message is intended only for the individual or entity to which it is addressed. It may contain privileged, confidential information which is exempt from disclosure under applicable laws. If you are not the intended recipient, please note that you are strictly prohibited from disseminating or distributing this information (other than to the intended recipient) or copying this information. If you have received this communication in error, please notify us immediately by return email.
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE book SYSTEM "file:///c:/docbook44/docbookx.dtd">
<book><?dbhtml filename="index.html" ?>
<bookinfo>
<title>GT.M Programmer's Guide</title>
<pubdate>December 01, 2005</pubdate>
<copyright>
<year>2005</year>
<holder>Fidelity Information Services, Inc.</holder>
</copyright>
</bookinfo>
<preface><?dbhtml filename="preface.html" ?>
<title>About This Manual</title>
<para>The GT.M Programmer's Guide describes how to develop and maintain M applications using GT.M, the
Fidelity Information Systems' M language compiler and run-time system. For information on how to install
the GT.M software and maintain the user environment, refer to the GT.M Administration and Operations Guide.</para>
<sect1 id="audience">
<title>Intended Audience</title>
<para>This manual is intended for programmers who develop and/or maintain M applications in the GT.M environment.
This manual assumes that the programmers have no previous knowledge of GT.M. However, it does assume that the programmers
have access to the <phrase os="VMS">OpenVMS</phrase><phrase os="UNIX">UNIX</phrase> documentation that supplements the
limited <phrase os="VMS">VMS</phrase><phrase os="UNIX">UNIX</phrase> information in this manual.</para>
</sect1>
<sect1 id="purpose_of_the_manual">
<title>Purpose of the Manual</title>
<para>The GT.M Programmer's Guide documents all aspects of programming with M in the GT.M environment.</para>
</sect1>
<sect1 id="how_to_use_the_manual">
<title>How to Use This Manual</title>
<para>To assist you in locating information, the flow of the chapters moves from more general usage information to more specific reference and utilization information. The introductory chapters (Chapters 1 through 5) are directed at the first-time user and are probably best used for quick reference after you become acquainted with GT.M. Chapters 6 through 8 are organized in reference style with each chapter focusing on a specific language element and providing all the choices in alphabetical order. Chapter 9 describes GT.M handling of input and output. Chapter 10 describes GT.M-provided utility routines. Chapters 11 through 14 describe individual features of GT.M including context specific issues and requirements. Chapter 15 describes some error processing techniques. Chapter 11 describes using GT.M with languages other than American English. Chapter 12 describes error processing techniques.</para>
<para>Each of the chapters is summarized below to help you orient yourself to the general location of information.</para>
<para>Chapter 1:"About GT.M" gives an overview of the features of the GT.M programming system.</para>
<para>Chapter 2:"GT.M Language Extensions" provides summary tables of the GT.M language extension, grouped by purpose.</para>
<para>Chapter 3:"Program Development Cycle" gives an introduction to program development in the GT.M environment.</para>
<para>Chapter 4:"Operating and Debugging in Direct Mode" describes basic elements of operating in Direct Mode and the features available for debugging in Direct Mode.</para>
<para>Chapter 5:"General Language Features of M" describes features of M as a programming language that are important in using the reference information given in the "Commands," "Functions" and "Intrinsic Special Variables" chapters.</para>
<para>Chapter 6:"Commands" is a comprehensive description of each GT.M command. Entries are in alphabetical order.</para>
<para>Chapter 7:"Functions" is a comprehensive description of each GT.M function. Entries are in alphabetical order.</para>
<para>Chapter 8:"Intrinsic Special Variables" is a comprehensive description of each GT.M intrinsic special variable. Entries are in alphabetical order.</para>
<para>Chapter 9:"Input/Output Processing" describes input/output facilities available in GT.M.</para>
<para>Chapter 10:"M Utility Routines" describes library utilities provided with GT.M for performing frequently used M tasks.</para>
<para>Chapter 11:"Integrating External Routines" describes how to call GT.M routines from routines created in other programming languages and how to call out of GT.M routines to these external programs.</para>
<para os ="VMS">Chapter 12:"Database Access Library" describes the symbols in the GT.M run-time library used to call into GT.M routines from external routines.</para>
<para>Chapter <phrase os="VMS">13</phrase><phrase os="UNIX">12</phrase>:" Internationalization" describes the facilities available for using GT.M successfully with languages other than American English.</para>
<para os="VMS">Chapter 14:"Compiler Escape and Substitution Facility" describes the facility that allows you to create substitution strings that can be located and inserted into the code when it is compiled.</para>
<para>Chapter <phrase os="VMS">15</phrase><phrase os="UNIX">13</phrase>:"Error Processing" describes methods for error handling in GT.M.</para>
</sect1>
<sect1 id="examples">
<title>Examples</title>
<para os="UNIX">You can use GT.M with any UNIX shell as long as environment variables and scripts are consistently created for that shell. In this manual, all examples that involve UNIX commands assume use of the Bourne shell. They also assume that your environment has been set up as described in the chapters on "Installing GT.M" and "Basic Operations" in the GT.M Administration and Operations Guide </para>
<para>A conscientious effort was made in creating examples to present not only instructive examples, but also any related error messages that appear if you try the examples. However, due to implementation and shell differences, you may occasionally obtain different results. Any differences should be relatively minor, but it is advisable to try the exercises in a database environment that will not effect valued information.</para>
<para>In very rare cases, some examples that syntactically must occur on the same line may appear on multiple lines for typesetting purposes. In the case of those examples the continued lines are indented by a quarter of an inch.</para>
<para>Non-M examples, a dash (-) a backslash (\) appears at the end of the continued line. In M examples, an effort was made to construct examples where command lines did not wrap, in many cases using the argumentless DO. In cases of M command syntax description, and system message displayed in examples, you should always assume a single line is correct and that the break is entirely due to typesetting constraints. No separate convention is used in these cases to avoid confusion in trying the examples or syntaxes.</para>
<para>The examples make frequent use of literals in an attempt to focus the reader's attention on particular points. In normal usage variables are used far more frequently than literals.</para>
</sect1>
</preface>
<chapter label="1"><?dbhtml filename="chapter1.html" ?>
<title>About GT.M</title>
<para>GT.M is Fidelity Information Systems' implementation of ANSI standard M for Hewlett-Packard's OpenVMS system and for various
UNIX systems and for Hewlett-Packard's OpenVMS system. GT.M provides an environment that allows many users to share the same
database.</para>
<para>In addition to preserving the traditional features of M, GT.M also offers an optimized compiler that produces object code that
does not require internal interpreters during execution.</para>
<para>The GT.M dynamic linking mechanism activates compiled objects. You can link the object modules into shareable excutable images
and INSTALL them to be shared by multiple processes.</para>
<para>On all platforms, the GT.M dynamic linking mechanism activates compiled objects. On some platforms, you can link the object modules
into shared object libraries.</para>
<para>In keeping with the focus on creating fully compiled code, GT.M is tightly integrated with the operating system environment and
permits the use of operating system utilities for program development.</para>
<para>GT.M also provides a full complement of M tools for creating, compiling, and debugging source code. Many of these tasks are
accomplished from the GT.M facility called Direct Mode, which offers the look and feel of an interpreted language that is familiar to
the traditional M programmer.</para>
<sect1 id="progr_environ">
<title>Programming Environment</title>
<para>The GT.M Programming Environment is described in the following sections.</para>
<sect2 id="manage_data">
<title>Managing Data</title>
<para>The scope of M data is either process local or global. Local variables last only for the duration of the current session; GT.M
deletes them when the M process terminates.</para>
<para>Global variables contain data that persists beyond the process. GT.M stores global variables on disk. A Global Directory organizes global variables and describes the organization of a database. The GT.M administrator uses the Global Directory Editor (GDE) to create and manage Global Directories. A Global Directory maps global names to a database file. GT.M uses this mapping when it stores and retrieves globals from the database. Several Global Directories may refer to a single database file.</para>
<para>For more information about the GT.M data management system, refer to the "Global Directory Editor", "MUPIP" and "GT.M Journaling" chapters in the GT.M Administration and Operations Guide.</para>
<sect3 id="db_manage_utils">
<title>Database Management Utilities</title>
<para>The Global Directory Editor (GDE) creates, modifies, maintains, and displays the characteristics of Global Directories. GDE also maps LOCKs on resource names to the region of the database specified for the corresponding global variables.</para>
<para>The M Peripheral Interchange Program (MUPIP) creates database files and provides tools for GT.M database management and database journaling.</para>
<para>For more information regarding GT.M database utilities, refer to the "Global Directory Editor", "MUPIP" and "GT.M Journaling" chapters in the GT.M Administration and Operations Guide.</para>
</sect3>
</sect2>
<sect2 id="manage_source_code">
<title>Managing Source Code</title>
<para>In the GT.M programming environment, source routines are generated and stored as standard VMS filesUNIX files. They are created and edited with standard VMSUNIX text editors. </para>
<para>GT.M is designed to work with the operating system utilities and enhances them when beneficial. The following sections describe the process of programming and debugging with GT.M and from the operating system.</para>
<sect3 id="src_file_mang">
<title>Source File Management</title>
<para>In addition to standard M "percent" utilities, GT.M permits the use of the standard VMS file manipulation tools, e.g., the DIFFERENCE, SEARCH, COPY, and RENAME commands. The GT.M programmer can also use the powerful facilities provided by the RMS directory structure, file protection codes, and backup version numbers.</para>
<para>GT.M programs are compatible with most configuration management software, for example, Hewlett-Packard's Code Management System (CMS).</para>
<para>In addition to standard M "percent" utilities, GT.M permits the use of the standard UNIX file manipulation tools, for example, the diff, grep, cp, and mv commands. The GT.M programmer can also use the powerful facilities provided by the UNIX directory structure, such as time and date information, tree-structured directories, and file protection codes. </para>
<para>GT.M programs are compatible with most source management software, for example, RCS and SCCS.</para>
</sect3>
<sect3 id="prog_and_debug_faci">
<title>Programming and Debugging Facilities</title>
<para os="VMS">The GT.M programmer can use any VMS editor to create M source files, including EVE, the EDT keypad emulator, or a custom Text Processing Utility (TPU) program. The GT.M ZEDIT command provides access to a VMS TPU program directly from M. </para>
<para os="UNIX">The GT.M programmer can use any UNIX text editor to create M source files. If you generate a program from within the Direct Mode, it also accesses the UNIX text editor specified by the EDITOR environment variable and provides additional capabilities to automate and enhance the process.</para>
<para>The GT.M programmer also uses the Direct Mode facility to interactively debug, modify, and execute M routines. In Direct Mode, GT.M executes each M command immediately, as if it had been in-line at the point where GT.M initiated Direct Mode.</para>
<para>The following is a list of additional enhancements available from the Direct Mode:</para>
<itemizedlist>
<listitem>
<para>The capability to issue commands from Direct Mode to the VMS Command Language Interpreter (CLI), generally DCLshell</para>
</listitem>
<listitem>
<para>A command recall function to display and reuse previously entered commands, similar to the DCL recall function</para>
</listitem>
<listitem>
<para>Many language extensions that specifically optimize the debugging environment</para>
</listitem>
</itemizedlist>
</sect3>
<sect3 id="gtm_compiler">
<title>The GT.M Compiler</title>
<para>The GT.M compiler operates on source files to produce object files consisting of position-independent, shareable, native object VMS code native object code, which on some platforms can be linked into shared object libraries. GT.M provides syntax error checking at compile-time and allows you to enable or disable the compile-as-written mode. By default, GT.M produces an object file even if the compiler detects errors in the source code. This compile-as-written mode facilitates a flexible approach to debugging. </para>
</sect3>
<sect3 id="vax_vms_library" os="VMS">
<title>The VMS Librarian</title>
<para>If an object module contains frequently used routines, you can store it in a VMS library for future use. This approach simplifies file management and the linking process. When object modules are stored in a object library, you do not need to reference them explicitly during the linking process. When you reference the library from Digital Command Language (DCL) using the LINK command, LINK combines all the object modules to produce one GT.M executable image.</para>
</sect3>
<sect3 id="run_time_sys">
<title>The Run-Time System</title>
<para>A GT.M programmer can execute an M routine from <phrase os="VMS">DCL using the VMS RUN utility</phrase> <phrase os="UNIX">the shell</phrase> or interactively, using the M commands from Direct Mode.</para>
<para>The run-time system executes compile-as-written code as long as it does not encounter the compile-time errors. If it detects an error, the run-time system suspends execution of a routine immediately and transfers control to Direct Mode or to a user-written error routine. </para>
<para os="VMS">The VMS INSTALL utility can install an M image. Installing images as shareable allows multiple users to access the image as a single copy. This approach eliminates the use of a separate copy of the image for each user, allowing a more efficient use of physical memory and of the disk channel.</para>
<para os="VMS">To run GT.M routines in batch mode, use the DCL SUBMIT command and an appropriate command file.</para>
<sect4 id="automatic_and_incr_link">
<title>Automatic and Incremental Linking</title>
<para>The run-time system utilizes a GT.M facility called ZLINK to link in an M routine. When a program or a Direct Mode command refers to an M routine that is not part of the current process, GT.M automatically uses the ZLINK facility and attempts to link the referenced routine (auto-ZLINK). The ZLINK facility also determines whether recompilation of the routine is necessary. When compiling as a result of a ZLINK, GT.M typically ignores errors in the source code.</para>
<para>The run-time system also provides incremental linking. The ZLINK command adds an M routine to the current image. This feature facilitates the addition of code modifications during a debugging session. The GT.M programmer can also use the feature to add patches and generated code to a running M process.</para>
</sect4>
</sect3>
<sect3 id="err_proc">
<title>Error Processing</title>
<para>The GT.M compiler detects and reports syntax errors at the following times:</para>
<itemizedlist>
<listitem>
<para>Compile-time - while producing the object module from a source file</para>
</listitem>
<listitem>
<para>Run-time - while compiling code for M indirection and XECUTEs</para>
</listitem>
<listitem>
<para>Run-time - when the user is working in Direct Mode.</para>
</listitem>
</itemizedlist>
<para>The compile-time error message format displays the line containing the error and the location of the error on the line. The error message also indicates what was incorrect about the M statement.</para>
<para>GT.M can not detect certain types of errors associated with indirection, the functioning of I/O devices, and program logic until run-time. </para>
<para>The compile-as-written feature allows compilation to continue and produces an object module despite errors in the code. This permits testing of other pathways through the code. The errors are reported at run-time, when GT.M encounters them in the execution path.</para>
<para>The GT.M run-time system recognizes execution errors and reports them when they occur. It also reports errors flagged by the compiler when they occur in the execution path.</para>
<para>For more information, refer to the "Error Processing" chapter in this manual.</para>
</sect3>
<sect3 id="input_output_proc">
<title>Input/Output Processing</title>
<para>GT.M supports input and output processing with the following system components:</para>
<itemizedlist>
<listitem>
<para>Terminals</para>
</listitem>
<listitem>
<para>Sequential disk files</para>
</listitem>
<listitem>
<para>Magnetic tapes</para>
</listitem>
<listitem>
<para>Mailboxes</para>
</listitem>
<listitem>
<para>FIFOs</para>
</listitem>
<listitem>
<para>Null devices</para>
</listitem>
<listitem>
<para>Socket devices</para>
</listitem>
</itemizedlist>
<para>GT.M input/output processing is device-independent. Copying information from one device to another is accomplished without reformatting.</para>
<para>GT.M has special terminal-handling facilities. GT.M performs combined QIO operations to enhance terminal performance. The terminal control facilities that GT.M provides include escape sequences, control character traps, and echo suppression.</para>
<para>GT.M supports RMS sequential disk files that are accessed using a variety of deviceparameters.</para>
<para>GT.M supports block I/O with fixed and variable length records for file-structured (FILES-11) tapes and non-file-structured unlabeled (FOREIGN) tapes. GT.M supports the ASCII character set for unlabeled FOREIGN and FILES-11 tapes. GT.M supports the EBCDIC character set for FOREIGN tapes only. GT.M also supports FOREIGN DOS-11 and ANSI labelled tapes or stream format records. It also supports ASCII and EBCDIC character sets.</para>
<para>GT.M uses permanent or temporary mailboxes fifos for interprocess communication. GT.M treats mailboxes as record-structured I/O devices.</para>
<para>GT.M provides the ability to direct output to a null device. This is an efficient way to discard unwanted output.</para>
<para>GT.M provides device-exception processing so that I/O exception handling need not be combined with process-related exception conditions. The OPEN, USE, and CLOSE EXCEPTION parameters define an XECUTE string as an error handler for an I/O device. </para>
</sect3>
</sect2>
<sect2 id="integrate_with_other_lang">
<title>Integrating GT.M with Other Languages</title>
<para>GT.M offers capabilities that allow you to optimize your programming environment. These include allowing you to call into M routines from programs written in other programming languages, access your M databases with interfaces that provide functionality equivalent to M intrinsic database functions, and to alter your programming environment when working with languages other than American English. These include allowing you to call programs written in other programming languages that support C-like interfaces and to alter your programming environment when working with languages other than American English. This capability is described in more detail in chapters throughout this manual.</para>
</sect2>
<sect2 id="acc_to_non_m_routine">
<title>Access to Non-M Routines</title>
<para>GT.M routines can call external (non-M) routines using the external call function. This permits access to functions implemented in other programming languages. For more information, refer to the chapter "Integrating External Routines" in this manual. </para>
</sect2>
<sect2 id="international">
<title>Internationalization</title>
<para>GT.M allows the definition of alternative collation sequences and pattern matching codes for use with languages other than English. The "Internationalization" chapter in this manual describes the details and requirements of this functionality.</para>
</sect2>
</sect1>
</chapter>
<chapter label="2"><?dbhtml filename="chapter2.html" ?>
<title>GT.M Language Extensions</title>
<para>In addition to providing all of the ANSI standard M features, GT.M offers a number of language extensions. In this chapter, the language extensions are grouped by intended function to demonstrate their relationships to each other and to the programming process. A summary table is provided in each section. For a full description of a particular extension, refer to its complete entry in the "Commands", "Functions" or "Intrinsic Special Variables" chapter in this manual.</para>
<para>The following sections describe the GT.M language extensions listed below:</para>
<itemizedlist>
<listitem>
<para>M Development Committee (MDC) Type A releases</para>
</listitem>
<listitem>
<para>UNIX interface facilities</para>
</listitem>
<listitem>
<para>VMS interface facilities</para>
</listitem>
<listitem>
<para>Debugging tools</para>
</listitem>
<listitem>
<para>Exception-handling extensions</para>
</listitem>
<listitem>
<para>Journaling extensions</para>
</listitem>
<listitem>
<para>Extensions providing additional capability</para>
</listitem>
<listitem>
<para>Device Handling Extensions</para>
</listitem>
</itemizedlist>
<sect1 id="mdc_typeA_release">
<title>MDC Type A Releases</title>
<para>Type A releases are proposed changes to ANSI standard M that the MDC has recommended for inclusion in the next revision of the M standard.</para>
<para>The following table summarizes the GT.M MDC Type A releases.</para>
<informaltable frame="all">
<tgroup cols="2">
<colspec colname="c1"/>
<colspec colname="c2"/>
<tbody>
<row>
<entry namest="c1" nameend="c2" align="center">
<para>GT.M MDC Type A Releases </para>
</entry>
</row>
<row>
<entry align="center">
<para>EXTENSION</para>
</entry>
<entry align="center">
<para>EXPLANATION</para>
</entry>
</row>
<row>
<entry>
<para>$REFERENCE</para>
</entry>
<entry>
<para>Contains the last global reference, which updated the naked reference. If the naked reference is not valid the $REFERENCE contains an empty string.</para>
</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</sect1>
<sect1 id="oper_sys_interface">
<title>Operating System Interface Facilities</title>
<para>To improve efficiency and reduce duplication and inconsistency, GT.M is closely integrated with the host operating system environment. With GT.M you can gain access to the operating system facilities to examine:</para>
<itemizedlist>
<listitem>
<para>System information, such as quotas and SIDs </para>
</listitem>
<listitem>
<para>Jobs and processes</para>
</listitem>
<listitem>
<para>Directories and files</para>
</listitem>
<listitem>
<para>Devices</para>
</listitem>
<listitem>
<para>Messages</para>
</listitem>
<listitem>
<para>Privileges </para>
</listitem>
</itemizedlist>
<para os="VMS">All of these extensions are subject to normal VMS security management.</para>
<para>The following table summarizes the GT.M operating system interface facilities.</para>
<informaltable frame="all" os="VMS">
<tgroup cols="2">
<colspec colname="c1"/>
<colspec colname="c2"/>
<tbody>
<row>
<entry namest="c1" nameend="c2" align="center">
<para>Operating System Interface Facilities</para>
</entry>
</row>
<row>
<entry align="center">
<para>EXTENSION</para>
</entry>
<entry align="center">
<para>EXPLANATION</para>
</entry>
</row>
<row>
<entry>
<para>ZHelp</para>
</entry>
<entry>
<para>Provides access to a GT.M or VMS help library.</para>
</entry>
</row>
<row>
<entry>
<para>ZSYstem</para>
</entry>
<entry>
<para>Accesses the VMS Command Language Interpreter (CLI), generally DCL.</para>
</entry>
</row>
<row>
<entry>
<para>$ZCMdline</para>
</entry>
<entry>
<para>Contains a string value specifying the "excess" portion of the command line that invoked the GT.M process.</para>
</entry>
</row>
<row>
<entry>
<para>$ZFILE attributes()</para>
</entry>
<entry>
<para>Retrieves a file attribute.</para>
</entry>
</row>
<row>
<entry>
<para>$ZGETDVI()</para>
</entry>
<entry>
<para>Retrieves a device attribute.</para>
</entry>
</row>
<row>
<entry>
<para>$ZGETJPI()</para>
</entry>
<entry>
<para>Retrieves a process attribute.</para>
</entry>
</row>
<row>
<entry>
<para>$ZGETLKI()</para>
</entry>
<entry>
<para>Retrieves a VMS lock attribute.</para>
</entry>
</row>
<row>
<entry>
<para>$ZGETSYI</para>
</entry>
<entry>
<para>Retrieves a system attribute.</para>
</entry>
</row>
<row>
<entry>
<para>$ZJob</para>
</entry>
<entry>
<para>Holds the pid of the process created by the last JOB command performed by the current process.</para>
</entry>
</row>
<row>
<entry>
<para>$ZLKID()</para>
</entry>
<entry>
<para>Scans VMS locks.</para>
</entry>
</row>
<row>
<entry>
<para>$ZMessage()</para>
</entry>
<entry>
<para>Translates an error condition code into text form.</para>
</entry>
</row>
<row>
<entry>
<para>$ZPARSE()</para>
</entry>
<entry>
<para>Parses an RMS filename.</para>
</entry>
</row>
<row>
<entry>
<para>$ZPID()</para>
</entry>
<entry>
<para>Scans process identifiers.</para>
</entry>
</row>
<row>
<entry>
<para>$ZPRIVilege()</para>
</entry>
<entry>
<para>Determines current VMS privileges.</para>
</entry>
</row>
<row>
<entry>
<para>$ZSEARCH()</para>
</entry>
<entry>
<para>Searches for one or more RMS files.</para>
</entry>
</row>
<row>
<entry>
<para>$ZSETPRV()</para>
</entry>
<entry>
<para>Sets or clears VMS privileges and determines current privileges.</para>
</entry>
</row>
<row>
<entry>
<para>$ZSYstem</para>
</entry>
<entry>
<para>Contains the status code of the last ZSYSTEM.</para>
</entry>
</row>
<row>
<entry>
<para>$ZTRNLNM()</para>
</entry>
<entry>
<para>Translates a VMS logical name.</para>
</entry>
</row>
<row>
<entry>
<para>$ZDIRectory</para>
</entry>
<entry>
<para>Contains current default directory.</para>
</entry>
</row>
<row>
<entry>
<para>$ZMODE</para>
</entry>
<entry>
<para>Contains process mode (Batch, Interactive, Direct Mode).</para>
</entry>
</row>
<row>
<entry>
<para>$ZPROCess</para>
</entry>
<entry>
<para>Contains name of current process.</para>
</entry>
</row></tbody></tgroup>
</informaltable>
<informaltable frame="all" os="UNIX">
<tgroup cols="2">
<colspec colname="c1"/>
<colspec colname="c2"/>
<tbody>
<row>
<entry namest="c1" nameend="c2" align="center">
<para>Operating System Interface Facilities </para>
</entry>
</row>
<row>
<entry align="center">
<para>EXTENSION</para>
</entry>
<entry align="center">
<para>EXPLANATION</para>
</entry>
</row>
<row>
<entry>
<para>ZSYstem</para>
</entry>
<entry>
<para>Provides access to the shell.</para>
</entry>
</row>
<row>
<entry>
<para>$ZMessage()</para>
</entry>
<entry>
<para>Translates an error condition code into text form.</para>
</entry>
</row>
<row>
<entry>
<para>$ZCMdline</para>
</entry>
<entry>
<para>Contains a string value specifying the "excess" portion of the command line that invoked the GT.M process.</para>
</entry>
</row>
<row>
<entry>
<para>$ZJob</para>
</entry>
<entry>
<para>Holds the pid of the process created by the last JOB command performed by the current process.</para>
</entry>
</row>
<row>
<entry>
<para>$ZPARSE()</para>
</entry>
<entry>
<para>Parses a UNIX filename.</para>
</entry>
</row>
<row>
<entry>
<para>$ZSEARCH()</para>
</entry>
<entry>
<para>Searches for one or more UNIX files.</para>
</entry>
</row>
<row>
<entry>
<para>$ZSYstem</para>
</entry>
<entry>
<para>Contains the status code of the last ZSYSTEM.</para>
</entry>
</row>
<row>
<entry>
<para>$ZTRNLNM()</para>
</entry>
<entry>
<para>Translates an environment variable.</para>
</entry>
</row>
<row>
<entry>
<para>$ZDIRectory</para>
</entry>
<entry>
<para>Contains current working directory.</para>
</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</sect1>
<sect1 id="debugging_facilities">
<title>Debugging Facilities</title>
<para>GT.M provides a number of debugging features, many of them through language extensions.</para>
<para>These features include the ability to:</para>
<itemizedlist>
<listitem>
<para>Interactively execute routines using M commands.</para>
</listitem>
<listitem>
<para>Display lines that may contain errors using the ZPRINT command and the $ZPOSITION special variable.</para>
</listitem>
<listitem>
<para>Redisplay error messages using the $ZSTATUS special variable and the ZMESSAGE command.</para>
</listitem>
<listitem>
<para>Set breakpoints and actions to bypass an error using the ZBREAK command.</para>
</listitem>
<listitem>
<para>Execute a line at a time using the ZSTEP command.</para>
</listitem>
<listitem>
<para>Display information about the M environment using the ZSHOW command.</para>
</listitem>
<listitem>
<para>Modify the invocation stack with QUIT and ZGOTO.</para>
</listitem>
<listitem>
<para>Incrementally add or modify code using the ZLINK and ZEDIT commands.</para>
</listitem>
<listitem>
<para>Continue execution using the ZCONTINUE command.</para>
</listitem>
</itemizedlist>
<para>The following table summarizes the GT.M language extensions that facilitate debugging.</para>
<informaltable frame="all" os="VMS">
<tgroup cols="2">
<colspec colname="c1"/>
<colspec colname="c2"/>
<tbody>
<row>
<entry namest="c1" nameend="c2" align="center">
<para>GT.M Debugging Tools</para>
</entry>
</row>
<row>
<entry align="center">
<para>EXTENSION</para>
</entry>
<entry align="center">
<para>EXPLANATION</para>
</entry>
</row>
<row>
<entry>
<para>ZBreak</para>
</entry>
<entry>
<para>Establishes a temporary breakpoint, with optional M action and/or activation count.</para>
</entry>
</row>
<row>
<entry>
<para>ZCOMpile</para>
</entry>
<entry>
<para>Invokes the GT.M compiler without a corresponding ZLINK.</para>
</entry>
</row>
<row>
<entry>
<para>ZContinue</para>
</entry>
<entry>
<para>Continues routine execution from a BREAK.</para>
</entry>
</row>
<row>
<entry>
<para>ZEDit</para>
</entry>
<entry>
<para>Invokes a VMS editor.</para>
</entry>
</row>
<row>
<entry>
<para>ZGoto</para>
</entry>
<entry>
<para>Removes zero or more levels from the M invocation stack and, optionally, transfers control.</para>
</entry>
</row>
<row>
<entry>
<para>ZLink</para>
</entry>
<entry>
<para>Includes a new or modified M routine in the current M process, automatically recompiling it if necessary.</para>
</entry>
</row>
<row>
<entry>
<para>ZMessage</para>
</entry>
<entry>
<para>Signals the specified condition.</para>
</entry>
</row>
<row>
<entry>
<para>ZPrint</para>
</entry>
<entry>
<para>Displays lines of source code.</para>
</entry>
</row>
<row>
<entry>
<para>ZSHow</para>
</entry>
<entry>
<para>Displays information about the M environment.</para>
</entry>
</row>
<row>
<entry>
<para>ZSTep</para>
</entry>
<entry>
<para>Executes a routine incrementally to the beginning of the next line of the specified type.</para>
</entry>
</row>
<row>
<entry>
<para>ZWRite</para>
</entry>
<entry>
<para>Displays all or some of the local or global symbols.</para>
</entry>
</row>
<row>
<entry>
<para>$ZCSTATUS</para>
</entry>
<entry>
<para>Holds the status code value for the last compilation performed by a ZCOMPILE command.</para>
</entry>
</row>
<row>
<entry>
<para>$ZEDit</para>
</entry>
<entry>
<para>Contains the status code for the last ZEDit.</para>
</entry>
</row>
<row>
<entry>
<para>$ZJOBEXAM()</para>
</entry>
<entry>
<para>Performs a ZSHOW "*" to a default file location and name, or the one optionally specified by the argument.</para>
</entry>
</row>
<row>
<entry>
<para>$ZLEVel</para>
</entry>
<entry>
<para>Contains the current level of DO/XECUTE nesting.</para>
</entry>
</row>
<row>
<entry>
<para>$ZMessage()</para>
</entry>
<entry>
<para>Translates an error condition code into text form.</para>
</entry>
</row>
<row>
<entry>
<para>$ZPOSition</para>
</entry>
<entry>
<para>Contains a string indicating the current execution location.</para>
</entry>
</row>
<row>
<entry>
<para>$ZPROmpt</para>
</entry>
<entry>
<para>Controls the direct mode prompt.</para>
</entry>
</row>
<row>
<entry>
<para>$ZSOurce</para>
</entry>
<entry>
<para>Contains the name of the most recently ZLINKed or ZEDITed M source program; provides the default name for next ZEDIT or ZLINK.</para>
</entry>
</row>
<row>
<entry>
<para>$ZStatus</para>
</entry>
<entry>
<para>Contains error condition code and location of the last exception condition occurring during routine execution.</para>
</entry>
</row>
<row>
<entry>
<para>$ZSTep</para>
</entry>
<entry>
<para>Controls the default ZSTep action.</para>
</entry>
</row>
</tbody>
</tgroup>
</informaltable>
<informaltable frame="all" os="UNIX">
<tgroup cols="2">
<colspec colname="c1"/>
<colspec colname="c2"/>
<tbody>
<row>
<entry namest="c1" nameend="c2" align="center">
<para>GT.M Debugging Tools</para>
</entry>
</row>
<row>
<entry align="center">
<para>EXTENSION</para>
</entry>
<entry align="center">
<para>EXPLANATION</para>
</entry>
</row>
<row>
<entry>
<para>ZBreak</para>
</entry>
<entry>
<para>Establishes a temporary breakpoint, with optional M action and/or activation count.</para>
</entry>
</row>
<row>
<entry>
<para>ZContinue</para>
</entry>
<entry>
<para>Continues routine execution from a break.</para>
</entry>
</row>
<row>
<entry>
<para>ZEDit</para>
</entry>
<entry>
<para>Invokes the UNIX text editor specified by the EDITOR environment variable.</para>
</entry>
</row>
<row>
<entry>
<para>ZGoto</para>
</entry>
<entry>
<para>Removes multiple levels from the M invocation stack and transfers control.</para>
</entry>
</row>
<row>
<entry>
<para>ZLink</para>
</entry>
<entry>
<para>Includes a new or modified M routine in the current M image; automatically recompiles if necessary.</para>
</entry>
</row>
<row>
<entry>
<para>ZMessage</para>
</entry>
<entry>
<para>Signals the specified condition.</para>
</entry>
</row>
<row>
<entry>
<para>ZPrint</para>
</entry>
<entry>
<para>Displays lines of source code.</para>
</entry>
</row>
<row>
<entry>
<para>ZSHow</para>
</entry>
<entry>
<para>Displays information about the M environment.</para>
</entry>
</row>
<row>
<entry>
<para>ZSTep</para>
</entry>
<entry>
<para>Incrementally executes a routine to the beginning of the next line of the same type.</para>
</entry>
</row>
<row>
<entry>
<para>ZWRite</para>
</entry>
<entry>
<para>Displays all or some local or global variables.</para>
</entry>
</row>
<row>
<entry>
<para>$ZCSTATUS</para>
</entry>
<entry>
<para>Holds the value of the status code for the last compile performed by a ZCOMPILE command.</para>
</entry>
</row>
<row>
<entry>
<para>$ZEDit</para>
</entry>
<entry>
<para>Contains the status code for the last ZEDit.</para>
</entry>
</row>
<row>
<entry>
<para>$ZJOBEXAM()</para>
</entry>
<entry>
<para>Performs a ZSHOW "*" to a default file location and name, or the one optionally specified by the argument.</para>
</entry>
</row>
<row>
<entry>
<para>$ZLEVel</para>
</entry>
<entry>
<para>Contains the current level of DO/XECUTE nesting.</para>
</entry>
</row>
<row>
<entry>
<para>$ZMessage()</para>
</entry>
<entry>
<para>Translates an error condition code into text form.</para>
</entry>
</row>
<row>
<entry>
<para>$ZPOSition</para>
</entry>
<entry>
<para>Contains a string indicating the current execution location.</para>
</entry>
</row>
<row>
<entry>
<para>$ZPROmpt</para>
</entry>
<entry>
<para>Controls the symbol displayed as the direct mode prompt.</para>
</entry>
</row>
<row>
<entry>
<para>$ZROutines</para>
</entry>
<entry>
<para>Contains a string specifying a directory list containing the object, and optionally the source, files.</para>
</entry>
</row>
<row>
<entry>
<para>$ZSOurce</para>
</entry>
<entry>
<para>Contains name of the M source program most recently ZLINKed or ZEDITed; default name for next ZEDIT or ZLINK.</para>
</entry>
</row>
<row>
<entry>
<para>$ZStatus</para>
</entry>
<entry>
<para>Contains error condition code and location of the last exception condition occurring during routine execution.</para>
</entry>
</row>
<row>
<entry>
<para>$ZSTep</para>
</entry>
<entry>
<para>Controls the default ZSTep action.</para>
</entry>
</row>
</tbody>
</tgroup>
</informaltable>
</sect1>
<sect1 id="exception_handling">
<title>Exception Handling Facilities</title>
<para>The GT.M exception trapping allows you to do the following:</para>
<itemizedlist>
<listitem>
<para>DO a recovery routine and resume the original command stream.</para>
</listitem>
<listitem>
<para>GOTO any special handling; an extended ZGOTO provides for context management.</para>
</listitem>
<listitem>
<para>Report an error and enter Direct Mode for debugging.</para>
</listitem>
<listitem>
<para>OPEN Input/Output devices with specific traps in addition to the main trap.</para>
</listitem>
<listitem>
<para>Trap and process an exception based on a device error.</para>
</listitem>
<listitem>
<para>Trap and process an exception based on terminal input. </para>
</listitem>
</itemizedlist>
<para>The following table summarizes the GT.M language extensions that facilitate exception handling.</para>
<para/>
<informaltable frame="all">
<tgroup cols="2">
<colspec colname="c1"/>
<colspec colname="c2"/>
<tbody>
<row>
<entry namest="c1" nameend="c2" align="center">
<para>GT.M Exception Handling Extensions</para>
</entry>
</row>
<row>
<entry align="center">
<para>EXTENSION</para>
</entry>
<entry align="center">
<para>EXPLANATION</para>
</entry>
</row>
<row>
<entry>
<para>ZGoto</para>
</entry>
<entry>
<para>Removes zero or more levels from the M Invocation stack and, optionally, transfers control.</para>
</entry>
</row>
<row>
<entry>
<para>ZMessage</para>
</entry>
<entry>
<para>Signals the specified condition.</para>
</entry>
</row>
<row>
<entry>
<para>$ZCSTATUS</para>
</entry>
<entry>
<para>Holds the value of the status code for the last compile performed by a ZCOMPILE command.</para>
</entry>
</row>
<row>
<entry>
<para>$ZEOF</para>
</entry>
<entry>
<para>Contains indication of whether the last READ reached end-of-file.</para>
</entry>
</row>
<row>
<entry>
<para>$ZMessage()</para>
</entry>
<entry>
<para>Translates an error condition code into text form.</para>
</entry>
</row>
<row>
<entry>
<para>$ZLevel</para>
</entry>
<entry>
<para>Contains current level of DO/XECUTE nesting.</para>
</entry>
</row>
<row>
<entry>
<para>$ZStatus</para>
</entry>
<entry>
<para>Contains error condition code and location of last exception condition occurring during routine execution.</para>
</entry>
</row>
<row>
<entry>
<para>$ZSYstem</para>
</entry>
<entry>
<para>Contains the status code of the last ZSYSTEM.</para>
</entry>
</row>
<row>
<entry>
<para>$ZTrap</para>
</entry>
<entry>
<para>Contains an XECUTE string or entryref that GT.M invokes upon encountering an exception condition.</para>
</entry>
</row>
<row>
<entry>
<para>EXCEPTION</para>
</entry>
<entry>
<para>Provides a deviceparameter specifying an XECUTE string or entryref that GT.M invokes upon encountering a device-related exception condition.</para>
</entry>
</row></tbody></tgroup>
</informaltable>
</sect1>
<sect1 id="jrnl_ext">
<title>Journaling Extensions</title>
<para>Journaling records redundant copies of database update information to increase protection against loss of information due to hardware and software failure. GT.M provides the M commands ZTSTART and ZTCOMMIT, to mark the beginning and end of a logical transaction. When ZTSTART and ZTCOMMIT fence a logical transaction, which may consist of multiple global variable updates, journal records can assure recovery of incomplete application transactions. </para>
<para>The following table summarizes the GT.M language extensions for journaling.</para>
<informaltable frame="all">
<tgroup cols="2">
<colspec colname="c1"/>
<colspec colname="c2"/>
<tbody>
<row>
<entry namest="c1" nameend="c2" align="center">
<para>Journaling Extensions</para>
</entry>
</row>
<row>
<entry align="center">
<para>EXTENSION</para>
</entry>
<entry align="center">
<para>EXPLANATION</para>
</entry>
</row>
<row>
<entry>
<para>View</para>
</entry>
<entry>
<para>Extended to ensure that GT.M has transferred all updates to the journal file.</para>
</entry>
</row>
<row>
<entry>
<para>ZTCommit</para>
</entry>
<entry>
<para>Marks the completion of a logical transaction.</para>
</entry>
</row>
<row>
<entry>
<para>ZTStart</para>
</entry>
<entry>
<para>Marks the beginning of a logical transaction.</para>
</entry>
</row>
<row>
<entry>
<para>$View()</para>
</entry>
<entry>
<para>Extended for examining journaling status.</para>
</entry>
</row></tbody></tgroup>
</informaltable>
<para/>
</sect1>
<sect1 id="extensions_for_addl_capacity">
<title>Extensions For Additional Capability</title>
<para>For ways to adjust some process operating characteristics, refer to the VIEW section of the "Commands" chapter in this manual. For ways to get information about certain process operating characteristics, refer to the $VIEW() section of the "Functions" chapter in this manual.</para>
<para>In GT.M, support of environment specification for global names and resource names is possible. It is possible to excercise user code to customize interpretation of the environment specification. Refer to "General Language Features" chapter in this manual for details.</para>
<para>The following table summarizes GT.M extensions that increase general capability.</para>
<informaltable frame="all">
<tgroup cols="2">
<colspec colname="c1"/>
<colspec colname="c2"/>
<tbody>
<row>
<entry namest="c1" nameend="c2" align="center">
<para>GT.M Extensions for Additional Capability</para>
</entry>
</row>
<row>
<entry align="center">
<para>EXTENSION</para>
</entry>
<entry align="center">
<para>EXPLANATION</para>
</entry>
</row>
<row>
<entry>
<para>View</para>
</entry>
<entry>
<para>Modifies the environment.</para>
</entry>
</row>
<row>
<entry>
<para>ZAllocate*</para>
</entry>
<entry>
<para>Facilitates incremental locking by locking a name without unlocking previously locked names.</para>
</entry>
</row>
<row>
<entry>
<para>ZDeallocate*</para>
</entry>
<entry>
<para>Unlocks one or more names without necessarily unlocking other names.</para>
</entry>
</row>
<row>
<entry>
<para>ZHelp</para>
</entry>
<entry>
<para>Provides access to on-line help.</para>
</entry>
</row>
<row>
<entry>
<para>ZWIthdraw</para>
</entry>
<entry>
<para>"Kills" data in a node without affecting the node's descendants.</para>
</entry>
</row>
<row>
<entry>
<para>$Order()</para>
</entry>
<entry>
<para>Enhanced to return the next unsubscripted variable in collating sequence from the current environment.</para>
</entry>
</row>
<row>
<entry>
<para>$View()</para>
</entry>
<entry>
<para>Examines the GT.M environment.</para>
</entry>
</row>
<row>
<entry>
<para>$ZCall()**</para>
</entry>
<entry>
<para>Returns a value from an external routine or user-defined function written in another programming language.</para>
</entry>
</row>
<row>
<entry>
<para>$ZCStatus</para>
</entry>
<entry>
<para>Returns the status from the last compile.</para>
</entry>
</row>
<row>
<entry>
<para>$ZDate()</para>
</entry>
<entry>
<para>Converts a date and/or time in $HOROLOG format into formatted text, using a user-specified format string.</para>
</entry>
</row>
<row>
<entry>
<para>$ZPrevious()***</para>
</entry>
<entry>
<para>Returns the previous element in a collating sequence, at the current level of a local or global array.</para>
</entry>
</row>
<row>
<entry>
<para>$ZA,$ZB, $ZEOF</para>
</entry>
<entry>
<para>Return device dependent I/O status information.</para>
</entry>
</row>
<row>
<entry>
<para>$ZCOmpile</para>
</entry>
<entry>
<para>Maintains the compiler qualifiers to be used on automatic compilation.</para>
</entry>
</row>
<row>
<entry>
<para>$ZBIT functions</para>
</entry>
<entry>
<para>A series of functions beginning with the characters $ZBIT that allow manipulation of bits.</para>
</entry>
</row>
<row>
<entry>
<para>$ZGBLdir</para>
</entry>
<entry>
<para>Maintains the name of the current global directory; may be set to switch this process to a new database.</para>
</entry>
</row>
<row>
<entry>
<para>$ZIO</para>
</entry>
<entry>
<para>Contains translated name of current I/O device.</para>
</entry>
</row>
<row>
<entry>
<para>$ZINTerrupt</para>
</entry>
<entry>
<para>Specifies the code to be XECUTE'd when an interrupt is processed.</para>
</entry>
</row>
<row>
<entry>
<para>$ZMAXTPTIme</para>
</entry>
<entry>
<para>Contains an integer value indicating the time duration GT.M should wait for the completion of all activities fenced by the current transaction's outermost TSTART/TCOMMIT pair.</para>
</entry>
</row>
<row>
<entry>
<para>$ZROutines</para>
</entry>
<entry>
<para>Maintains the list of directories to search during look-ups of object and source files.</para>
</entry>
</row>
<row>
<entry>
<para>$ZSYstem</para>
</entry>
<entry>
<para>Returns the status from the last VMS shell invocation.</para>
</entry>
</row>
<row>
<entry>
<para>$ZVERsion</para>
</entry>
<entry>
<para>Contains a designation of the current version name, level, and operating system.</para>
</entry>
</row>
</tbody>
</tgroup>
</informaltable>
<para>*The ZALLOCATE and ZDEALLOCATE commands are provided for compatibility with other M systems. However, Sanchez recommends use of the standard LOCK command, which provides an incremental locking facility. The incremental lock provides both flexibility and greater compatibility with the M language standard.</para>
<para os="VMS">**The $ZCALL function is provided for compatibility with previous versions of GT.M and other M systems. However, Sanchez recommends use of the standard external reference for routines and functions. The external reference provides both flexibility and compatibility with the M language standard.</para>
<para>**<phrase os="VMS">*</phrase>The $ZPREVIOUS function is provided for compatibility with previous versions of GT.M and other M systems. However, Sanchez recommends use of the standard two-argument form for the $ORDER function.</para>
</sect1>
<sect1 id="gtm_device_handling_extensions">
<title>GT.M Device Handling Extensions</title>
<para>In the earlier versions of the M standard, device behavior was defined as a framework, with the details left to the implementations. GT.M supports Terminals, Sequential Disks, Magnetic Tape, Mailboxes, FIFOs, and a Null device with under this model. Subsequently device mnemonicspaces were added to the standard and some of them defined. GT.M supports the SOCKET device under this model with some extensions identified with controlmnemonics starting with the letter "Z." </para>
<itemizedlist>
<listitem>
<para>For details of GT.M device handling refer to the "Input/Output Processing" Chapter in this manual.</para>
</listitem>
</itemizedlist>
</sect1>
</chapter>
<chapter label="3"><?dbhtml filename="chapter3.html" ?>
<title>Program Development Cycle</title>
<para condition="manual;manual" os="UNIX;VMS">This chapter introduces program development in the GT.M environment. The GT.M environment differs from other M implementations in a number of ways. These differences, which include maintaining data and code in separate files and compiling rather than interpreting source code, allow greater programmer control over the development cycle.</para>
<para condition="manual;help" os="UNIX">In contrast to M environments that interpret M code, GT.M compiles M code from source files into the target machine language. The GT.M compiler produces object files, which are dynamically linked into an image. Source files and object files may be managed independently, or placed together in a specific directory. GT.M permits access to source and object files in multiple directories.</para>
<para condition="help;manual" os="VMS">In contrast to M environments that interpret M code, GT.M compiles M code from source files into the object files. These object files can be directly linked into an image, permanently or dynamically. Source files and object files are independent of one another. Since GT.M permits access to source and object files in multiple directories. they may be managed independently or all placed together in a specific directory.</para>
<para>GT.M databases are RMSUNIX files identified by a small file called a Global Directory. Global Directories allow management of the database files to be independent of the placement of files containing M routines. By changing the Global Directory, you can use the same programs to access different databases.</para>
<para>Program development may utilize both GT.M and VMSUNIX development tools. The development methodology and environment chosen for a particular installation, and tailored by the individual user, determines the actual mix of tools. These tools may vary from entirely GT.M with little UNIXVMS, to mostly UNIXVMS with a modest use of GT.M.</para>
<para os="VMS" condition="help">Direct Mode serves as an interactive interface to the GT.M run-time environment and the compiler. In Direct Mode, the user enters M commands at the GT.M prompt, and GT.M compiles and executes the command. This feature provides immediate turnaround for rapid program development and maintenance.</para>
<para>This chapter is based on the tasks that a programmer might perform while developing an application. It provides a "road map" for programmers of varying levels. Some steps may be unnecessary in your environment, so feel free to skip sections that do not apply to your situation.</para>
</chapter>
<index id="index"><?dbhtml filename="indexnames.html" ?>
</index>
</book>
[Date Prev] | [Thread Prev] | [Thread Next] | [Date Next] -- [Date Index] | [Thread Index] | [List Home]