Editing Naming and Coding Standards

<span id="naming-and-coding-standard-cobol"></span>
= Naming and Coding Standard — COBOL =

{|
!width="23%"| Field
!width="76%"| Value
|-
| Document ID
| PGCBL-NCS-001
|-
| Document Type
| Naming and Coding Standard
|-
| System
| pgcobol — Prime Numbers Application v1.0
|-
| Applies to
| All GnuCOBOL source files (<code>.cbl</code>) and copybooks (<code>.cpy</code>)
|-
| Version
| 1.0
|-
| Status
| Approved
|-
| Owner
| Lead Developer
|-
| Author
| Derived from: IBM Enterprise COBOL Coding Guidelines, GnuCOBOL Best Practices, Micro Focus COBOL Standards, and observation of existing pgcobol source
|-
| Created
| 2026-03-17
|-
| Last modified
| 2026-03-17
|-
| Classification
| Internal
|}

<span id="version-history"></span>
== Version History ==

{|
!width="16%"| Version
!width="22%"| Date
!width="15%"| Author
!width="15%"| Status
!width="30%"| Change Summary
|-
| 0.1
| 2026-03-17
| —
| Draft
| Initial standard from source analysis
|-
| 1.0
| 2026-03-17
| —
| Approved
| Baselined
|}


-----

<span id="table-of-contents"></span>
== Table of Contents ==

# [[#1-standards-basis|Standards Basis]]
# [[#2-source-file-conventions|Source File Conventions]]
# [[#3-division-and-section-structure|Division and Section Structure]]
# [[#4-data-naming-conventions|Data Naming Conventions]]
# [[#5-paragraph-naming-conventions|Paragraph Naming Conventions]]
# [[#6-procedure-division-coding-rules|Procedure Division Coding Rules]]
# [[#7-sql-embedding-conventions|SQL Embedding Conventions]]
# [[#8-commentary-standards|Commentary Standards]]
# [[#9-copybook-standards|Copybook Standards]]
# [[#10-method-dispatch-pattern-standard|Method-Dispatch Pattern Standard]]
# [[#11-error-handling-standard|Error Handling Standard]]
# [[#12-compliance-checklist|Compliance Checklist]]
# [[#13-open-issues|Open Issues]]


-----

<span id="standards-basis"></span>
== 1. Standards Basis ==

This standard synthesises rules from the following well-known and published sources:

{|
!width="50%"| Source
!width="50%"| What it contributes
|-
| '''ISO/IEC 1989:2014''' (COBOL 2014 standard)
| Syntax compliance baseline
|-
| '''IBM Enterprise COBOL Programming Guide (SC27-1460)'''
| Naming conventions, data division layout, structured programming
|-
| '''Micro Focus COBOL Coding Standards'''
| Paragraph prefixing, copybook discipline, comment headers
|-
| '''GnuCOBOL Programmer’s Guide'''
| GnuCOBOL-specific extensions and limitations
|-
| '''NIST COBOL Test Suite conventions'''
| Identifier uniqueness and column discipline
|-
| '''Yourdon / Constantine structured design'''
| Module cohesion, coupling reduction — applied to COBOL tiers
|-
| '''pgcobol source'''
| Existing conventions extracted and formalised
|}


-----

<span id="source-file-conventions"></span>
== 2. Source File Conventions ==

<span id="file-names"></span>
=== 2.1 File names ===

<pre>&lt;program-id&gt;.cbl          Main program source
&lt;copybook-name&gt;.cpy       Copybook source
&lt;program-id&gt;.cbsql        GixSQL pre-processor input (if SQL present)
&lt;program-id&gt;_cbsql.out    GixSQL pre-processor listing (generated; do not edit)</pre>
* All lowercase.
* Hyphens as word separators (not underscores) for new files. Underscores are a legacy convention in this codebase (<code>primes_table.cpy</code>); new files use hyphens.
* The <code>PROGRAM-ID</code> in the source must match the filename exactly (case-insensitive).

<span id="column-discipline"></span>
=== 2.2 Column discipline ===

GnuCOBOL supports both fixed-format (traditional) and free-format source. This codebase uses '''fixed format''':

<pre>Columns 1–6    Sequence number area (blank in new code; used by legacy tools)
Column  7      Indicator area: space = code, * = comment, / = page eject, - = continuation
Columns 8–11   Area A: DIVISION, SECTION, paragraph names, 01/77-level data
Columns 12–72  Area B: all other code
Columns 73–80  Identification area (optional; ignored by compiler)</pre>
'''Rule:''' All paragraph names and top-level items begin in column 8 (Area A). All subordinate code begins at column 12 or beyond (Area B).


-----

<span id="division-and-section-structure"></span>
== 3. Division and Section Structure ==

<span id="mandatory-division-order"></span>
=== 3.1 Mandatory division order ===

Every program must contain these divisions in this order:

<pre>IDENTIFICATION DIVISION.
  PROGRAM-ID.
  (AUTHOR. — optional)
  (DATE-WRITTEN. — optional)

ENVIRONMENT DIVISION.
  CONFIGURATION SECTION.
    SOURCE-COMPUTER.
    OBJECT-COMPUTER.
    SPECIAL-NAMES.
  INPUT-OUTPUT SECTION.      (only if files are used)
    FILE-CONTROL.

DATA DIVISION.
  FILE SECTION.              (only if files are used)
  WORKING-STORAGE SECTION.
  LINKAGE SECTION.           (only for called programs)

PROCEDURE DIVISION [USING ...].</pre>
<span id="working-storage-section-order"></span>
=== 3.2 Working-Storage section order ===

Items in WORKING-STORAGE must appear in this order:

# Debug marker filler (01 FILLER PIC X(32) VALUE “Start WS <program>”) — for memory-dump readability.
# File status fields (if any files).
# Constants (01 level, VALUE clause, no modification at runtime).
# Work fields grouped by function.
# COPY statements for local copybooks (primes-ui, primes-dal, etc.).

<span id="linkage-section"></span>
=== 3.3 Linkage section ===

The linkage section must contain only COPY statements referencing the published inter-tier copybooks. No fields should be defined directly in the LINKAGE SECTION of a standard program.


-----

<span id="data-naming-conventions"></span>
== 4. Data Naming Conventions ==

<span id="general-rules"></span>
=== 4.1 General rules ===

{|
!width="50%"| Rule
!width="50%"| Rationale
|-
| Use hyphens as word separators: <code>test-number</code>, not <code>testNumber</code> or <code>test_number</code>
| COBOL convention; underscores are non-standard in some compilers
|-
| Maximum name length: 30 characters (COBOL 85 limit)
| Portability
|-
| Names must be meaningful: no single-letter names except loop indexes
| Readability
|-
| Avoid COBOL reserved words and common abbreviations that conflict (e.g. <code>LENGTH</code>, <code>SPACE</code>)
| Prevents ambiguity
|-
| Prefix 88-level condition names with the purpose they test, not the field name
| <code>dal-method-ok</code> not <code>dal-result-zero</code>
|}

<span id="level-number-conventions"></span>
=== 4.2 Level number conventions ===

{|
!width="50%"| Level
!width="50%"| Use
|-
| 01
| Group items, independent items, copybook roots
|-
| 03, 05, 07
| Subordinate group and elementary items (use odd numbers: 01, 03, 05, 07 …)
|-
| 66
| RENAMES clause (use sparingly)
|-
| 77
| Independent elementary items (prefer 01 unless 77 is clearly appropriate)
|-
| 88
| Condition names; always immediately under the field they qualify
|}

'''Rule:''' Use odd-numbered levels (01, 03, 05, 07, 09) to allow insertion of intermediate levels without renumbering. Never use even levels in new code.

<span id="naming-prefixes-for-scope"></span>
=== 4.3 Naming prefixes for scope ===

{|
!width="33%"| Prefix
!width="33%"| Meaning
!width="33%"| Example
|-
| <code>r-</code>
| Record / row field (fetched from DB)
| <code>r-ident</code>, <code>r-prime</code>
|-
| <code>u-</code>
| UI-layer field (in primes-ui block)
| <code>u-sequence</code>, <code>u-number</code>
|-
| <code>t-</code>
| Table cell / temporary print field
| <code>t-ident</code>, <code>t-prime</code>
|-
| <code>f-</code>
| Formatted / print-ready field
| <code>f-page-number</code>
|-
| <code>w-</code>
| Work field (local computation)
| <code>w-remainder</code>
|}

<span id="picture-clause-conventions"></span>
=== 4.4 Picture clause conventions ===

{|
!width="33%"| Type
!width="33%"| Preferred PICTURE
!width="33%"| Notes
|-
| Positive integer, display
| <code>9(n)</code>
| n ≤ 9 for standard arithmetic
|-
| Signed integer, display
| <code>S9(n)</code>
| Use S prefix for fields that can go negative or are SQL host variables
|-
| Packed decimal
| <code>S9(n) COMP-3</code>
| For high-volume arithmetic and SQL host variables
|-
| Binary integer
| <code>S9(n) COMP-5</code>
| For SQLCA fields and counters needing maximum performance
|-
| Fixed decimal
| <code>9(n)V9(m)</code>
| V = implied decimal point; no actual decimal character stored
|-
| Alphanumeric
| <code>X(n)</code>
| For text, method verbs, messages
|-
| Edited numeric (print)
| <code>Z(n)9</code> or <code>Z(n)</code>
| For zero-suppressed print output only; never used in arithmetic
|-
| Boolean flag
| <code>9(1)</code> with 88-levels
| e.g. <code>PIC 9 VALUE 1. 88 new-page VALUE 1.</code>
|}

<span id="level-condition-names"></span>
=== 4.5 88-level condition names ===

* Must be named for what is '''true''' when the condition fires, not for the value: <code>session-method-ok</code> not <code>result-is-zero</code>.
* Result-code 88-levels must cover all meaningful values; add a <code>88 invalid-method VALUE &quot;bad&quot;</code> sentinel.
* Multiple conditions for the same field must have non-overlapping VALUES.

<span id="copybook-field-naming"></span>
=== 4.6 Copybook field naming ===

* Fields in a copybook must be globally unique across all copybooks in the project (COBOL does not namespace copybooks).
* Prefix copybook fields with the copybook’s logical name: <code>dal-methods</code>, <code>ui-method-result</code>, <code>session-result</code>.


-----

<span id="paragraph-naming-conventions"></span>
== 5. Paragraph Naming Conventions ==

This project uses a '''prefix-number naming scheme''' derived from IBM COBOL shop practice:

<span id="prefix-codes"></span>
=== 5.1 Prefix codes ===

{|
!width="33%"| Prefix
!width="33%"| Meaning
!width="33%"| Example
|-
| <code>r</code>
| Regular processing paragraph (business logic, I/O)
| <code>r80-test-number</code>
|-
| <code>s</code>
| System / infrastructure paragraph (DB connect, file open)
| <code>s00-connect</code>
|-
| <code>e</code>
| Error-handling paragraph
| <code>e10-handle-db-error</code>
|-
| <code>x</code>
| Exit / cleanup paragraph (always PERFORM last)
| <code>x99-shutdown</code>
|}

<blockquote>'''Observation from existing source:''' The project uses <code>r</code> and <code>s</code> prefixes already. The <code>e</code> and <code>x</code> prefixes are introduced here as an extension. The <code>r99</code> convention for shutdown paragraphs is retained.
</blockquote>
<span id="numbering"></span>
=== 5.2 Numbering ===

* Two-digit sequence: <code>00</code>, <code>10</code>, <code>20</code> … <code>90</code>, <code>99</code>.
* Low numbers (00–29): initialisation / setup.
* Mid numbers (30–79): main processing.
* High numbers (80–89): sub-processing / helpers.
* 90–98: cleanup and close.
* 99: final exit / stop.
* Leave gaps of 10 between paragraphs to allow insertion.

<span id="name-format"></span>
=== 5.3 Name format ===

<pre>&lt;prefix&gt;&lt;NN&gt;-&lt;short-hyphenated-description&gt;

Examples:
  r80-test-number
  r82-next-test-number
  r85-write-prime
  r89-get-next-divider
  r90-start-primes-report
  r99-close-primes
  s00-connect
  s01-cursor
  s02-fetch
  s99-disconnect</pre>
<span id="rules"></span>
=== 5.4 Rules ===

* Paragraph names must be unique within the program.
* A paragraph must do one thing. If it needs a comment explaining “also does X”, split it.
* Paragraphs called only from one place may be inlined (PERFORM vs inline code) — choose consistency over micro-optimisation.
* Never use <code>GO TO</code> except for the structured <code>GO TO &lt;paragraph&gt;</code> used as a skip (an accepted COBOL idiom). Do not use <code>ALTER</code>.


-----

<span id="procedure-division-coding-rules"></span>
== 6. Procedure Division Coding Rules ==

<span id="structured-programming"></span>
=== 6.1 Structured programming ===

All control flow must use structured constructs:

{|
!width="50%"| Construct
!width="50%"| Use for
|-
| <code>PERFORM &lt;paragraph&gt;</code>
| Single call to a named paragraph
|-
| <code>PERFORM &lt;paragraph&gt; UNTIL &lt;condition&gt;</code>
| Loops with pre-test condition
|-
| <code>EVALUATE TRUE … WHEN … END-EVALUATE</code>
| Multi-way branch (preferred over nested IF)
|-
| <code>IF … ELSE … END-IF</code>
| Two-way branch
|-
| <code>NEXT SENTENCE</code>
| Skip remainder of sentence (used sparingly; prefer END-IF)
|}

'''Never use:''' - <code>GO TO</code> (except structured skip idiom in legacy contexts) - <code>ALTER</code> - <code>PERFORM … THRU</code> (couples paragraphs; prefer explicit PERFORM chains)

<span id="evaluate-true-convention"></span>
=== 6.2 EVALUATE TRUE convention ===

The method-dispatch EVALUATE always takes this form:

<syntaxhighlight lang="cobol">EVALUATE TRUE
  WHEN <condition-name-1>
    PERFORM <paragraph>
  WHEN <condition-name-2>
    PERFORM <paragraph>
  WHEN OTHER
    MOVE 1 TO <result-field>
END-EVALUATE.</syntaxhighlight>
* Every EVALUATE must have a <code>WHEN OTHER</code> clause.
* The <code>WHEN OTHER</code> must set a meaningful error indicator; it must never be a no-op.

<span id="perform-until"></span>
=== 6.3 PERFORM … UNTIL ===

* The loop condition is checked '''before''' the first iteration (test-before / DO-WHILE reversed).
* Infinite loops are not permitted. Every PERFORM UNTIL must have a reachable exit condition.
* Loop termination must be tested and documented in the program logic guide.

<span id="call-conventions"></span>
=== 6.4 CALL conventions ===

* All inter-program calls use <code>CALL &quot;literal&quot; USING &lt;data-block&gt;</code>.
* The called program name must be a string literal, not a data name (for static linkage and security).
* Always check the result field of the called program’s control block immediately after the CALL.

<span id="arithmetic"></span>
=== 6.5 Arithmetic ===

* Use <code>COMPUTE</code> for complex expressions: <code>COMPUTE x = a ** 0.5</code>.
* Use <code>ADD … TO</code>, <code>SUBTRACT … FROM</code>, <code>MULTIPLY … BY</code>, <code>DIVIDE … BY … GIVING … REMAINDER</code> for simple operations.
* Always use <code>GIVING</code> and <code>REMAINDER</code> clauses to avoid in-place modification of source operands.
* Always check for zero divisor before DIVIDE.
* Declare intermediate results with sufficient precision to avoid truncation: <code>PIC 9(9)V9(9)</code> for square-root results.


-----

<span id="sql-embedding-conventions"></span>
== 7. SQL Embedding Conventions ==

<span id="exec-sql-block-layout"></span>
=== 7.1 EXEC SQL block layout ===

<syntaxhighlight lang="cobol">           EXEC SQL [AT <connection-alias>]
             <sql statement>
           END-EXEC.</syntaxhighlight>
* <code>EXEC SQL</code> on its own line, indented to Area B.
* SQL keywords in uppercase.
* Host variable prefix <code>:</code> immediately before the variable name, no space.
* <code>END-EXEC.</code> on its own line, followed by a period.

<span id="host-variable-declaration"></span>
=== 7.2 Host variable declaration ===

* All SQL host variables must be declared via <code>EXEC SQL INCLUDE &lt;copybook&gt; END-EXEC</code> or directly in WORKING-STORAGE.
* Host variables for row-level data must be grouped under a 01-level record that mirrors the table structure.
* Use <code>COMP-3</code> for numeric host variables for performance.

<span id="sqlcode-checking"></span>
=== 7.3 SQLCODE checking ===

Every EXEC SQL block must be followed immediately by a SQLCODE check:

<syntaxhighlight lang="cobol">           EXEC SQL ... END-EXEC.

           IF SQLCODE = 0 THEN
             <success path>
           ELSE
             MOVE SQLERRMC TO program-message
             PERFORM e10-handle-sql-error
           END-IF.</syntaxhighlight>
* Never fall through after an unchecked SQL statement.
* Log <code>SQLCODE</code> and <code>SQLERRMC</code> on every error path.

<span id="cursor-naming"></span>
=== 7.4 Cursor naming ===

<pre>&lt;table-name&gt;cursor

Example: primescursor (cursor on the primes table)</pre>
<span id="connection-alias-naming"></span>
=== 7.5 Connection alias naming ===

<pre>&lt;database-name&gt;

Example: primes (alias for the primes database connection)</pre>
The alias must be consistent across all <code>AT &lt;alias&gt;</code> clauses and the CONNECT/RESET statements.


-----

<span id="commentary-standards"></span>
== 8. Commentary Standards ==

<span id="program-header-block"></span>
=== 8.1 Program header block ===

Every <code>.cbl</code> file must open with a standardised comment block in columns 7–72:

<syntaxhighlight lang="cobol">      *=================================================================
      * Program:    <PROGRAM-ID>
      * Document:   <PGCBL-PLG-NNN>
      * Purpose:    <one sentence>
      * Tier:       Orchestrator | Business Logic | Data Access | UI
      * Calls:      <list of programs this program calls>
      * Called by:  <list of programs that call this program>
      * Copybooks:  <list of copybooks copied>
      * Author:     <name>
      * Created:    YYYY-MM-DD
      * Modified:   YYYY-MM-DD <name> <change summary>
      *=================================================================</syntaxhighlight>
<span id="paragraph-headers"></span>
=== 8.2 Paragraph headers ===

Every paragraph must have a comment immediately before it:

<syntaxhighlight lang="cobol">      *-----------------------------------------------------------------
      * r80-test-number
      *   Tests whether test-number is prime by trial division.
      *   Called by: PERFORM UNTIL test-number = 999999999
      *   Uses: test-number, test-divider, test-number-sqr, test-rest
      *-----------------------------------------------------------------
       r80-test-number.</syntaxhighlight>
<span id="inline-comments"></span>
=== 8.3 Inline comments ===

* Use <code>*&gt;</code> (GnuCOBOL free-format inline comment) or a <code>*</code> in column 7 for a full-line comment.
* Comment the '''why''', not the '''what''': the code shows what; the comment explains why.
* Every EXEC SQL block must have a comment above it stating what it does and under what conditions it is called.

<syntaxhighlight lang="cobol">      * Fetch the next prime from the cursor.
      * Called after every successful report loop iteration.
           EXEC SQL FETCH primescursor INTO :primes-row END-EXEC.</syntaxhighlight>
<span id="prohibited-comment-patterns"></span>
=== 8.4 Prohibited comment patterns ===

* Do not comment out code and leave it in the source permanently. Use version control instead.
* Do not write comments that merely restate the code: <code>* MOVE 1 TO X (moves 1 to X)</code>.


-----

<span id="copybook-standards"></span>
== 9. Copybook Standards ==

<span id="file-name-and-content-rules"></span>
=== 9.1 File name and content rules ===

* Each copybook defines exactly one logical structure (one 01-level group).
* The copybook file name matches the 01-level name: <code>primes-dal.cpy</code> defines <code>01 primes-dal</code>.
* Copybooks must not contain PROCEDURE DIVISION code.
* Copybooks must not contain COPY statements (no nested copies).

<span id="copybook-header"></span>
=== 9.2 Copybook header ===

Every copybook must open with:

<syntaxhighlight lang="cobol">      *=================================================================
      * Copybook: <name>.cpy
      * Purpose:  <one sentence>
      * Used by:  <list of programs>
      * Document: <PGCBL-DDD-001> §<section>
      *=================================================================</syntaxhighlight>
<span id="change-control"></span>
=== 9.3 Change control ===

* Any change to a copybook is a '''breaking change''' for all programs that include it.
* Changes must be accompanied by a recompilation of all affected programs.
* The copybook version history must be updated in the header comment.

<span id="canonical-copybook-rule"></span>
=== 9.4 Canonical copybook rule ===

Where two copybooks define the same structure (e.g. <code>primes-table.cpy</code> and <code>primes_table.cpy</code>), one must be designated canonical and the other deprecated and removed. The canonical version is documented in the Data Dictionary.


-----

<span id="method-dispatch-pattern-standard"></span>
== 10. Method-Dispatch Pattern Standard ==

This pattern is the core inter-tier communication mechanism. These rules ensure it is applied consistently.

<span id="control-block-layout"></span>
=== 10.1 Control block layout ===

<syntaxhighlight lang="cobol">       01 <tier>-<control-block>.
        03 <tier>-methods         PIC X(32).
         88 <verb-1>              VALUE "<verb-1-string>".
         88 <verb-2>              VALUE "<verb-2-string>".
         88 invalid-method        VALUE "bad".
        03 <data-payload-group>.
         05 <field-1>             PIC ...
        03 <tier>-result          PIC 9(2)  VALUE ZERO.
         88 <tier>-method-ok      VALUE 0.
         88 <tier>-method-nok     VALUE 1.
         88 <tier>-method-eof     VALUE 9.</syntaxhighlight>
<span id="result-code-convention"></span>
=== 10.2 Result code convention ===

{|
!width="33%"| Value
!width="33%"| 88-level name
!width="33%"| Meaning
|-
| 0
| <code>&lt;tier&gt;-method-ok</code>
| Operation succeeded
|-
| 1
| <code>&lt;tier&gt;-method-nok</code>
| Operation failed (error)
|-
| 9 or 99
| <code>&lt;tier&gt;-method-eof</code>
| End of data (cursor exhausted, no more rows)
|}

* All tiers must use these values consistently.
* No other result codes may be introduced without updating this standard and the Data Dictionary.

<span id="caller-obligations"></span>
=== 10.3 Caller obligations ===

<syntaxhighlight lang="cobol">           MOVE "<verb>" TO <tier>-methods.
           CALL "<program>" USING <control-block>.
           IF <tier>-method-ok THEN
             <success path>
           ELSE
             <error path — must not be empty>
           END-IF.</syntaxhighlight>
* The caller must always check the result immediately after the CALL.
* An unchecked result is a coding error.

<span id="callee-obligations"></span>
=== 10.4 Callee obligations ===

* The callee must set the result field before EXIT PROGRAM on every code path.
* The callee must handle <code>WHEN OTHER</code> in the EVALUATE and set result to 1 (nok).
* The callee must not STOP RUN (only EXIT PROGRAM); the caller decides whether to stop.


-----

<span id="error-handling-standard"></span>
== 11. Error Handling Standard ==

<span id="sql-errors"></span>
=== 11.1 SQL errors ===

Every EXEC SQL block must check SQLCODE as specified in §7.3. On error:

# Move <code>SQLERRMC</code> to <code>program-message</code>.
# Set the tier’s result field to 1 (nok).
# Call primesui with <code>ui-methods = &quot;log-message&quot;</code> to log the error.
# EXIT PROGRAM — do not STOP RUN from within a subprogram.

<span id="file-io-errors"></span>
=== 11.2 File I/O errors ===

Every file OPEN, READ, WRITE, CLOSE must check the file-status field:

<syntaxhighlight lang="cobol">           IF <file>-status = "00" THEN
             <success>
           ELSE
             MOVE <file>-status TO program-message
             PERFORM r98-message-ui
             MOVE 1 TO ui-method-result
           END-IF.</syntaxhighlight>
<span id="return-code"></span>
=== 11.3 Return code ===

At the end of <code>primesmain</code> (the only <code>STOP RUN</code> in the system), set the process return code:

<syntaxhighlight lang="cobol">           IF <any-error-indicator> THEN
             MOVE 1 TO RETURN-CODE
           ELSE
             MOVE 0 TO RETURN-CODE
           END-IF.
           STOP RUN.</syntaxhighlight>

-----

<span id="compliance-checklist"></span>
== 12. Compliance Checklist ==

Use this checklist during code review:

<span id="structure"></span>
=== Structure ===

* ☐ Program header block present and complete.
* ☐ All divisions in correct order.
* ☐ WORKING-STORAGE follows the prescribed section order.
* ☐ LINKAGE SECTION contains only COPY statements.

<span id="naming"></span>
=== Naming ===

* ☐ All paragraph names follow <code>&lt;prefix&gt;&lt;NN&gt;-&lt;description&gt;</code> scheme.
* ☐ All data names use hyphens, not underscores (except legacy names).
* ☐ 88-level names describe the true condition, not the value.
* ☐ Copybook fields are globally unique and prefixed with the copybook’s logical name.

<span id="procedure-division"></span>
=== Procedure Division ===

* ☐ No GO TO (except structured skip).
* ☐ No PERFORM … THRU.
* ☐ Every EVALUATE has WHEN OTHER.
* ☐ Every CALL is followed by a result check.
* ☐ Every EXEC SQL is followed by a SQLCODE check.
* ☐ Every file operation is followed by a file-status check.
* ☐ RETURN-CODE is set before STOP RUN in primesmain.

<span id="comments"></span>
=== Comments ===

* ☐ Every paragraph has a comment header.
* ☐ Every EXEC SQL block has a purpose comment.
* ☐ No commented-out code left in permanent source.

<span id="copybooks"></span>
=== Copybooks ===

* ☐ Each copybook defines exactly one 01-level structure.
* ☐ Copybook file name matches the 01-level name.
* ☐ No nested COPY statements.
* ☐ Copybook header present.


-----

<span id="open-issues"></span>
== 13. Open Issues ==

{|
!width="18%"| ID
!width="18%"| Issue
!width="18%"| Owner
!width="21%"| Target
!width="21%"| Status
|-
| OI-01
| <code>primes_table.cpy</code> (underscore) needs to be designated as deprecated in favour of <code>primes-table.cpy</code> (hyphen)
| Developer
| —
| Open
|-
| OI-02
| No program header blocks present in current source — all four programs need retrofitting
| Developer
| —
| Open
|-
| OI-03
| No paragraph comment headers present in current source — all paragraphs need retrofitting
| Developer
| —
| Open
|-
| OI-04
| Direct DISPLAY statements in <code>primes.cbl</code> bypass the structured log format; should be replaced with calls to primesui
| Developer
| —
| Open
|-
| OI-05
| <code>RETURN-CODE</code> not set in <code>primesmain</code>; needs adding before STOP RUN
| Developer
| —
| Open
|}
<hr/>
Terug naar: [[Design standards]] | [[Cobol and PostgreSQL]]