How does a COBOL program return a status (ie. R0) to a calling program?
I found a reference to RETURN-CODE but compiler balks at that.

— VAXman

On 9/11/2023 3:01 PM, Brian Schenkenberger wrote:
> How does a COBOL program return a status (ie. R0) to a calling program?
> I found a reference to RETURN-CODE but compiler balks at that.
>

In Unix ending the program with:

STOP RUN RETURNING {literal-1}
{identifier-1}

will make a return code available to the shell.

If you want a status returned to DCL I expect that would do it.

bill

{I really need to get a VMS system running here again.}

On Monday, September 11, 2023 at 12:46:03 PM UTC-7, bill wrote:

(snip)

> If you want a status returned to DCL I expect that would do it.

But DCL will give you a funny message, instead of a number.

Years ago, I had a program that returned 8.

For IBM OS/360 and descendents, 8 is error,
(4 is warning, 12 is even worse error).

And then VMS gives a surprising message, that doesn't help at all.

On Monday, September 11, 2023 at 12:46:03 PM UTC-7, bill wrote:

(snip)

> If you want a status returned to DCL I expect that would do it.

OK, I had to look it up. It seems that 8 give "ACCVIO Access Violation".

Now, it does that even if your program doesn't have any actual access violation.

So I start trying to figure out where my program goes wrong, and then find out why.

On 9/11/2023 3:01 PM, Brian Schenkenberger wrote:
> How does a COBOL program return a status (ie. R0) to a calling program?
> I found a reference to RETURN-CODE but compiler balks at that.

Disclaimer: I really don't know Cobol, but the following seems to work:

$ type m.cob
identification division.
program-id.m.
data division.
working-storage section.
01 a pic 9(9) comp.
01 b pic 9(9) comp.
01 res pic 9(9) comp.
01 res2 pic 9(9) display.
procedure division.
main-paragraph.
move 123 to a
move 456 to b
call "ADD2" using a,b giving res
move res to res2
display res2
stop run.
$ cob m
$ type add2.cob
identification division.
program-id.add2.
data division.
working-storage section.
01 res pic 9(9) comp.
linkage section.
01 a pic 9(9) comp.
01 b pic 9(9) comp.
procedure division using a,b giving res.
main-paragraph.
compute res = a + b.
end program add2.
$ cob add2
$ link m + add2
$ run m
000000579

Arne

On 2023-09-11 19:45:56 +0000, bill said:

> On 9/11/2023 3:01 PM, Brian Schenkenberger wrote:
>> How does a COBOL program return a status (ie. R0) to a calling program?
>> I found a reference to RETURN-CODE but compiler balks at that.
>>
>
> In Unix ending the program with:
>
> STOP RUN RETURNING {literal-1}
> {identifier-1}
>
>
> will make a return code available to the shell.
>
> If you want a status returned to DCL I expect that would do it.
>
> bill
>
> {I really need to get a VMS system running here again.}

I need a COBOL sub-program to return a value to its COBOL caller.

PROGRAM-ID. MAIN-PROGRAM.
: :
CALL "ADVENTURE" USING MAGIC-WORDS GIVING MAGIC-SMOKE.
: :
IF MAGIC-SMOKE = SS$_XYZZY THEN
do something and tele-transport out of cave.
END-IF.

Sub-PROGRAM

Then, something like

PROGRAM-ID. ADVENTURE.
: :
PROCEDURE DIVISION USING MAGIC-WORDS RETURNING MAGIC-SMOKE TO CALLER.
-- this is correct syntax up to this point ---------------^
: :
MOVE SS$_XYZZY TO MAGIC-SMOKE.
EXIT.

END PROGRAM ADVENTURE.

— VAXman

On 9/11/2023 3:53 PM, gah4 wrote:
> On Monday, September 11, 2023 at 12:46:03 PM UTC-7, bill wrote:
>
> (snip)
>
>> If you want a status returned to DCL I expect that would do it.
>
> But DCL will give you a funny message, instead of a number.
>
> Years ago, I had a program that returned 8.
>
> For IBM OS/360 and descendents, 8 is error,
> (4 is warning, 12 is even worse error).
>
> And then VMS gives a surprising message, that doesn't help at all.

What is surprising about the below messages, and the escalation in their severity?

$ exit 8
%SYSTEM-W-ACCVIO, access violation, reason mask=00, virtual address=0000000000000008, PC=000000007AEE1EA8, PS=00000000
$ exit 10
%SYSTEM-E-ACCVIO, access violation, reason mask=00, virtual address=000000000000000A, PC=000000007AEE1EA8, PS=00000000
$ exit 12
%SYSTEM-F-ACCVIO, access violation, reason mask=00, virtual address=000000000000000C, PC=000000007AEE1EA8, PS=00000000

$ HELP /MESSAGE ACCVIO will explain the above.

--
-- Rob

On 9/11/2023 4:00 PM, Brian Schenkenberger wrote:
> I need a COBOL sub-program to return a value to its COBOL caller.
>
> PROGRAM-ID.        MAIN-PROGRAM.
> :
> CALL "ADVENTURE" USING MAGIC-WORDS GIVING MAGIC-SMOKE.
> :
> IF MAGIC-SMOKE = SS$_XYZZY THEN
>     do something and tele-transport out of cave.
> END-IF.

> PROGRAM-ID.     ADVENTURE.
> :
> :
> PROCEDURE DIVISION USING MAGIC-WORDS RETURNING MAGIC-SMOKE TO CALLER.
> -- this is correct syntax up to this point ---------------^

PROCEDURE DIVISION USING MAGIC-WORDS GIVING MAGIC-SMOKE

> :
>     MOVE SS$_XYZZY TO MAGIC-SMOKE.
>         EXIT.
>
> END PROGRAM ADVENTURE.

Also see the little ADD example I posted.

The args goes in linkage section the result goes in
working-storage section.

Arne

On 9/11/2023 4:00 PM, Brian Schenkenberger wrote:
> On 2023-09-11 19:45:56 +0000, bill said:
>
>> On 9/11/2023 3:01 PM, Brian Schenkenberger wrote:
>>> How does a COBOL program return a status (ie. R0) to a calling
>>> program? I found a reference to RETURN-CODE but compiler balks at that.
>>>
>>
>> In Unix ending the program with:
>>
>>      STOP RUN RETURNING {literal-1}
>>                         {identifier-1}
>>
>>
>> will make a return code available to the shell.
>>
>> If you want a status returned to DCL I expect that would do it.
>>
>> bill
>>
>> {I really need to get a VMS system running here again.}
>
> I need a COBOL sub-program to return a value to its COBOL caller.
>
> PROGRAM-ID.        MAIN-PROGRAM.
> :
> :
> CALL "ADVENTURE" USING MAGIC-WORDS GIVING MAGIC-SMOKE.
> :
> :
> IF MAGIC-SMOKE = SS$_XYZZY THEN
>     do something and tele-transport out of cave.
> END-IF.
>
>
>
> Sub-PROGRAM
>
> Then, something like
>
> PROGRAM-ID.     ADVENTURE.
> :
> :
> PROCEDURE DIVISION USING MAGIC-WORDS RETURNING MAGIC-SMOKE TO CALLER.
> -- this is correct syntax up to this point ---------------^
> :
> :
>     MOVE SS$_XYZZY TO MAGIC-SMOKE.
>         EXIT.
>
> END PROGRAM ADVENTURE.
>
> — VAXman
>

OK, give a couple minutes. :-)

bill

On 2023-09-11 19:59:05 +0000, Arne Vajhj said:

> On 9/11/2023 3:01 PM, Brian Schenkenberger wrote:
>> How does a COBOL program return a status (ie. R0) to a calling program?
>> I found a reference to RETURN-CODE but compiler balks at that.
>
> Disclaimer: I really don't know Cobol, but the following seems to work:
>
> $ type m.cob
> identification division.
> program-id.m.
> data division.
> working-storage section.
> 01 a pic 9(9) comp.
> 01 b pic 9(9) comp.
> 01 res pic 9(9) comp.
> 01 res2 pic 9(9) display.
> procedure division.
> main-paragraph.
> move 123 to a
> move 456 to b
> call "ADD2" using a,b giving res
> move res to res2
> display res2
> stop run.
> $ cob m
> $ type add2.cob
> identification division.
> program-id.add2.
> data division.
> working-storage section.
> 01 res pic 9(9) comp.
> linkage section.
> 01 a pic 9(9) comp.
> 01 b pic 9(9) comp.
> procedure division using a,b giving res.
> main-paragraph.
> compute res = a + b.
> end program add2.
> $ cob add2
> $ link m + add2
> $ run m
> 000000579
>
> Arne

I've tried that but compiler pukes on it. I've tried:

MOVE SS$_NORMAL TO RES.

and

COMPUTE RES = SS$_NORMAL *1.

It just doesn't like it.

—VAXman

On 9/11/2023 3:59 PM, Arne Vajhøj wrote:
> On 9/11/2023 3:01 PM, Brian Schenkenberger wrote:
>> How does a COBOL program return a status (ie. R0) to a calling
>> program? I found a reference to RETURN-CODE but compiler balks at that.
>
> Disclaimer: I really don't know Cobol, but the following seems to work:
>
> $ type m.cob
> identification division.
> program-id.m.
> data division.
> working-storage section.
> 01  a       pic 9(9) comp.
> 01  b       pic 9(9) comp.
> 01  res     pic 9(9) comp.
> 01  res2    pic 9(9) display.
> procedure division.
> main-paragraph.
>     move 123 to a
>     move 456 to b
>     call "ADD2" using a,b giving res
>     move res to res2
>     display res2
>     stop run.
> $ cob m
> $ type add2.cob
> identification division.
> program-id.add2.
> data division.
> working-storage section.
> 01  res     pic 9(9) comp.
> linkage section.
> 01  a       pic 9(9) comp.
> 01  b       pic 9(9) comp.
> procedure division using a,b giving res.
> main-paragraph.
>     compute res = a + b.
>     end program add2.
> $ cob add2
> $ link m + add2
> $ run m
> 000000579
>

Yeah, that should do the trick. I prefer to use RETURNING rather than
GIVING but that's just a human readability thing for me.

bill

On 9/11/2023 4:12 PM, Brian Schenkenberger wrote:
> On 2023-09-11 19:59:05 +0000, Arne Vajhj said:
>> $ type add2.cob
>> identification division.
>> program-id.add2.
>> data division.
>> working-storage section.
>> 01  res     pic 9(9) comp.
>> linkage section.
>> 01  a       pic 9(9) comp.
>> 01  b       pic 9(9) comp.
>> procedure division using a,b giving res.
>> main-paragraph.
>>      compute res = a + b.
>>      end program add2.

> I've tried that but compiler pukes on it.  I've tried:
>
> MOVE SS$_NORMAL TO RES.
>
> and
>
> COMPUTE RES = SS$_NORMAL *1.
>
> It just doesn't like it.

Move should be fine.

How did you declare RES and how did you declare SS$_NORMAL and
what error did you get?

Arne

On 9/11/2023 4:17 PM, Arne Vajhøj wrote:
> On 9/11/2023 4:12 PM, Brian Schenkenberger wrote:
>> On 2023-09-11 19:59:05 +0000, Arne Vajhj said:
>>> $ type add2.cob
>>> identification division.
>>> program-id.add2.
>>> data division.
>>> working-storage section.
>>> 01  res     pic 9(9) comp.
>>> linkage section.
>>> 01  a       pic 9(9) comp.
>>> 01  b       pic 9(9) comp.
>>> procedure division using a,b giving res.
>>> main-paragraph.
>>>      compute res = a + b.
>>>      end program add2.
>
>> I've tried that but compiler pukes on it.  I've tried:
>>
>> MOVE SS$_NORMAL TO RES.
>>
>> and
>>
>> COMPUTE RES = SS$_NORMAL *1.
>>
>> It just doesn't like it.
>
> Move should be fine.
>
> How did you declare RES and how did you declare SS$_NORMAL and
> what error did you get?

Anyway.

$ typ m2.cob
identification division.
program-id.m.
data division.
working-storage section.
01 a pic 9(9) comp.
01 b pic 9(9) comp.
01 res pic 9(9) comp.
01 stat pic 9(9) comp.
01 res2 pic 9(9) display.
01 stat2 pic 9(9) display.
procedure division.
main-paragraph.
move 123 to a
move 456 to b
call "ADD3" using a,b,res giving stat
move res to res2
move stat to stat2
display stat2 " " res2
stop run.
$ cob m2
$ type add3.cob
identification division.
program-id.add3.
data division.
working-storage section.
01 SS$_NORMAL pic 9(9) comp value is external SS$_NORMAL.
01 stat pic 9(9) comp.
linkage section.
01 a pic 9(9) comp.
01 b pic 9(9) comp.
01 res pic 9(9) comp.
procedure division using a,b,res giving stat.
main-paragraph.
compute res = a + b
move SS$_NORMAL to stat.
end program add3.
$ cob add3
$ link m2 + add3
$ run m2
000000001 000000579

Arne

On Monday, September 11, 2023 at 1:08:43 PM UTC-7, Robert A. Brooks wrote:

(snip)

> What is surprising about the below messages, and the escalation in their severity?
> $ exit 8
> %SYSTEM-W-ACCVIO, access violation, reason mask=00, virtual address=0000000000000008, PC=000000007AEE1EA8, PS=00000000
> $ exit 10
> %SYSTEM-E-ACCVIO, access violation, reason mask=00, virtual address=000000000000000A, PC=000000007AEE1EA8, PS=00000000
> $ exit 12
> %SYSTEM-F-ACCVIO, access violation, reason mask=00, virtual address=000000000000000C, PC=000000007AEE1EA8, PS=00000000
It was a C program that I wrote, and that had exit(8); in it.

There was no access violation.

Well, even more, the program does a lot of array access, and I had for a while
been tracking down array bounds problems. Though most were fixed by then,
it is possible that there were some left. But that is my first thought.

> $ HELP /MESSAGE ACCVIO will explain the above.

I suppose it helps if someone else wrote the program.

On 9/11/2023 4:12 PM, Brian Schenkenberger wrote:
> On 2023-09-11 19:59:05 +0000, Arne Vajhj said:
>
>> On 9/11/2023 3:01 PM, Brian Schenkenberger wrote:
>>> How does a COBOL program return a status (ie. R0) to a calling
>>> program? I found a reference to RETURN-CODE but compiler balks at that.
>>
>> Disclaimer: I really don't know Cobol, but the following seems to work:
>>
>> $ type m.cob
>> identification division.
>> program-id.m.
>> data division.
>> working-storage section.
>> 01  a       pic 9(9) comp.
>> 01  b       pic 9(9) comp.
>> 01  res     pic 9(9) comp.
>> 01  res2    pic 9(9) display.
>> procedure division.
>> main-paragraph.
>>      move 123 to a
>>      move 456 to b
>>      call "ADD2" using a,b giving res
>>      move res to res2
>>      display res2
>>      stop run.
>> $ cob m
>> $ type add2.cob
>> identification division.
>> program-id.add2.
>> data division.
>> working-storage section.
>> 01  res     pic 9(9) comp.
>> linkage section.
>> 01  a       pic 9(9) comp.
>> 01  b       pic 9(9) comp.
>> procedure division using a,b giving res.
>> main-paragraph.
>>      compute res = a + b.
>>      end program add2.
>> $ cob add2
>> $ link m + add2
>> $ run m
>> 000000579
>>
>> Arne
>
> I've tried that but compiler pukes on it.  I've tried:
>
> MOVE SS$_NORMAL TO RES.
>
> and
>
> COMPUTE RES = SS$_NORMAL *1.
>
> It just doesn't like it.
>
> —VAXman
>

OK Brian, here's a solution to your problem.

identification division.
program-id.m.
data division.
working-storage section.
01 a pic 9(9) comp.
01 b pic 9(9) comp.
01 res pic 9(9) comp.
01 res2 pic 9(9) display.
procedure division.
main-paragraph.
move 123 to a
move 456 to b
call "add2" using a,b,res
move res to res2
display res2
stop run.

identification division.
program-id.add2.
data division.
linkage section.
01 res pic 9(9) comp.
01 a pic 9(9) comp.
01 b pic 9(9) comp.
procedure division using a,b,res.
main-paragraph.
compute res = a + b.
end program add2.

Notice that rather than using the RETURNING|GIVING part this program
just uses another argument to bring back the return value. This works
because all of the arguments are BY REFERENCE.

I intend to look deeper into why the RETURNING is exhibiting strange
behavior but in the meantime this will get the job done and according
to what I just read is considered normal practice for COBOL CALLs.

bill

On Monday, September 11, 2023 at 3:01:30 PM UTC-4, Brian Schenkenberger wrote:
> How does a COBOL program return a status (ie. R0) to a calling program?
> I found a reference to RETURN-CODE but compiler balks at that.
>
> — VAXman

Darn novices. Gotta teach them everything.
You should know better than to write 'balks' when asking for help.
What if a customer wrote that to you: "What are you doing EXACTLY, and what message do you get EXACTLY?"

Anyhoo... I largely answered that question in your earlier topic. See summary below.
Admittedly that topic got heavily side-tracked by the usual suspects (par for the course) to Fortran, dashes and underscores. No Emacs reference though, not yet, that's good.

On Friday, September 8, 2023 at 9:02:59 PM UTC-4, Hein RMS van den Heuvel wrote:
> On Friday, September 8, 2023 at 12:45:07 PM UTC-4, Brian Schenkenberger wrote:
>
> > I have the SYS$MGBLSC working... at least, in the debugger.:
: > Or provide a second lower level function with just the 1 element also passed as linkage and called from the one you have?
> Remember these are functions 'giving', but they can only 'give' an R0 return value. Per Reference Guide: "The identifier must refer to an elementary integer numeric data
> item with COMP, COMP-1, or COMP-2 usage and no scaling positions."
>
> Greetings my friend!

And here is the definitive answer. And based on how convoluted
it seems I can understand why the method I provide in my last
example is considered the better way and none of the numerous
COBOL books (including Murach!) even mention it. But it does
work. Another advantage of the other way is you can actually
return more than one value.

bill

identification division.
program-id.m.
data division.
working-storage section.
01 a pic 9(9) comp.
01 b pic 9(9) comp.
01 res pic 9(9) comp.
01 res2 pic 9(9) display.
procedure division.
main-paragraph.
move 123 to a
move 456 to b
call "add2" using a,b RETURNING res.
move res to res2
display res2
stop run.

identification division.
program-id.add2.
data division.
working-storage section.
01 res pic 9(9) comp.
linkage section.
01 a pic 9(9) comp.
01 b pic 9(9) comp.
procedure division using a,b.
main-paragraph.
compute res = a + b.
move res to RETURN-CODE.
end program add2.

On 9/11/2023 10:04 PM, bill wrote:
>
>
> And here is the definitive answer.  And based on how convoluted
> it seems I can understand why the method I provide in my last
> example is considered the better way and none of the numerous
> COBOL books (including Murach!) even mention it.  But it does
> work.  Another advantage of the other way is you can actually
> return more than one value.
>
> bill
>
>
> identification division.
> program-id.m.
> data division.
> working-storage section.
> 01  a       pic 9(9) comp.
> 01  b       pic 9(9) comp.
> 01  res     pic 9(9) comp.
> 01  res2    pic 9(9) display.
> procedure division.
> main-paragraph.
>      move 123 to a
>      move 456 to b
>      call "add2" using a,b RETURNING res.
>      move res to res2
>      display res2
>      stop run.
>
> identification division.
> program-id.add2.
> data division.
> working-storage section.
> 01  res     pic 9(9) comp.
> linkage section.
> 01  a       pic 9(9) comp.
> 01  b       pic 9(9) comp.
> procedure division using a,b.
> main-paragraph.
>      compute res = a + b.
>      move res to RETURN-CODE.
>      end program add2.
>
>

And, just to throw another monkey wrench into the works,
I read the VA COBOL Reference and the VSI OpenVMS COBOL
Reference and it appears that VMS COBOL does not even
support RETURNING/GIVING in call statements so the example
above will probably not even compile. But, the previous
example provided should work fine and seems to be the way
VMS expects it to be done. Hope it helps, Brian.

bill

[Anybody else got some COBOL that needs fixin? I still
love this stuff.]

Den 2023-09-12 kl. 14:26, skrev bill:

> I read the VA COBOL Reference and the VSI OpenVMS COBOL
> Reference and it appears that VMS COBOL does not even
> support RETURNING/GIVING in call statements...

My copy of "VSI OpenVMS VSI COBOL Reference Guide" says
on page 275, in the description of the CALL statement:

22.
On Alpha and I64 systems, if the GIVING phrase of the CALL
statement is not specified, the function result is made available
in the RETURN-CODE special register when control returns to the
calling program.

23.
If the GIVING phrase is specified, the function result is made
available in function-res when control returns to the calling program.

[function-res]
Is the identifier of an elementary integer numeric data item with COMP,
COMP-1, or COMP-2 usage and no scaling positions. function-res can be
subscripted, and it can be qualified. When control returns to the calling
program, function-res can contain a function result.

I would not expected that to be any different on x86...

On 9/12/2023 8:44 AM, Jan-Erik Söderholm wrote:
> Den 2023-09-12 kl. 14:26, skrev bill:
>
>> I read the VA COBOL Reference and the VSI OpenVMS COBOL
>> Reference and it appears that VMS COBOL does not even
>> support RETURNING/GIVING in call statements...
>
> My copy of "VSI OpenVMS VSI COBOL Reference Guide" says
> on page 275, in the description of the CALL statement:
>
> 22.
> On Alpha and I64 systems, if the GIVING phrase of the CALL
> statement is not specified, the function result is made available
> in the RETURN-CODE special register when control returns to the
> calling program.
>
> 23.
> If the GIVING phrase is specified, the function result is made
> available in function-res when control returns to the calling program.
>
> [function-res]
> Is the identifier of an elementary integer numeric data item with COMP,
> COMP-1, or COMP-2 usage and no scaling positions. function-res can be
> subscripted, and it can be qualified. When control returns to the calling
> program, function-res can contain a function result.
>
>
>
> I would not expected that to be any different on x86...

Wow, I found and read that section. Seems to have been done as an
after thought. I guess the reason some compilers haven't included
it is because of the X/Open qualifier. :-) The explanation is even
more confusing than the one I finally found that made my last example
possible. In mine, the programmer has to put a value in RETURN-CODE
which then gets passed back to the RETURNING/GIVING identifier. The
VMS Reference seems to hint that it some how shows up in RETURN-CODE
automatically.

Could someone with the necessary compiler test my last example and
let me know if it works on VMS? Looks like setting up a VAX isn't
the answer. I wonder if the problems I had with the Alpha emulator
were ever fixed?

bill

> Could someone with the necessary compiler test my last example and
> let me know if it works on VMS? Looks like setting up a VAX isn't
> the answer. I wonder if the problems I had with the Alpha emulator
> were ever fixed?
>
> bill

Bill,

A bit off topic, but please create a new topic re: I wonder if the problems I had with the Alpha emulator were ever fixed?

Please describe the problem. Perhaps it has been fixed...

Dan

Disclosure: I work for Stromasys, the source of the Charon series of emulation products.

FYI, I found a stray . in an IF statement that cause the compile to
balk when trying this return status thing.

— VAXman

One last comment on this project.

I installed the Student System and was able to test my code
myself.

Had to change RETURNING to GIVING as it appears VMS COBOL
doesn't support the use of RETURNING. Other than that it
worked fine.

But I still say the other way is probably better and will
definitely result in more readable code.

bill

On 9/11/2023 3:45 PM, bill wrote:
> On 9/11/2023 3:01 PM, Brian Schenkenberger wrote:
>> How does a COBOL program return a status (ie. R0) to a calling
>> program? I found a reference to RETURN-CODE but compiler balks at that.
>>
>
> In Unix ending the program with:
>
>     STOP RUN RETURNING {literal-1}
>                        {identifier-1}
>
>
> will make a return code available to the shell.
>
> If you want a status returned to DCL I expect that would do it.
>
> bill
>
> {I really need to get a VMS system running here again.}
>

OK, in case anyone is still interested in any of this.

OpenVMS COBOL does not support the RETURNING clause on a STOP RUN.

If you wish to pass a STATUS back to DCL you have to put the
desired value in the predefined variable RETURN-CODE before
using STOP RUN.

I tried it and it works fine.

I really miss doing COBOL. Kinda miss Fortran, too, but not
as much. And then there was Pascal. A shame we lost all the
good languages.

bill

On 14/09/2023 23:32, bill wrote:
> On 9/11/2023 3:45 PM, bill wrote:
>> On 9/11/2023 3:01 PM, Brian Schenkenberger wrote:
>>> How does a COBOL program return a status (ie. R0) to a calling
>>> program? I found a reference to RETURN-CODE but compiler balks at that.
>>>
>>
>> In Unix ending the program with:
>>
>>      STOP RUN RETURNING {literal-1}
>>                         {identifier-1}
>>
>>
>> will make a return code available to the shell.
>>
>> If you want a status returned to DCL I expect that would do it.
>>
>> bill
>>
>> {I really need to get a VMS system running here again.}
>>
>
> OK, in case anyone is still interested in any of this.
>
> OpenVMS COBOL does not support the RETURNING clause on a STOP RUN.
>
> If you wish to pass a STATUS back to DCL you have to put the
> desired value in the predefined variable RETURN-CODE before
> using STOP RUN.
>
> I tried it and it works fine.
>
> I really miss doing COBOL.  Kinda miss Fortran, too, but not
> as much.  And then there was Pascal.  A shame we lost all the
> good languages.
>
> bill
>

Pascal IS available for x86

--
Chris