Programmer's Guide to Writing Programs

Index

Table of Contents

!  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O  P  Q  R  S  T  U  V  W  X  Y  Z 

!

01SHUFFLE Compiler directive  *
64KPARA Compiler directive  *
64KSECT Compiler directive  *

A

ACCEPT and EBCDIC  *
ACCEPT FROM ENVIRONMENT-VALUE  *
ACCEPT FROM LINE NUMBER  *
Accessing non-COBOL data  *
Adis portability  *
adisctrl database and NLS  *
ALIGN Compiler directive  *
ALIGN Compiler Directive  *
Alphanumeric data, efficiency of manipulation  *
Alt key portability  *
ALTER Compiler directive  *
ALTER statement  * , *
AND logic operator  * , * , *
ANIM Compiler directive  *
Animating
        calling C subprograms  *
        programs that call assembler subprograms  *
Animator
        and Integrated Preprocessor  *
        hiding screen  *
        maximum programs loaded  *
Animator directives
        FLASH-CALLS  * , * , *
ANSI, COMP usage  *
API routines
        accessing  *
        OS/2  *
        OS/2 (16-bit)  *
        OS/2 (32-bit)  *
        supplied definitions  *
        Win32  *
        Windows  *
        Windows NT  *
apidef.asm  *
apidef{B}.asm{D}  *
Application Configuration System  *
        See also Configuration file
        and Menu Handler  *
        call interface  *
        closing configuration file  *
        error messages  *
        parameters  *
        processing method  *
Application subsystem routines  *
Applications
        memory management in mixed-language applications  *
        mixed language programs  *
        native-mode Windows  *
        portability  *
        QuickWindows  *
ARGUMENT-NUMBER function-name  *
ARGUMENT-VALUE function-name  *
Arithmetic statement efficiency  *
ASCII
        collating example  *
        collating sequences  *
ASCII/EBCDIC
        converting  *
        converting using _CODESET  *
ASMLIST Compiler directive  *
Assembler
        calling from animated programs  *
        FAR returns  *
        invoking from COBOL  *
        memory considerations  *
        mixed language programming  * , *
        register state on program call  *
        routine library  *
        subprograms  *
        subprograms on DOS  *
        subprograms on OS/2 (16-bit)  *
        subprograms on OS/2 (32-bit)  *
        subprograms on Windows  *
        subprograms on Windows NT (32-bit)  *
Attribute routines, set PC attribute table  *
Attributes
        portability  *
        setting for application  *
Attributes tag, configuration file  *

B

BASIS and Integrated Preprocessor  *
Bit manipulation programming  *
Bitmap
        freeing from printer  *
        loading for printing  *
        writing to printer  *
Boolean operators
        Calling  *
        using  *
BOUND Compiler directive  *
Boundary crossing  * , *
        segment  *
BOUNDOPT Compiler directive  *
BY REFERENCE phrase  *
BY VALUE phrase  * , *
Byte
        read from port  *
        reading from memory  *
        write to port  *
        writing to memory  *

C

C
        interfacing with COBOL  * , *
        Lattice  *
        Microsoft v4.0  *
        Microsoft v5.0  *
        Microsoft V6.0  * , * , *
        Microsoft V7.0  * , *
C functions
        cobcall  *
        cobcancel  *
        cobexit  *
        cobfunc  *
        cobinit  *
        cobkeypad  *
        coblongjmp  *
        cobsavenv  *
        cobtidy  *
C screen handling
        cobaddch  *
        cobaddstr  *
        cobaddstrc  *
        cobclear  *
        cobcols  *
        cobgetch  *
        cobgetenv  *
        coblines  *
        cobmove  *
        cobprintf  *
        cobputenv  *
        cobrescanenv  *
        cobscroll  *
C Set++  * , *
        32-bit/16-bit call conversion  *
C signal handling
        cobpostsighandler  *
        cobremovesighandler  *
C-language header  *
C/C++, Microsoft V7  *
c6dosif.obj file  *
c6doslb.obj files  *
c6os2if.obj  *
c6os2lb.obj  *
c7dosif.obj file  *
c7doslb.obj file  *
CALL  * , *
        efficiency  *
        parameters  *
        requirements (16-bit)  *
        requirements (32-bit and 64-bit)  *
CALL convention, OS/2 API  *
Call convention  *
        efficiency  *
        OS/2 (16-bit)  *
        Windows (16-bit)  *
Call interface compatibility  *
CALL prototype syntax  *
CALLFH Compiler directive  *
Calling
        assembler programs  *
        programs  *
        SYSTEM  *
        system()  *
        UNIX system shell  *
CANCEL  * , *
Cancelling non-COBOL programs  *
Case conversion
        CBL_TOLOWER routine  *
        CBL_TOUPPER routine  *
        in National Language Support  * , *
Case sensitivity and portability  *
Cbllink utility  *
Cblnames utility  *
CBL_ routines
        logic  *
        National Language Support  *
CBL_ALLOC_MEM  * , *
        efficiency  *
CBL_AND  *
CBL_CLOSE_VFILE  *
CBL_CULL_RUN_UNITS  *
CBL_EQ  *
CBL_ERROR_PROC  *
CBL_EXEC_RUN_UNIT  *
CBL_EXIT_PROC  *
CBL_FREE_MEM  *
CBL_GET_OS_INFO  *
CBL_GET_SHMEM_PTR  *
CBL_IMP  *
CBL_NLS_CLOSE_MSG_FILE  *
CBL_NLS_COMPARE  *
CBL_NLS_INFO  *
CBL_NLS_OPEN_MSG_FILE  *
CBL_NLS_READ_MSG  *
CBL_NOT  *
CBL_OPEN_VFILE  *
CBL_OR  *
CBL_PUT_SHMEM_PTR  *
CBL_READ_VFILE  *
CBL_SCR_SET_PC_ATTRIBUTES  *
CBL_SUBSYSTEM  *
CBL_TOLOWER  *
CBL_TOUPPER  *
CBL_WRITE_VFILE  *
CBL_XOR  *
CBL_YIELD_RUN_UNIT  *
.cfg file, installing concurrency support  *
CHAIN  *
Character sets
        converting  *
        extended character set and portability  *
CHARSET Compiler directive  *
Check program exists  *
Child run-unit  *
CHIP Compiler directive  * , *
Class condition tests in National Language Support  *
Close NLS message file  *
Closedown procedure registration  *
Closing printer  *
cob32api.dll file  *
cob32chr.dll file  *
cob32win.dll file  *
cobaddch routine  *
cobaddstr routine  *
cobaddstrc routine  *
cobcall function  *
cobcancel function  *
cobchtype  *
cobclear routine  *
cobcols routine  *
COBDIR environment variable  *
cobexit function  *
cobfp87.dle  *
cobfp87.dll  *
cobfp87.dlw  *
cobfp87d.lib  *
cobfp87o.lib  *
cobfp87w.lib  *
cobfunc function  *
cobgetch routine  *
cobgetenv routine  *
cobinit function  *
cobkeypad function  *
COBLANG environment variable  *
coblibw.lib  *
Coblines routine  *
coblongjmp function  *
COBLPFORM environment variable  *
cobmove routine  *
COBOL
        call conventions  *
        interfacing environment  *
        interfacing with C  * , *
        invoking Microsoft C V6  *
        invoking Microsoft C/C++ V7  *
        protection violation  *
COBOL syntax
        not implemented  *
        used for interfacing  *
COBOL system
        See System
COBOL type definition  *
cobolapi.def  *
COBPOOL environment variable  * , *
cobpostsighandler routine  *
COBPRINTER environment variable  *
cobprintf routine  *
cobputenv routine  *
cobremovesighandler  *
cobrescanenv routine  *
cobsavenv function  *
cobscreen.h header file  *
cobscroll routine  *
cobtidy function  *
cobw  *
Code segments  *
Codepage environment in National Language Support  *
_CODESET program, configuring  *
Collating sequence for ASCII and EBCDIC  *
Color, setting on printer  *
Colorizing applications  *
COMMAND-LINE function-name  *
Commands
        cbllink  *
        cblnames  *
Communication
        between programs  *
        between run-units  *
COMP Compiler directive  *
COMP usage  *
COMP-3  *
COMP-5
        efficiency  *
        representation  *
        speed  *
COMP-X
        efficiency  *
        representation  * , *
        speed  *
Comparisons
        CBL_NLS_COMPARE  *
        EQUALS  *
        GREATER  *
        LESS  *
        NOT EQUAL  *
Compiler directives  *
        ALIGN  *
        CALLFH  *
        CHIP  *
        DEFFILE  *
        efficiency  *
        ENDP  *
        FLAG-CHIP  *
        INTLEVEL  *
        MF  *
        MODEL  *
        NLS  *
        portability  *
        PREPROCESS  *
        REALOVL  *
        RETRYLOCK  *
        SEG  *
        size optimization  *
        speed optimization  *
        XREF  *
Compiling
        native object code  *
        using Cbllink utility  *
Concurrency support  *
        installing  *
condemo.cbl  *
Conditional statement efficiency  *
Conditions  *
Configuration at run-time  *
Configuration file
        attributes tag  *
        color  *
        comment indicators  *
        comments  *
        error messages  *
        examples  * , *
        location  *
        mfcobolrc  *
        mftools  *
        mftools.cfg  *
        naming tag  *
        structure  *
        tag  *
        tag indicators  *
Configuration System
        See Application Configuration System
Configuring applications
        See Application Configuration System
CONSOLE  *
Converting signal handlers  *
Coprocessor  *
COPY limits  *
Core heap size  *
CORRESPONDING phrase  *
Coru  *
Count linkage parameters  *
Create named values  *
Ctrl key portability  *
Currency sign and National Language Support  * , *
Currency sign and NLS  *

D

Data
        fixing in memory  *
        unfixing from memory  *
Data Division  *
Data item maximum size  *
Data segments  *
Data types
        COMP-5  *
        COMP-X  *
        efficiency  *
        storage representation  *
DBCS
        support  *
        transparency  *
Debugging C subprograms  *
Decimal point  *
.def file  * , * , * , *
DEFAULTCALLS Compiler directive  *
DEFFILE Compiler directive  *
DISPLAY statement  * , *
DISPLAY UPON ENVIRONMENT-NAME  *
DISPLAY UPON ENVIRONMENT-VALUE  *
DISPLAY usage  *
DOS
        invoking COBOL from C V6.0  *
        invoking COBOL from C/C++ V7  *
DOS interrupt  *
dos.inc  *
Double-Byte Character Set support  *
Dynamically linked subprograms  *

E

EBCDIC
        collating example  *
        collating sequences  *
        converting to ASCII  *
        converting to ASCII using _CODESET  *
Editing NLS programs  *
Efficiency  *
Embedded directives and portability  *
ENDP Compiler directive  *
ENTRY  *
Entry point  * , * , * , * , * , * , * , *
Environment variables
        COBDIR  *
        COBLANG  *
        COBPOOL  * , *
        LANG  *
        NO87  *
        POOL  *
        setting  *
        XFHCONV  *
ENVIRONMENT-NAME function-name  * , *
ENVIRONMENT-VALUE function-name  * , *
EQ logic operator  *
Equivalence logic operator  *
errno in C interface  *
Error messages
        Application Configuration System  *
        Integrated Preprocessor  *
Error procedure registration  *
Error procedure routines  *
Example
        condemo.cbl program  *
        configuration file  *
        Integrated Preprocessor  *
eXclusive-OR logic operator  *
Execute program  *
EXIT  *
Exit procedure registration  *
Exit procedure routines  *
Exponent  *
External data efficiency  *
External File Mapper
        disabling  *
        environment variables  *
        test data  *

F

f51doslb.obj file  *
f51os2lb.obj file  *
FAR calls, as a result of compilation  *
Files
        c6dosif.obj  *
        c6doslb.obj  *
        c7dosif.obj  *
        c7doslb.obj  *
        cob32api.dll  *
        cob32chr.dll  *
        cob32win.dll  *
        coblibw.lib  *
        cobw  *
        f51dosif.obj  *
        f51os2if.obj  *
        grouping into libraries  *
        install.def  *
        installf.mac  *
        linitc.obj  *
        linitc31.obj  *
        linitc32.obj  *
        mfc6intf.obj  *
        mfc6intw.obj  *
        mfc7intf.obj  *
        mfc7qws.obj  *
        mfc7wins.obj  *
        minitc  *
        minitf  *
        minitp.obj  *
        portability  *
        printing  *
        winstf.def  *
        winstf.lib  *
        winstf.obj  *
Fixing data in memory  *
FLAG-CHIP Compiler directive  * , * , *
FLASH-CALLS Animator directive  * , * , *
Floating-point
        compatibility  *
        external data item  * , *
        implementation (16-bit)  *
        implementation (32-bit and 64-bit)  *
        inaccuracies  *
        limit  *
        limits  *
        literal  * , *
        support  *
FORMFEED function-name  *
FORTRAN
        Microsoft 5.1  *
        Microsoft V5.0  *
Free dynamically allocated memory  *
Freeing bitmap from printer  *

G

General protection violation  *
Generated code portability  *
GO TO statement
        efficiency  *
        inter-segment  *

H

H2cpy  *
        command-line options  *
        invoking  *
Handling large programs
        16-bit  *
        32-bit and 64-bit  *
Handling return codes  *
Header-to-COPY  *
Headers preprocessor  *
Heap routines
        close heap  *
        open heap  *
        read heap  *
        write heap  *
High-level languages
        compatibility with COBOL  *
        interfacing with  *
        mixed language programming  *
Host Compatibility Option  *

I

i87  *
IEEE floating-point  *
IF statement
        collating considerations  *
        COMPUTE  *
        efficiency  *
IMP logic operator  * , *
Inheritance  *
Initialization data  *
install.def  *
Installf  *
        creating library  * , * , * , *
        installing library  *
installf.mac  * , * , *
Instance  *
Integrated Preprocessor  *
        examples  *
        interfacing with Compiler  *
        invoking  *
        invoking multiple  *
        parameters  *
        response codes  *
        stack  *
        testing  *
        writing  *
Integration tools  *
Inter-program communication  *
        CALL  *
Intercommunication between run-units  *
Interfacing  *
        32-bit/16-bit call conversion using C Set++  *
        accessing non-COBOL data  *
        between 16-bit and 32-bit modules  *
        COBOL syntax  *
        environment  * , *
        guidlines  *
        restrictions on COBOL to C interfacing  *
        REXX  *
        run-time systems  *
        support for Windows V3  *
        support routines  *
        to assembler subprograms  *
        with high-level languages  *
        with OS/2 API routines (32-bit)  *
        with _Optlink routines  *
Interfacing to
        Lattice C  *
        Microsoft C V4.0  *
        Microsoft C V5.0  *
        Microsoft C V6.0  *
        Microsoft C/C++ V7.0  *
        Microsoft FORTRAN V5.0  *
        Microsoft FORTRAN V5.1  *
        Microsoft PASCAL  *
        Microsoft Visual C++ V1.0  *
        OS/2 API routines (16-bit)  *
        Windows API routines  *
        Windows NT API routines  *
Intermediate code
        creating portable  *
        vs native code  *
Internationalization Support  *
INTLEVEL Compiler directive  *
intrins.cbl sample program  *
Intrinsic functions
        coding  *
        in National Language Support  *
Invoking
        H2cpy  *
        Microsoft C V6 from COBOL  *
        Microsoft C/C++ V7 from COBOL  *

J

No entries

K

kbd.inc  *
Key, maximum number  *

L

L6 RTE switch  *
LANG environment variable  *
Language and National Language Support  * , *
Language levels and Integrated Preprocessor  *
Large programs
        Data Division  *
        Data Division efficiency  *
        handling (16-bit)  *
        handling (32-bit and 64-bit)  *
        MODEL Compiler directive  *
        Procedure Division  *
Lattice C  *
.lbr file  * , *
        creating  *
        editing  *
        updating  *
Lbrman
        adding files  *
        catalog  *
        commit calls  *
        create library  *
        deleting files  *
        entry point  *
        error status  *
        extracting files  *
        first file  *
        hiding files  *
        initializing  * , *
        invoking  *
        next file  *
        parameter block  *
        renaming files  *
        restoring hidden files  *
        search directory  * , *
        show hidden files  *
.lbt file  *
Library files and entry points  *
Library Manager  *
        adding files  *
        call interface  *
        catalog  *
        commit calls  *
        create library  *
        deleting files  *
        entry point  *
        error status  *
        extracting files  *
        first file  *
        hiding files  *
        initializing  * , *
        invoking  *
        next file  *
        parameter block  *
        renaming files  *
        restoring hidden files  *
        search directory  * , *
        show hidden files  *
Library routines  *
        See CBL_ routines
        See PC_ routines
        application subsystem  *
        CBL_ALLOC_MEM  *
        CBL_CLOSE_VFILE  *
        CBL_CULL_RUN_UNITS  *
        CBL_ERROR_PROC  *
        CBL_EXEC_RUN_UNIT  *
        CBL_EXIT_PROC  *
        CBL_FREE_MEM  *
        CBL_GET_OS_INFO  *
        CBL_GET_SHMEM_PTR  * , *
        CBL_OPEN_VFILE  *
        CBL_READ_VFILE  *
        CBL_SCR_SET_PC_ATTRIBUTES  *
        CBL_SUBSYSTEM  *
        CBL_TOLOWER  *
        CBL_TOUPPER  *
        CBL_WRITE_VFILE  *
        CBL_YIELD_RUN_UNIT  *
        error procedure  *
        exit procedure  *
        memory handling  *
        miscellaneous  *
        multiple run-units  * , *
        NLS  *
        operating system information  *
        PC_PRINTER_CLOSE  *
        PC_PRINTER_CONTROL  *
        PC_PRINTER_FREE_BMP  *
        PC_PRINTER_INFO  *
        PC_PRINTER_LOAD_BMP  *
        PC_PRINTER_OPEN  *
        PC_PRINTER_SET_COLOR  *
        PC_PRINTER_SET_FONT  *
        PC_PRINTER_WRITE  *
        PC_PRINTER_WRITE_BMP  *
        PC_PRINT_FILE  *
        PC_TEST_PRINTER  *
        portability  *
        printer  *
        run-units  *
        text  *
        virtual heap  *
        X"84"  *
        X"85"  *
        X"86"  *
        X"87"  *
        X"88"  *
        X"91" - function 11  *
        X"91" - function 12  *
        X"91" - function 13  *
        X"91" - function 14  *
        X"91" - function 15  *
        X"91" - function 16  *
        X"91" - function 35  *
        X"91" - function 60  *
        X"91" - function 61  *
        X"94"  *
        X"95"  *
        X"96"  *
        X"97"  *
Library routines (call-by-name)
        logic  *
        logic operators  *
        National Language Support  * , * , *
        portability  * , *
        text  *
Limits, COBOL system  *
linitc.obj file  *
linitc31.obj file  *
linitc32.obj file  *
linitio.obj  *
Linkage parameters, counting  *
Linkage Section  *
        efficiency  *
Linking
        C subprograms  * , * , *
        Cbllink utility  *
        FORTRAN subroutines  *
        Pascal subprograms  *
LITVAL-SIZE Compiler directive  *
.lnk file  *
Loading bitmap for printing  *
Local-Storage Section  * , * , *
Locale and National Language Support  *
Logic operators
        AND  *
        Calling  *
        efficiency  *
        EQuivalence  *
        eXclusive-OR  *
        IMPlies  *
        library routines  *
        NOT  *
        OR  *
Logic Routines  *
Lowercase, CBL_TOLOWER  *

M

Machine state at transfer of control  *
Managing multiple run-units  *
Maximum
        core heap size  *
        data item size  *
        EXTERNAL data item size  *
        nesting  *
        nesting of PERFORM  *
        number of keys  *
        number of names  *
        number size  *
        OCCURS (screen section)  *
        parameters in USING  *
        program size  * , * , *
        programs loaded  *
        record size  *
        relocation entries  *
        table dimensions  *
Memory
        CBL_ALLOC_MEM  *
        CBL_FREE_MEM  *
        fixing data in  *
        free dynamically allocated  *
        full error  *
        library routines  *
        mixed language applications  *
        model considerations  *
        read word from  *
        run-time system  *
        unfixing data from  *
        write word to  *
Menu Handler and Application Configuration System  *
MF Compiler directive  *
mf.ini configuration file  *
mfc6intf.obj file  *
mfc6intw.obj file  *
mfc7intf.obj file  *
mfc7qws.obj file  *
mfc7wins.obj file  *
mfcobolrc configuration file  *
Mfconfig program
        See Application Configuration System
mftools.cfg configuration file  * , *
Microsoft C
        C/CC++ V7.0  *
        V4.0  *
        V5.0  *
        V6.0  *
Microsoft C V6, subprograms on OS/2  *
Migrating applications  *
        Compiler directives  *
        Panels Version 2  *
        undefined results  *
minitc file  *
minitf file  *
minitp.obj file  *
Miscellaneous routines  *
Mixed-language programming  * , *
        accessing non-COBOL data  *
        guidelines  *
        restrictions on COBOL to C interfacing  *
        REXX  *
        support for Windows V3  *
        support functions  *
MODEL Compiler directive  *
        HUGE  *
        LARGE  *
mou.inc  *
Multi-threading  *
Multiple run-units
        concurrency  *
        dynamically allocated memory  *
        intercommunication  *
        management  *
        named values  *
Multiple signal handlers  *

N

Named values
        allocate memory  *
        create/update  *
        read  *
National Language Support
        See also NLS
        adisctrl database  *
        case conversion  * , *
        class condition tests  *
        codepage environment  *
        collating sequence  *
        currency symbol  * , * , *
        editing programs  *
        indexed sequential file  *
        intrinsic functions  *
        language environment  * , *
        library routines (call-by-name)  * , * , *
        locale  *
        %NLS%  *
        territory environment  *
        using  *
NATIVE Checker directive collating considerations  *
Native object code  *
        listing  *
NESTCALL Compiler directive  * , *
Nesting limits  *
NLS
        See National Language Support
NLS Compiler directive  *
NLS routines  *
        CBL_NLS_CLOSE_MSG_FILE  *
        CBL_NLS_COMPARE  *
        CBL_NLS_INFO  *
        CBL_NLS_OPEN_MSG_FILE  *
        CBL_NLS_READ_MSG  *
NO87 environment variable  *
Non-COBOL programs, canceling  *
NOSMALLDD Compiler directive  *
NOT logic operator  * , *
Numbers, maximum size  *
Numeric items and National Language Support  *
Numeric overflow checking  *

O

OCCURS, maximum in screen section  *
OCCURS DEPENDING ON clause, efficiency  *
ON SIZE ERROR phrase  *
        optimization  *
Opening printer  *
Operating system
        CBL_GET_OS_INFO  *
        portability features  *
Operating system information routines  *
OPT Compiler directive default  *
Optimizing
        for size with OPTSIZE  *
        for size with overlays  *
        for small program  *
        for speed at run time  *
        for speed with OPTSPEED  *
_Optlink routines  *
OR logic operator  * , * , *
Ordering parameters  *
Originator run-unit  *
OS/2
        API  *
        API (16-bit)  *
        API (32-bit)  *
        API routines  *
        interfacing between 16-bit and 32-bit modules  *
        invoking COBOL from C V6.0  *
        Microsoft C V6 programs on  *
        thread concurrency  *
Overlaying  *
        segmentation on 16-bit  *
        size optimization  *

P

Pack byte  *
Panels Version 2  *
PARAMCOUNTCHECK Compiler directive  *
Parameters  *
        alignment  *
        boundary crossing  *
        efficiency  *
        format  *
        methods of passing  *
        mismatch  *
        ordering  * , *
        passed by value  *
        passing by reference  *
        passing by value  *
        received by value  *
        removing from stack  *
Parent run-unit  *
Pascal, interfacing to  *
PC_PRINTER_CLOSE  *
PC_PRINTER_CONTROL  *
PC_PRINTER_FREE_BMP  *
PC_PRINTER_INFO  *
PC_PRINTER_LOAD_BMP  *
PC_PRINTER_OPEN  *
PC_PRINTER_SET_COLOR  *
PC_PRINTER_SET_FONT  *
PC_PRINTER_WRITE  *
PC_PRINTER_WRITE_BMP  *
PC_PRINT_FILE  *
PC_STEP_SELECTOR  *
PC_TEST_PRINTER  *
PERFORM
        efficiency  *
        inter-segment  *
        nesting  *
Performance  *
Pointer
        illegal  *
        representation  *
POOL environment variable  *
Port
        read word from  *
        write word to  *
Portability  *
        ACCEPT and DISPLAY  *
        alt/ctrl keys  *
        case sensitivity  *
        COBOL syntax  *
        Compiler directives  *
        embedding directives  *
        extended character sets  *
        file  *
        guidelines  *
        issues  *
        library routines (call-by-name)  *
        operating system features  *
        path specification  *
        requirements  *
        restrictions  *
        RM COBOL  *
        RM file status  *
        ROLLBACK statement  *
        screen I/O  *
        $SET statement  *
        source code  *
        Undefined results  *
        USAGE COMP-5  *
        user attribute byte  *
Portability routines  *
Posting signal handler  *
Precompilers  *
PREPROC.CBL  *
PREPROCESS Compiler directive  *
Preprocessor
        See Integrated Preprocessor
PREPROX.CBL  *
Printer
        closing  *
        control  *
        freeing bitmap  *
        information  *
        loading bitmap  *
        opening  *
        setting color on  *
        setting font  *
        testing  *
        writing bitmap to  *
        writing to  *
Printer channels  *
PRINTER function-name  *
Printer routines  *
Printing files  *
Procedure Division  *
proco.exe  *
Program
        cancelling non-COBOL programs  *
        check exists  *
        execute  *
        invoking assembler from COBOL  *
        invoking Microsoft C V6 from COBOL  *
        invoking Microsoft C/C++ V7 from COBOL  *
        large  *
        maximum size  * , * , *
        mixed language  *
        preserving registers  *
Program calling conventions  *
Program management in the RTE  *
Program names
        in the RTE  *
        resolving  *
PROGRAM-ID paragraph  *
        public symbols  *
Programming
        mixed language  *
        restrictions  * , *
        using OS/2 API routines  *
        using Windows API routines  *
Programming restrictions  *
Programs
        maximum animated  *
        maximum loaded  *
Protection violation  *
Public symbols, PROGRAM-ID  *

Q

QuickWindows, invoking COBOL  *

R

Read
        byte from memory  *
        byte from port  *
        programmable switch  *
        run-time switch  *
        word from port  *
Read named value  *
Read word from memory  *
REALOVL Compiler directive  *
Record, maximum size  *
Recursion  * , *
        entry point  *
REF Compiler directive  * , *
Reference modification  *
        versus STRING statement  *
Register
        preservation  *
        usage on 16-bit  *
        usage on OS/2 (32-bit)  *
        usage on Windows NT  *
Relocation entries, maximum number  *
REMAINDER phrase  *
REPLACE verb and Integrated Preprocessor  *
Representation of data types  *
Requirements
        CALL (16-bit)  *
        CALL (32-bit and 64-bit)  *
Restrictions
        programming  *
        when interfacing between C and COBOL  *
RETRYLOCK Compiler directive  *
Return code  * , *
RETURN-CODE  * , * , *
        efficiency  *
RETURNING phrase  * , *
REXX  *
RM file status portability  *
RMSTAT conversion routine  *
rmstat.obj module  *
ROLLBACK statement portability  *
ROUNDED phrase  * , *
Routines
        See Library routines
        for supporting mixed language applications  *
        logic  *
        National Language Support  *
RTNCODE-SIZE Compiler directive  *
Run-time
        configuration  *
        errors  *
        switches  *
Run-unit
        child  *
        coru  *
        library routines  *
        management  *
        originator  *
        parent  *
Run-unit routines
        allocate dynamic memory  *
        clear  *
        create run-unit  *
        create/update named value  *
        free dynamic memory  *
        read named value  *
        yield run-unit  *
Run-units
        See multiple run-units
        intercommunication  *

S

Sample programs, intrins.cbl  *
Screen handling portability  *
Screens limit  *
Searching
        in the RTE  *
        multiple directories  *
SECTION  * , *
SEG Compiler directive  *
SEGCROSS Compiler directive  * , *
Segmentation  * , * , *
        boundary crossing  * , *
Segmented program  * , *
SEGSIZE Compiler directive  * , *
SET ADDRESS statement  *
$SET statement portability  *
Setting
        color on printer  *
        printer font  *
        programmable switch  *
        run-time switch  *
Setting environment variables using Mfextmap  *
shell, calling  *
sigaction() function  *
Signal handler
        converting  *
        multiple  *
        posting  *
        signal() and sigaction()  *
        third party software  *
        writing  *
Signal handling  *
signal() function  *
SMALLDD Compiler directive  *
Sort
        algorithm for fast sort  *
        efficiency  *
SORT statement collating considerations  *
Source code portability  *
SOURCEASM Compiler directive  *
Stack
        ordering parameters on  *
        removing parameters from  *
Stack overflow  *
Static linking
        call requirements  *
        through LITLINK  *
Storage representation of data types  *
Stride  * , *
String
        CBL_NLS_COMPARE  *
        CBL_TOLOWER  *
        CBL_TOUPPER  *
STRING statement, versus reference modification  *
Subscript
        maximum number  *
        out of range  *
Subsystem routines, declare/deallocate  *
Switch
        read programmable  *
        read run-time  *
        set run-time  *
        setting programmable  *
Switches
        L6 subprogram search order  *
        run-time  *
SYSTEM
        calling  *
        calling system shell  *
System
        attributes  *
        limits  *
        specifications  *
System shell, calling  *
system(), calling  *

T

TAB function-name  *
Table handling efficiency  *
Territory environment and National Language Support  *
Testing printer  *
Text files  *
Text routines  *
        convert to lower case  *
        convert to upper case  *
Third party software and signal handlers  *
Thread-safety  *
Thunking
        interface  *
        Thunking Kit  *
tools.lbr  *
Trickle  *
TRICKLECHECK Compiler directive  *
TRUNC Compiler directive  * , *

U

Undefined results
        migrating applications  *
        portability  *
Unfixing data from memory  *
Unpack byte  *
Update named values  *
Upper case, convert string to  *
USAGE COMP-5, portability  *
USE GLOBAL AFTER, maximum number in program  *
User attribute byte portability  *
User screen, making visible  *
USING, maximum number of parameters  *
USING phrase  *
usrdef.asm  * , *
usrdef{B}.asm{D}  * , *
_USRSCRN  *
Utilities
        Cbllink  *
        Cblnames  *

V

vio.inc  *
Virtual heap routines  *

W

Win32 API routines  *
Windowing syntax, portability  *
Windows
        API  *
        API routines  *
        invoking COBOL from C V6.0  *
        invoking COBOL from C V7.0  *
        native-mode applications  *
        QuickWindows applications  * , *
Windows API  * , *
        mixed language programming  *
Windows NT, API  *
Windows V3, mixed-language programming  *
winstf, creating library  *
winstf.def  *
winstf.lib  *
winstf.mac  *
winstf.obj  *
Word
        read from memory  *
        read from port  *
        write to memory  *
        write to port  *
WRITE
        BEFORE/AFTER PAGE  *
        BEFORE/AFTER TAB  *
Write
        byte to memory  *
        byte to port  *
        word to memory  *
        word to port  *
Writing signal handler  *

X

X"84"  *
X"87"  *
X"88"  *
X"F4" - pack byte  *
X"F5" - unpack byte  *
X/Open environment variables  *
XFHCONV environment variable  *
XOR logic operator  * , * , *
XREF Compiler directive  *
        integrated preprocessor  *

Y

Yield run-unit  *

Z

No entries