Program Logic - Revision history

Martin: Created page with " = Program Logic = '''Project:''' pgcobol — Prime Numbers Application
'''Version:''' 1.0 (reverse-engineered)
'''Date:''' 2026-03-17 ----- == 1. primesmain — Step-by-Step Logic == '''Source:''' `primesmain.cbl`
'''Role:''' Entry point. Parses command-line argument, initialises UI, dispatches to processing, shuts down.
2026-03-25T16:47:57Z

Created page with "<span id="program-logic"></span> = Program Logic = '''Project:''' pgcobol — Prime Numbers Application<br /> '''Version:''' 1.0 (reverse-engineered)<br /> '''Date:''' 2026-03-17 ----- <span id="primesmain-step-by-step-logic"></span> == 1. primesmain — Step-by-Step Logic == '''Source:''' <code>primesmain.cbl</code><br /> '''Role:''' Entry point. Parses command-line argument, initialises UI, dispatches to processing, shuts down. <span id="procedure-division-main-i..."

New page
<span id="program-logic"></span>
= Program Logic =

'''Project:''' pgcobol — Prime Numbers Application<br />
'''Version:''' 1.0 (reverse-engineered)<br />
'''Date:''' 2026-03-17

-----

<span id="primesmain-step-by-step-logic"></span>
== 1. primesmain — Step-by-Step Logic ==

'''Source:''' <code>primesmain.cbl</code><br />
'''Role:''' Entry point. Parses command-line argument, initialises UI, dispatches to processing, shuts down.

<span id="procedure-division-main-inline-logic"></span>
=== PROCEDURE DIVISION (main inline logic) ===

<pre>Step 1 ACCEPT commandline-args FROM COMMAND-LINE
→ reads first token of the OS command line into commandline-args (PIC X(32))

Step 2 MOVE commandline-args TO methods
MOVE 'primesmain' TO program-name
→ loads session control block ready for dispatch
→ sets log identity for subsequent messages

Step 3 PERFORM r90-start-session
→ opens primes.prt and verifies UI layer is ready (see §1.1)

Step 4 EVALUATE TRUE
WHEN report-primes (commandline-args = "report")
LOG "Primes report generation starts."
SET methods = "report"
PERFORM r92-generate-primes → CALL primesgen

WHEN generate-primes (commandline-args = "generate")
LOG "Primes generation starts."
SET methods = "generate"
* PERFORM r92-generate-primes is COMMENTED OUT *

WHEN OTHER
LOG "Bad parameter, program initialisation failed."
PERFORM r99-stop-session
STOP RUN

Step 5 LOG "Primes run complete, program stops."

Step 6 PERFORM r99-stop-session

Step 7 STOP RUN</pre>
<span id="paragraph-r90-start-session"></span>
=== 1.1 Paragraph: r90-start-session ===

<pre>MOVE 'start-session' TO program-paragraph
MOVE 'start' TO ui-methods
CALL "primesui" USING primes-ui

IF ui-method-ok (result = 0) THEN
LOG "UI initialisation succeeded."
LOG commandline-args value
ELSE
DISPLAY "Emergency console message program stops." UPON scherm
STOP RUN ← hard abort; no graceful close</pre>
<span id="paragraph-r92-generate-primes"></span>
=== 1.2 Paragraph: r92-generate-primes ===

<pre>CALL "primesgen" USING primes-session
← passes entire session control block by reference
← primesgen reads methods to determine its path</pre>
<span id="paragraph-r99-stop-session"></span>
=== 1.3 Paragraph: r99-stop-session ===

<pre>MOVE 'stop' TO ui-methods
CALL "primesui" USING primes-ui
← primesui flushes print buffer and closes primes.prt</pre>

-----

<span id="primesgen-step-by-step-logic"></span>
== 2. primesgen — Step-by-Step Logic ==

'''Source:''' <code>primesgen.cbl</code><br />
'''Role:''' Implements both the sieve algorithm (generate) and the cursor read-loop (report). Receives control via <code>primes-session</code> linkage; uses <code>primes-dal</code> and <code>primes-ui</code> locally.

<span id="procedure-division-main-inline-logic-1"></span>
=== PROCEDURE DIVISION (main inline logic) ===

<pre>Step 1 EVALUATE TRUE on methods (from primes-session)

WHEN report-primes
PERFORM r90-start-primes-report
IF session-method-ok THEN
PERFORM r86-report-primes UNTIL session-method-eof

WHEN generate-primes
PERFORM r91-start-primes-generation
IF session-method-ok THEN
PERFORM r80-test-number UNTIL test-number = 999999999

WHEN OTHER
SET program-name = "primesgen", program-paragraph = "main"
LOG "Bad method, primes process failed."

Step 2 PERFORM r99-close-primes

Step 3 EXIT PROGRAM</pre>
<span id="paragraph-r90-start-primes-report"></span>
=== 2.1 Paragraph: r90-start-primes-report ===

<pre>CALL primes "connect"
IF dal-method-ok THEN LOG "DB init succeeded." ELSE LOG "DB init failed." + session-result=1

CALL primes "cursor"
→ START TRANSACTION
→ OPEN primescursor (SELECT * FROM primes)
IF dal-method-ok THEN LOG "Cursor init succeeded." ELSE LOG "Cursor init failed." + session-result=1

IF dal-method-ok THEN PERFORM r94-fetch (fetch first row)

IF dal-method-ok THEN
LOG "Fetch first row ok." + dal-result=0
ELSE
LOG "Fetch first row nok." + dal-result=1</pre>
<span id="paragraph-r91-start-primes-generation"></span>
=== 2.2 Paragraph: r91-start-primes-generation ===

<pre>CALL primes "connect"
IF dal-method-ok THEN
test-divider = 2
old-ident = 1
test-number = 3
test-number-sqr = COMPUTE test-number 0.5 (= SQRT(3) ≈ 1.732)
LOG "DB init succeeded."
ELSE
LOG "DB init failed."
session-result = 1</pre>
<span id="paragraph-r80-test-number-sieve-main-loop-body"></span>
=== 2.3 Paragraph: r80-test-number ''(sieve main loop body)'' ===

<pre>DIVIDE test-number BY test-divider
GIVING test-quot REMAINDER test-rest

EVALUATE TRUE
WHEN test-rest = 0
→ test-number is divisible; it is composite
PERFORM r82-next-test-number

WHEN test-divider > test-number-sqr
→ no factor ≤ √test-number found; test-number IS PRIME
PERFORM r85-write-prime
PERFORM r82-next-test-number

WHEN OTHER
→ keep trying; get next trial divisor from DB
PERFORM r89-get-next-divider</pre>
<span id="paragraph-r82-next-test-number"></span>
=== 2.4 Paragraph: r82-next-test-number ===

<pre>ADD 2 TO test-number ← advance to next odd integer
COMPUTE test-number-sqr = test-number 0.5 ← recompute √
MOVE 1 TO old-ident ← reset divider index to first prime
PERFORM r89-get-next-divider ← load test-divider = prime[2]</pre>
<span id="paragraph-r85-write-prime"></span>
=== 2.5 Paragraph: r85-write-prime ===

<pre>MOVE 'write' TO ui-methods
CALL "primes" USING primes-dal ← INSERT INTO primes (prime) VALUES (prime-number)
CALL "primesui" USING primes-ui ← add to print buffer</pre>
<span id="paragraph-r86-report-primes-report-loop-body"></span>
=== 2.6 Paragraph: r86-report-primes ''(report loop body)'' ===

<pre>MOVE 'write' TO ui-methods
MOVE primes-data TO u-primes ← copy sequence + value into UI block
CALL "primesui" USING primes-ui ← accumulate into 6-column print buffer
PERFORM r94-fetch ← advance cursor</pre>
<span id="paragraph-r89-get-next-divider"></span>
=== 2.7 Paragraph: r89-get-next-divider ===

<pre>MOVE 'get' TO gen-methods ← note: uses local "primes" group, not primes-dal
CALL "primes" USING primes ← DAL selects prime WHERE ident = old-ident+1
sets test-divider</pre>
<span id="paragraph-r94-fetch"></span>
=== 2.8 Paragraph: r94-fetch ===

<pre>MOVE 'next-prime' TO dal-methods
CALL "primes" USING primes-dal ← FETCH primescursor INTO primes-row
IF dal-method-ok THEN
next sentence
ELSE
LOG "Fetch failed."
session-result = 1</pre>
<span id="paragraph-r99-close-primes"></span>
=== 2.9 Paragraph: r99-close-primes ===

<pre>MOVE 'disconnect' TO dal-methods
CALL "primes" USING primes ← note: passes local "primes" group, not primes-dal
IF dal-method-ok THEN LOG "DB close succeeded."
ELSE LOG "DB close failed." + session-result=1</pre>

-----

<span id="primes-dal-step-by-step-logic"></span>
== 3. primes (DAL) — Step-by-Step Logic ==

'''Source:''' <code>primes.cbl</code><br />
'''Role:''' Data access layer. All SQL is here. Receives control via <code>primes-dal</code> linkage.

<span id="procedure-division"></span>
=== PROCEDURE DIVISION ===

<pre>EVALUATE TRUE on dal-methods
WHEN next-prime → PERFORM r80-get-next-prime
WHEN next-divider → PERFORM r81-get-next-divider
WHEN write-prime → PERFORM r83-write-prime
WHEN db-connect → PERFORM s00-connect
WHEN db-cursor → PERFORM s01-cursor
WHEN db-disconnect → PERFORM s99-disconnect
WHEN OTHER → dal-result = 1
EXIT PROGRAM</pre>
<span id="paragraph-s00-connect"></span>
=== 3.1 Paragraph: s00-connect ===

<pre>MOVE 'CONNECT' TO CUR-STEP
EXEC SQL
CONNECT TO :DATASRC AS primes USER :DBUSR USING :DBPWD
END-EXEC
IF SQLCODE = 0 THEN
dal-result = 0
LOG "Database initialisation ok."
ELSE
LOG "Database initialisation failed, terminating program."
dal-result = 1</pre>
<span id="paragraph-s01-cursor"></span>
=== 3.2 Paragraph: s01-cursor ===

<pre>EXEC SQL AT primes START TRANSACTION END-EXEC
IF SQLCODE = 0 THEN LOG "Start transaction ok."
ELSE LOG "Start transaction nok." + dal-result = 1

IF dal-method-ok THEN
EXEC SQL OPEN primescursor END-EXEC
IF SQLCODE = 0 THEN LOG "Start primescursor ok."
ELSE LOG "Start primescursor nok." + dal-result = 1</pre>
<span id="paragraph-s02-fetch-called-by-r80-get-next-prime"></span>
=== 3.3 Paragraph: s02-fetch ''(called by r80-get-next-prime)'' ===

<pre>EXEC SQL FETCH primescursor INTO :primes-row END-EXEC
IF SQLCODE = 0 THEN
primes-sequence = r-ident
prime-number = r-prime
dal-result = 0
ELSE
LOG "Fetch row nok."
dal-result = 1
LOG from program-name / program-paragraph context</pre>
<span id="paragraph-r81-get-next-divider"></span>
=== 3.4 Paragraph: r81-get-next-divider ===

<pre>new-ident = old-ident + 1

EXEC SQL AT primes
SELECT prime INTO :test-divider
FROM primes WHERE ident = :new-ident
END-EXEC

IF SQLCODE = 0 THEN next sentence
ELSE DISPLAY SQLCODE + "select new-divider nok" on console

MOVE new-ident TO old-ident</pre>
<span id="paragraph-r83-write-prime"></span>
=== 3.5 Paragraph: r83-write-prime ===

<pre>EXEC SQL AT primes
INSERT INTO primes (prime) VALUES (:prime)
END-EXEC

IF SQLCODE = 0 THEN next sentence
ELSE
DISPLAY SQLCODE on console
DISPLAY "primes.cbl insert next prime nok: " prime-number on console

*** EXEC SQL AT primes COMMIT END-EXEC ← COMMENTED OUT</pre>
<span id="paragraph-s99-disconnect"></span>
=== 3.6 Paragraph: s99-disconnect ===

<pre>MOVE 'DISCONNECT' TO CUR-STEP
EXEC SQL CONNECT RESET primes END-EXEC
IF SQLCODE = 0 THEN
dal-result = 0
LOG "Close database ok."
ELSE
LOG "Database initialisation failed, ending program."
dal-result = 1
DISPLAY "s99 disconnect from database" on console
DISPLAY SQLCODE on console</pre>

-----

<span id="primesui-step-by-step-logic"></span>
== 4. primesui — Step-by-Step Logic ==

'''Source:''' <code>primesui.cbl</code><br />
'''Role:''' All output. Manages the <code>primes.prt</code> print file and writes to the system console.

<span id="procedure-division-1"></span>
=== PROCEDURE DIVISION ===

<pre>EVALUATE TRUE on ui-methods
WHEN start-ui → PERFORM r90-start-primesui
WHEN write-ui → PERFORM r92-write-primesui
WHEN stop-ui → PERFORM r99-stop-primesui
WHEN message-ui → PERFORM r98-message-ui
WHEN OTHER → ui-method-result = 1
EXIT PROGRAM</pre>
<span id="paragraph-r90-start-primesui"></span>
=== 4.1 Paragraph: r90-start-primesui ===

<pre>MOVE 'start-primesui' TO program-paragraph
MOVE 'start-printer' TO program-message

OPEN OUTPUT fprinter (primes.prt)

IF primes-prt-status = '00' THEN
ui-method-result = 0
SET primes-idx TO 1 ← initialise table column index
LOG "Open printer Ok"
ELSE
ui-method-result = 1
DISPLAY primes-prt-status on console</pre>
<span id="paragraph-r92-write-primesui-called-for-every-prime-row"></span>
=== 4.2 Paragraph: r92-write-primesui ''(called for every prime row)'' ===

<pre>t-ident(primes-idx) = u-sequence ← load sequence into current cell
t-prime(primes-idx) = u-number ← load prime value into current cell
SET primes-idx UP BY 1 ← advance to next cell

IF new-page (print-new-page = 1) THEN
PERFORM r93-new-page ← write heading + column header

IF primes-idx = 7 THEN ← 6 entries filled (index is post-increment)
MOVE primes-table TO print-buffer
WRITE file-buffer FROM print-buffer ← write the 132-char data line
SET primes-idx TO 1

IF linage-counter = 53 THEN ← within 3 lines of page end
PERFORM r94-eop</pre>
<span id="paragraph-r93-new-page"></span>
=== 4.3 Paragraph: r93-new-page ===

<pre>MOVE primes-heading TO print-buffer
WRITE file-buffer FROM print-buffer ← "primes overview"
MOVE table-header TO print-buffer
WRITE file-buffer FROM print-buffer ← "Sequence Prime " × 6
MOVE ZERO TO print-new-page ← clear new-page flag</pre>
<span id="paragraph-r94-eop-end-of-page"></span>
=== 4.4 Paragraph: r94-eop ''(end-of-page)'' ===

<pre>MOVE page-number TO f-page-number
MOVE ' ' TO print-buffer
WRITE file-buffer FROM print-buffer ← blank separator line
MOVE primes-footing TO print-buffer
WRITE file-buffer FROM print-buffer ← " page: NNN"
ADD 1 TO page-number
MOVE 1 TO print-new-page ← trigger new heading on next write</pre>
<span id="paragraph-r98-message-ui"></span>
=== 4.5 Paragraph: r98-message-ui ===

<pre>DISPLAY process-message UPON scherm ← writes program-name + paragraph + message to console</pre>
<span id="paragraph-r99-stop-primesui"></span>
=== 4.6 Paragraph: r99-stop-primesui ===

<pre>MOVE 0 TO u-sequence
MOVE 0 TO u-number
PERFORM r92-write-primesui UNTIL new-page ← pad remaining cells to trigger line flush

MOVE 'stop-primesui' TO program-paragraph
MOVE 'close printer' TO program-message
PERFORM r98-message-ui

CLOSE fprinter

MOVE primes-prt-status TO ui-method-result
IF primes-prt-status = '00' THEN next sentence
ELSE DISPLAY primes-prt-status on console</pre>
<hr/>
Terug naar: [[Primes_programs_specifications]] | [[Cobol and PostgreSQL]]