| P | 
  
  
    | 
-p0 flag
     | 
  
  
    | 
-p1 or -p flag
     | 
  
  
    | 
Padding
     | 
  
  
    | 
Page
     | 
  
  
    | 
    advancing and line skipping
     | 
  
  
    | 
        report (ex.)
     | 
  
  
    | 
    logical
     | 
  
  
    | 
    physical
     | 
  
  
    | 
    size definition
     | 
  
  
    | 
Page body
     | 
  
  
    | 
Page footing
     | 
  
  
    | 
Page heading
     | 
  
  
    | 
PCA product
     | 
  
  
    | 
PERFORM n TIMES
     | 
  
  
    | 
    value of n
     | 
  
  
    | 
        compiler  implementation specifications
     | 
  
  
    | 
Performance
     | 
  
  
    | 
    and data type selection
     | 
  
  
    | 
    and intermediate data items
     | 
  
  
    | 
    compilation
     | 
  
  
    | 
    natural alignment for
     | 
  
  
    | 
    run-time
     | 
  
  
    | 
Physical block size
     | 
  
  
    | 
    compiler implementation specifications
     | 
  
  
    | 
Physical memory
     | 
  
  
    | 
    and compile performance
     | 
  
  
    | 
Physical page
     | 
  
  
    | 
    definition
     | 
  
  
    | 
PICTURE character-strings
     | 
  
  
    | 
    alphanumeric or alphabetic
     | 
  
  
    | 
        compiler  implementation specifications
     | 
  
  
    | 
    alphanumeric or numeric edited
     | 
  
  
    | 
        compiler  implementation specifications
     | 
  
  
    | 
    compiler implementation specifications
     | 
  
  
    | 
PICTURE clause
     | 
  
  
    | 
    editing symbols
     | 
  
  
    | 
    for intermediate data items
     | 
  
  
    | 
pixie
     | 
  
  
    | 
Portability
     | 
  
  
    | 
    Porting assistance
     | 
  
  
    | 
    See also Compatibility
     | 
  
  
    | 
Porting assistance
     | 
  
  
    | 
Precision
     | 
  
  
    | 
    and floating-point numbers
     | 
  
  
    | 
    and USAGE COMP
     | 
  
  
    | 
    not reduced by conversion to COMP
     | 
  
  
    | 
Primary key
     | 
  
  
    | 
    definition
     | 
  
  
    | 
    segmented
     | 
  
  
    | 
Print-control file #1
     | 
  
  
    | 
Print-control file #2
     | 
  
  
    | 
    See also Variable with fixed-control records
     | 
  
  
    | 
Procedure calls
     | 
  
  
    | 
Procedures
     | 
  
  
    | 
Productivity tools
     | 
  
  
    | 
prof
     | 
  
  
    | 
Program
     | 
  
  
    | 
    accessing another data division
     | 
  
  
    | 
    compiling
     | 
  
  
    | 
    compiling multiple files on OpenVMS Alpha
     | 
  
  
    | 
    compiling, multiple files on OpenVMS Alpha #1
     | 
  
  
    | 
    compiling, multiple files on OpenVMS Alpha #2
     | 
  
  
    | 
    compiling, multiple files on Tru64 UNIX
     | 
  
  
    | 
    compiling on OpenVMS Alpha
     | 
  
  
    | 
    contained
     | 
  
  
    | 
    creating
     | 
  
  
    | 
    driver
     | 
  
  
    | 
    running
     | 
  
  
    | 
Program conversion
     | 
  
  
    | 
    using the /STANDARD=OPENVMS_AXP qualifier option
     | 
  
  
    | 
Program development
     | 
  
  
    | 
Program listing files
     | 
  
  
    | 
    separate compilation
     | 
  
  
    | 
Program listings
     | 
  
  
    | 
    See Compiler listing files
     | 
  
  
    | 
Program run errors
     | 
  
  
    | 
    data errors
     | 
  
  
    | 
    logic errors
     | 
  
  
    | 
Program run messages
     | 
  
  
    | 
Program structure differences
     | 
  
  
    | 
    Compaq COBOL (ex.)
     | 
  
  
    | 
    Compaq COBOL for OpenVMS VAX
     | 
  
  
    | 
    using the /OPTIMIZE qualifier
     | 
  
  
    | 
Program switches
     | 
  
  
    | 
    See Switches
     | 
  
  
    | 
PROTECTED phrase
     | 
  
  
    | 
Protecting records
     | 
  
  
    | 
    automatic record locking #1
     | 
  
  
    | 
    automatic record locking #2
     | 
  
  
    | 
    automatic record locking #3
     | 
  
  
    | 
    bypassing a record lock
     | 
  
  
    | 
    concepts
     | 
  
  
    | 
    error conditions
     | 
  
  
    | 
        hard  record locks
     | 
  
  
    | 
        soft record locks
     | 
  
  
    | 
        soft record locks and  Declarative USE procedures
     | 
  
  
    | 
    manual record locking
     | 
  
  
    | 
    using record locking
     | 
  
  
    | 
Pseudocode placeholders
     | 
  
  
    | 
    unsupported by Compaq COBOL
     | 
  
  
    | Q | 
  
  
    | 
Qualifiers
     | 
  
  
    | 
    COBOL command
     | 
  
  
    | 
    with the COBOL command
     | 
  
  
    | 
QUIT command (LSE)
     | 
  
  
    | R | 
  
  
    | 
Random access mode
     | 
  
  
    | 
    specifying
     | 
  
  
    | 
ranlib command
     | 
  
  
    | 
READ NEXT statement
     | 
  
  
    | 
    changing access mode
     | 
  
  
    | 
READ PRIOR  statement
     | 
  
  
    | 
Reading files
     | 
  
  
    | 
    line sequential
     | 
  
  
    | 
    sequential
     | 
  
  
    | 
Record
     | 
  
  
    | 
    blocking, specifying
     | 
  
  
    | 
    cells
     | 
  
  
    | 
    definition
     | 
  
  
    | 
    fixed-length
     | 
  
  
    | 
    format
     | 
  
  
    | 
    locking
     | 
  
  
    | 
        Refer to Protecting records, Record locking, and File  sharing
     | 
  
  
    | 
    processing
     | 
  
  
    | 
    protection
     | 
  
  
    | 
        See Protecting records
     | 
  
  
    | 
    See also File
     | 
  
  
    | 
    space needs on a physical device
     | 
  
  
    | 
    variable-length
     | 
  
  
    | 
    variable with fixed-control
     | 
  
  
    | 
Record access mode
     | 
  
  
    | 
    definition
     | 
  
  
    | 
RECORD CONTAINS clause
     | 
  
  
    | 
Record definitions
     | 
  
  
    | 
    compiler implementation specifications
     | 
  
  
    | 
Record description #1
     | 
  
  
    | 
Record description #2
     | 
  
  
    | 
Record format
     | 
  
  
    | 
    specifying
     | 
  
  
    | 
Record-length descriptions, multiple
     | 
  
  
    | 
Record locking
     | 
  
  
    | 
    Compaq standard
     | 
  
  
    | 
    definition
     | 
  
  
    | 
    See also Protecting records
     | 
  
  
    | 
    successful
     | 
  
  
    | 
    X/Open standard
     | 
  
  
    | 
Record Management Services (RMS)
     | 
  
  
    | 
    completion codes
     | 
  
  
    | 
    See also RMS special registers
     | 
  
  
    | 
Record numbers
     | 
  
  
    | 
    cell numbers
     | 
  
  
    | 
RECORD statement
     | 
  
  
    | 
Record structures
     | 
  
  
    | 
    alignment of
     | 
  
  
    | 
RECORD VARYING clause
     | 
  
  
    | 
REDEFINES clause
     | 
  
  
    | 
    and numeric data storage #1
     | 
  
  
    | 
    and numeric data storage #2
     | 
  
  
    | 
Redefinition
     | 
  
  
    | 
    implied when inspecting data
     | 
  
  
    | 
Reference
     | 
  
  
    | 
    unresolved (linker)
     | 
  
  
    | 
REFERENCE argument-passing mechanism
     | 
  
  
    | 
Reference format
     | 
  
  
    | 
    terminal
     | 
  
  
    | 
Reference modification
     | 
  
  
    | 
Reference modification out of range
     | 
  
  
    | 
REFORMAT
     | 
  
  
    | 
    purpose of
     | 
  
  
    | 
REFORMAT utility
     | 
  
  
    | 
    converting reference format
     | 
  
  
    | 
    error messages
     | 
  
  
    | 
    running
     | 
  
  
    | 
REGARDLESS
     | 
  
  
    | 
Register usage
     | 
  
  
    | 
Relation tests
     | 
  
  
    | 
    description
     | 
  
  
    | 
    nonnumeric data
     | 
  
  
    | 
Relative file
     | 
  
  
    | 
    access modes
     | 
  
  
    | 
    AT END condition
     | 
  
  
    | 
    capabilities
     | 
  
  
    | 
    creating
     | 
  
  
    | 
        random access mode #1
     | 
  
  
    | 
        random access mode #2
     | 
  
  
    | 
        sequential access mode #1
     | 
  
  
    | 
        sequential access mode #2
     | 
  
  
    | 
    deleting records
     | 
  
  
    | 
        randomly #1
     | 
  
  
    | 
        randomly #2
     | 
  
  
    | 
        sequentially #1
     | 
  
  
    | 
        sequentially #2
     | 
  
  
    | 
        using the DELETE statement
     | 
  
  
    | 
    design considerations
     | 
  
  
    | 
    INVALID KEY condition
     | 
  
  
    | 
    invalid key condition
     | 
  
  
    | 
    open modes
     | 
  
  
    | 
    organization #1
     | 
  
  
    | 
    organization #2
     | 
  
  
    | 
        advantages
     | 
  
  
    | 
        disadvantages
     | 
  
  
    | 
        specifying
     | 
  
  
    | 
    processing #1
     | 
  
  
    | 
    processing #2
     | 
  
  
    | 
    reading
     | 
  
  
    | 
        dynamically #1
     | 
  
  
    | 
        dynamically #2
     | 
  
  
    | 
        randomly #1
     | 
  
  
    | 
        randomly #2
     | 
  
  
    | 
        sequentially #1
     | 
  
  
    | 
        sequentially #2
     | 
  
  
    | 
    record cells
     | 
  
  
    | 
    record numbers
     | 
  
  
    | 
    rewriting records
     | 
  
  
    | 
        randomly #1
     | 
  
  
    | 
        randomly #2
     | 
  
  
    | 
        sequentially #1
     | 
  
  
    | 
        sequentially #2
     | 
  
  
    | 
    rewriting records in
     | 
  
  
    | 
    See also Optimization
     | 
  
  
    | 
    SELECT statements
     | 
  
  
    | 
    specifying file organization and access mode
     | 
  
  
    | 
    tables, similarity to
     | 
  
  
    | 
    updating
     | 
  
  
    | 
        using the REWRITE statement
     | 
  
  
    | 
    usage #1
     | 
  
  
    | 
    usage #2
     | 
  
  
    | 
    valid I/O statements (tab.)
     | 
  
  
    | 
    writing
     | 
  
  
    | 
Relative indexing
     | 
  
  
    | 
    system overhead
     | 
  
  
    | 
Relative key
     | 
  
  
    | 
    definition
     | 
  
  
    | 
Relative record number
     | 
  
  
    | 
-relax_key_checking
     | 
  
  
    | 
-relax_key_checking or -rkc flag
     | 
  
  
    | 
REMAINDER phrase
     | 
  
  
    | 
REPLACE statement
     | 
  
  
    | 
    differences
     | 
  
  
    | 
        Compaq COBOL for OpenVMS VAX
     | 
  
  
    | 
        Compaq COBOL for OpenVMS VAX (ex.)
     | 
  
  
    | 
        Compaq COBOL on OpenVMS Alpha
     | 
  
  
    | 
        Compaq COBOL on OpenVMS Alpha (ex.)
     | 
  
  
    | 
        line numbers
     | 
  
  
    | 
            Compaq COBOL for OpenVMS VAX (ex.)
     | 
  
  
    | 
            Compaq COBOL on OpenVMS Alpha (ex.)
     | 
  
  
    | 
        line numbers in compiler listing files
     | 
  
  
    | 
    listing multiple instances of source line
     | 
  
  
    | 
Replacement argument
     | 
  
  
    | 
    list
     | 
  
  
    | 
        interference in
     | 
  
  
    | 
        to inspect data
     | 
  
  
    | 
Replacement value
     | 
  
  
    | 
REPLACING phrase
     | 
  
  
    | 
    to inspect data
     | 
  
  
    | 
Report
     | 
  
  
    | 
    bolding items in
     | 
  
  
    | 
    bottom margin
     | 
  
  
    | 
    components of
     | 
  
  
    | 
    components of (ex.)
     | 
  
  
    | 
    control footing
     | 
  
  
    | 
    control heading
     | 
  
  
    | 
    conventional
     | 
  
  
    | 
        controlling spacing
     | 
  
  
    | 
        line counter usage
     | 
  
  
    | 
        logical page
     | 
  
  
    | 
        logical page area (fig.)
     | 
  
  
    | 
        page-overflow condition
     | 
  
  
    | 
        page-overflow condition (ex.)
     | 
  
  
    | 
        printing
     | 
  
  
    | 
        See also Conventional Report
     | 
  
  
    | 
    design
     | 
  
  
    | 
    detail lines
     | 
  
  
    | 
    footing
     | 
  
  
    | 
    footing area
     | 
  
  
    | 
    GROUP INDICATE clause
     | 
  
  
    | 
    heading
     | 
  
  
    | 
    layout worksheet (fig.)
     | 
  
  
    | 
    linage-file report
     | 
  
  
    | 
        controlling spacing
     | 
  
  
    | 
        page advancing
     | 
  
  
    | 
        page overflow
     | 
  
  
    | 
        page overflow (ex.)
     | 
  
  
    | 
        printing
     | 
  
  
    | 
        See also Linage-file
     | 
  
  
    | 
        using the LINAGE-COUNTER
     | 
  
  
    | 
    linage-file report (ex.)
     | 
  
  
    | 
    logical page #1
     | 
  
  
    | 
    logical page #2
     | 
  
  
    | 
    makeup
     | 
  
  
    | 
    modes of printing
     | 
  
  
    | 
    page advancing and line skipping (ex.)
     | 
  
  
    | 
    page body
     | 
  
  
    | 
    page footing
     | 
  
  
    | 
    page heading
     | 
  
  
    | 
    physical page
     | 
  
  
    | 
    printing
     | 
  
  
    | 
    printing totals before detail lines
     | 
  
  
    | 
    problem solving
     | 
  
  
    | 
        bolding items
     | 
  
  
    | 
        example #1
     | 
  
  
    | 
        example #2
     | 
  
  
    | 
        GROUP INDICATE clause
     | 
  
  
    | 
        logical lines
     | 
  
  
    | 
        physical lines
     | 
  
  
    | 
        physical page
     | 
  
  
    | 
        printing #1
     | 
  
  
    | 
        printing #2
     | 
  
  
    | 
        printing #3
     | 
  
  
    | 
            bold
     | 
  
  
    | 
            details
     | 
  
  
    | 
            totals
     | 
  
  
    | 
        underlining
     | 
  
  
    | 
    RESET phrase
     | 
  
  
    | 
    spooling
     | 
  
  
    | 
    streamlining your
     | 
  
  
    | 
    top margin
     | 
  
  
    | 
    total accumulating
     | 
  
  
    | 
        crossfoot totals
     | 
  
  
    | 
        crossfooting
     | 
  
  
    | 
        defining
     | 
  
  
    | 
        incrementing
     | 
  
  
    | 
        RESET phrase
     | 
  
  
    | 
        rolled forward totals
     | 
  
  
    | 
        rolling-forward
     | 
  
  
    | 
        subtotals #1
     | 
  
  
    | 
        subtotals #2
     | 
  
  
    | 
        UPON phrase
     | 
  
  
    | 
    total accumulating (fig.)
     | 
  
  
    | 
    underlining in
     | 
  
  
    | 
    UPON phrase
     | 
  
  
    | 
    USE BEFORE REPORTING statement
     | 
  
  
    | 
Report file
     | 
  
  
    | 
    number of lines
     | 
  
  
    | 
        compiler implementation specifications
     | 
  
  
    | 
Report groups
     | 
  
  
    | 
    sample report using all seven (fig.)
     | 
  
  
    | 
Report Writer
     | 
  
  
    | 
    assigning a value in a print line
     | 
  
  
    | 
    assigning the source for a print field
     | 
  
  
    | 
    COLUMN NUMBER clause
     | 
  
  
    | 
    CONTROL clause
     | 
  
  
    | 
    detail reporting
     | 
  
  
    | 
    examples
     | 
  
  
    | 
        detail report #1
     | 
  
  
    | 
        detail report #2
     | 
  
  
    | 
        detail report #3
     | 
  
  
    | 
        detail report #4
     | 
  
  
    | 
        input data
     | 
  
  
    | 
        summary report
     | 
  
  
    | 
    first GENERATE statement (fig.)
     | 
  
  
    | 
    footings
     | 
  
  
    | 
        controlling
     | 
  
  
    | 
        generating
     | 
  
  
    | 
    GENERATE statement
     | 
  
  
    | 
    headings
     | 
  
  
    | 
        controlling
     | 
  
  
    | 
        generating
     | 
  
  
    | 
    INITIATE statement
     | 
  
  
    | 
    LINE clause
     | 
  
  
    | 
    logical page
     | 
  
  
    | 
        defining
     | 
  
  
    | 
        horizontal spacing
     | 
  
  
    | 
        vertical spacing
     | 
  
  
    | 
    PAGE clause
     | 
  
  
    | 
    printing
     | 
  
  
    | 
        GROUP INDICATE clause
     | 
  
  
    | 
    processing a Report Writer report
     | 
  
  
    | 
        detail reporting
     | 
  
  
    | 
        GENERATE statement #1
     | 
  
  
    | 
        GENERATE statement #2
     | 
  
  
    | 
        initiating
     | 
  
  
    | 
        suppressing a report group
     | 
  
  
    | 
        terminating processing
     | 
  
  
    | 
        USE BEFORE REPORTING statement
     | 
  
  
    | 
    Programming
     | 
  
  
    | 
    REPORT clause #1
     | 
  
  
    | 
    REPORT clause #2
     | 
  
  
    | 
    Report Description entry
     | 
  
  
    | 
    Report File
     | 
  
  
    | 
        defining
     | 
  
  
    | 
    report group types (tab.)
     | 
  
  
    | 
    report groups #1
     | 
  
  
    | 
    report groups #2
     | 
  
  
    | 
    Report Section
     | 
  
  
    | 
        defining
     | 
  
  
    | 
    SOURCE clause
     | 
  
  
    | 
    specifying multiple reports
     | 
  
  
    | 
    subsequent GENERATE statements (fig.)
     | 
  
  
    | 
    SUPPRESS statement
     | 
  
  
    | 
    TERMINATE statement
     | 
  
  
    | 
    TERMINATE statement (fig.)
     | 
  
  
    | 
    using Declarative procedures #1
     | 
  
  
    | 
    using Declarative procedures #2
     | 
  
  
    | 
    VALUE clause
     | 
  
  
    | 
RESERVE AREAS clause
     | 
  
  
    | 
    value of integers
     | 
  
  
    | 
        compiler implementation  specifications
     | 
  
  
    | 
Reserved words
     | 
  
  
    | 
    compatibility with Compaq COBOL for OpenVMS VAX
     | 
  
  
    | 
/RESERVED_WORDS qualifier
     | 
  
  
    | 
    Compaq COBOL support for
     | 
  
  
    | 
Restrictions on interprogram communication
     | 
  
  
    | 
RETURN-CODE
     | 
  
  
    | 
RISC architecture
     | 
  
  
    | 
RMS completion codes, using
     | 
  
  
    | 
RMS special registers
     | 
  
  
    | 
    differences #1
     | 
  
  
    | 
    differences #2
     | 
  
  
    | 
    list of
     | 
  
  
    | 
    RMS-CURRENT-FILENAME #1
     | 
  
  
    | 
    RMS-CURRENT-FILENAME #2
     | 
  
  
    | 
    RMS-CURRENT-STS #1
     | 
  
  
    | 
    RMS-CURRENT-STS #2
     | 
  
  
    | 
    RMS-CURRENT-STV #1
     | 
  
  
    | 
    RMS-CURRENT-STV #2
     | 
  
  
    | 
    RMS-FILENAME #1
     | 
  
  
    | 
    RMS-FILENAME #2
     | 
  
  
    | 
    RMS-STS #1
     | 
  
  
    | 
    RMS-STS #2
     | 
  
  
    | 
    RMS-STS #3
     | 
  
  
    | 
    RMS-STV #1
     | 
  
  
    | 
    RMS-STV #2
     | 
  
  
    | 
    RMS_CURRENT_STS
     | 
  
  
    | 
    RMS_CURRENT_STV
     | 
  
  
    | 
    RMS_STS #1
     | 
  
  
    | 
    RMS_STS #2
     | 
  
  
    | 
ROUNDED phrase
     | 
  
  
    | 
    with SIZE ERROR
     | 
  
  
    | 
Rounding off arithmetic results
     | 
  
  
    | 
Routines
     | 
  
  
    | 
    Named "main"
     | 
  
  
    | 
-rsv
     | 
  
  
    | 
-rsv foreign_extensions flag
     | 
  
  
    | 
-rsv [no]200x flag
     | 
  
  
    | 
-rsv [no]foreign_extensions
     | 
  
  
    | 
-rsv [no]xopen flag
     | 
  
  
    | 
RUN command
     | 
  
  
    | 
    on OpenVMS Alpha
     | 
  
  
    | 
    syntax, on OpenVMS Alpha
     | 
  
  
    | 
Run time
     | 
  
  
    | 
    accessing environment variables
     | 
  
  
    | 
    accessing environment variables (ex.)
     | 
  
  
    | 
    accessing logicals
     | 
  
  
    | 
    errors
     | 
  
  
    | 
        example of
     | 
  
  
    | 
    input/output messages
     | 
  
  
    | 
    messages
     | 
  
  
    | 
        format
     | 
  
  
    | 
        input/output errors
     | 
  
  
    | 
        interpreting
     | 
  
  
    | 
        program run errors
     | 
  
  
    | 
Run-Time Library routines
     | 
  
  
    | 
    cobcall
     | 
  
  
    | 
    cobcancel
     | 
  
  
    | 
    cobfunc
     | 
  
  
    | 
Run-time storage
     | 
  
  
    | 
    compiler implementation specifications #1
     | 
  
  
    | 
    compiler implementation specifications #2
     | 
  
  
    | 
Run unit
     | 
  
  
    | 
    examples of COBOL
     | 
  
  
    | 
    including non-COBOL programs
     | 
  
  
    | 
    multiple COBOL program
     | 
  
  
    | 
Running Compaq COBOL programs
     | 
  
  
    | 
    on OpenVMS Alpha
     | 
  
  
    | 
    on Tru64 UNIX
     |