Does anybody have an example program that uses random access by record
number on an RMS fixed record size, relative organization file they'd be
willing to share? I'm missing something, probably something obvious,
but I've not been able to get random access by record number to work.
I'm working in VAX MACRO (on VMS 5.5-2), but should be able to use an
example in any language.

--
T. Kurt Bond, tkurtbond@gmail.com, tkurtbond.github.io, consp.org, & tkb.tx0.org

On 9/16/2023 3:51 PM, T. Kurt Bond wrote:
> Does anybody have an example program that uses random access by record
> number on an RMS fixed record size, relative organization file they'd be
> willing to share? I'm missing something, probably something obvious,
> but I've not been able to get random access by record number to work.
> I'm working in VAX MACRO (on VMS 5.5-2), but should be able to use an
> example in any language.

So:
* RMS API (SYS$OPEN, SYS$GET, SYS$CLOSE)
* ORG=REL
* access by record number
?

I don't think I have ever used ORG=REL.

Arne

On 9/16/2023 3:51 PM, T. Kurt Bond wrote:
> Does anybody have an example program that uses random access by record
> number on an RMS fixed record size, relative organization file they'd be
> willing to share? I'm missing something, probably something obvious,
> but I've not been able to get random access by record number to work.
> I'm working in VAX MACRO (on VMS 5.5-2), but should be able to use an
> example in any language.
>

Well, it's in Basic ...

1 MAP (Z) String WholeRec$=64%

Open "test.dat" for Output as File #1%, &
Organization Relative Fixed, &
Recordsize 64%, &
MAP Z

For Z% = 1% to 9%
WholeRec$ = String$(64%,(Z%+48%))
Put #1%, Record Z%
Next Z%

Close #1%

Open "test.dat" for input as file 1%, &
Organization Relative Fixed, &
MAP Z

10 Input "Record num", Z%
GoTo 99 Unless Z%
Get #1%, Record Z%
Print WholeRec$
GoTo 10

99 End

If it is not obvious, just ask ...

--
David Froble Tel: 724-529-0450
Dave Froble Enterprises, Inc. E-Mail: davef@tsoft-inc.com
DFE Ultralights, Inc.
170 Grimplin Road
Vanderbilt, PA 15486

On Saturday, September 16, 2023 at 3:51:54 PM UTC-4, T. Kurt Bond wrote:
> Does anybody have an example program that uses random access by record
> number on an RMS fixed record size, relative organization file they'd be
> willing to share? I'm missing something, probably something obvious,
> but I've not been able to get random access by record number to work.
> I'm working in VAX MACRO (on VMS 5.5-2), but should be able to use an
> example in any language.
>
> --
> T. Kurt Bond, tkur...@gmail.com, tkurtbond.github.io, consp.org, & tkb.tx0.org
Kurt,

I do not have a sample easily at hand, but the examples in the FORTRAN manual should be illuminating. I have used relative files in the past, and there was no particular problem.

- Bob Gezelter, http://www.rlgsc.com

On Saturday, September 16, 2023 at 3:51:54 PM UTC-4, T. Kurt Bond wrote:
> Does anybody have an example program that uses random access by record
> number on an RMS fixed record size, relative organization file they'd be
> willing to share? I'm missing something, probably something obvious,
> but I've not been able to get random access by record number to work.
> I'm working in VAX MACRO (on VMS 5.5-2), but should be able to use an
> example in any language.
>
> --
> T. Kurt Bond, tkur...@gmail.com, tkurtbond.github.io, consp.org, & tkb.tx0.org

Here are some demos written in VMS-BASIC

https://neilrieck.net/demo_vms_html/openvms_demo_index.html#fileio

Neil Rieck
Waterloo, Ontario, Canada.
http://neilrieck.net

On Sunday, September 17, 2023 at 3:43:34 AM UTC-7, Bob Gezelter wrote:

(snip)

> I do not have a sample easily at hand, but the examples in the FORTRAN
> manual should be illuminating.
> I have used relative files in the past, and there was no particular problem.
I used to do them in IBM Fortran, and also PDP-10 Fortran, as unformatted.

For IBM and VAX, there is DEFINE FILE to set the record size, and

WRITE(unit'record) iolist
READ(unit'record) iolist

(That is an apostrophe to indicate the record number.)

It goes:

DEFINE FILE unit(numrec, recsize, U, assov)

Where for VAX/VMS recsize is in 16 bit words.
(I believe for IBM it is 32 bit words.)

The first time it is used, the whole file is formatted into the appropriate
number and size of records.

For IBM OS/360 and descendants, it formats the disk with the specified block size.
(And normally it has a JCL DD statement also specifying the record size and
(the same) block size.)

I don't know RMS enough to know, but it should do something similar, except that
it doesn't format the physical blocks to that size.

As well as I remember the PDP-10, it has to be in whole disk blocks.

"T. Kurt Bond" <tkurtbond@gmail.com> wrote:
> Does anybody have an example program that uses random access by record
> number on an RMS fixed record size, relative organization file they'd be
> willing to share? I'm missing something, probably something obvious,
> but I've not been able to get random access by record number to work.
> I'm working in VAX MACRO (on VMS 5.5-2), but should be able to use an
> example in any language.

I should definitely have provided more context with my question.

I'm debugging VTIL, a VAX MACRO implementation of a Forth-like language
that I wrote in 1988. I lost the source long ago (it was saved on a
9-track tape, and probably copied later to an 8mm tape, but when we
converted the VAX to use the Charon-VAX emulator I didn't get it copied
over to some other format, alas), so I retyped it from a printout that
recently turned up, and unfortunately in the process introduced a lot of
bugs through typos.

VTIL includes Forth-style block I/O words (words are Forth's version of
functions) that allow the user to load specificed numeric 1024-byte
blocks from a file, change their contents, and write them back out.
Unfortunately, the file was created by a different program (also written
in MACRO), and that program was *not* included in the printout. The
VTIL example program that used the block I/O words was an editor that
stored its text in blocks. (Probably inspired by the editor in
*Starting Forth*.) That program was also lost.

The code in VTIL itself which opend the file only specified the block
size, that the records were fixed, and random access was done using the
block number as the key. It didn't specify the organization. I
*thought* the file was created using relative organization, but when I
tried to load a block it would fail with a message about the key being
invalid, even though when I looked at the longword in memory with the
number in it it was correct. I wrote a couple of MACRO and BASIC
programs to play around with RMS files. Still confused, I posted here.

After reading all your replies (and thank you very much) and considering
the examples provided and reading more in the RMS Reference Manual and
doing a lot of searches in that manual I figured out two things: (1) you
can do random access to a *sequential* file as long as the records are
fixed size, and (2) I'd misspelled the KBF argument to the $RAB macro as
KFB. Sigh. (SO MANY TYPOS.)

Once I knew those things I was easily able to create a macro program
(MAKE-VTILBLOCKS.MAR) to create the sequential file and write an
appropriate number of blocks to it, another (READ-VTILBLOCKS.MAR) that
was able to randomly access records in it and display bytes from them.
Once that worked I fixed the typo in VTIL.MAR and then I was able to
read a block from the block file! Then I wrote a test VTIL program to
load a block from the block file, display a byte from it, change a byte
in it, and store the updated block back in the file in such a way that
READ-VTILBLOCKS could display that byte and easily confirm it had been
updated correctly.

The VTIL repository on GitHub is https://github.com/tkurtbond/VTIL
if anyone is interested in looking at the code.

Direct links to MAKE-VITLBLOCKS.MAR:

https://github.com/tkurtbond/VTIL/blob/a547c6af02e8fdd8ee4cf31cd2c081437d163554/make-vtilblocks.mar#L1

and to READ-VITLBLOCKS.MAR:

https://github.com/tkurtbond/VTIL/blob/a547c6af02e8fdd8ee4cf31cd2c081437d163554/read-vtilblocks.mar#L1

and the line in VTIL.MAR with the typo:

https://github.com/tkurtbond/VTIL/blob/a547c6af02e8fdd8ee4cf31cd2c081437d163554/vtil.mar#L438

Thanks again for your help!
--
T. Kurt Bond, tkurtbond@gmail.com, tkurtbond.github.io, consp.org, & tkb.tx0.org

On 2023-09-16 19:51:49 +0000, T. Kurt Bond said:

> Does anybody have an example program that uses random access by record
> number on an RMS fixed record size, relative organization file they'd be
> willing to share? I'm missing something, probably something obvious,
> but I've not been able to get random access by record number to work.
> I'm working in VAX MACRO (on VMS 5.5-2), but should be able to use an
> example in any language.

When I was writing RMS-CDC, I worked closely with Hein. He wrote many
test/example programs to check RMS-CDC functionality. Here is one of
his program in COBOL used to test RELATIVE RMS file accesses.

IDENTIFICATION DIVISION.
PROGRAM-ID. hein.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT the-file
ASSIGN TO "test-file"
ORGANIZATION IS RELATIVE
ACCESS MODE IS DYNAMIC
RELATIVE KEY IS the-key
FILE STATUS IS file-status.
DATA DIVISION.
FILE SECTION.
FD the-file.
01 the-record.
03 some-data PIC X(80).
WORKING-STORAGE SECTION.

01 the-key-txt.
03 filler PIC X(1) VALUE "(".
03 the-key PIC 9(9).
03 filler PIC X(2) VALUE ") ".
01 txt-key PIC X(9).
01 x PIC 9(9) COMP.
01 choice PIC 9.
01 file-status PIC XX.
01 sts PIC 9(9).
01 stv PIC 9(9).

01 rab_pt POINTER.
01 rfa_pt POINTER.

01 rfa.
03 vbn PIC 9(9) COMP VALUE 0.
03 id PIC 9(4) COMP VALUE 0.

01 rfa-txt.
03 filler PIC X(6) VALUE " RFA=(".
03 vbn-txt PIC 9(9).
03 filler PIC X(1) VALUE ",".
03 id-txt PIC 9(4).
03 filler PIC X(6) VALUE ") Rec=".

PROCEDURE DIVISION.

DECLARATIVES.
ERROR-HANDLER SECTION.
USE AFTER STANDARD EXCEPTION PROCEDURE ON the-file.
HERE-WE-GO.
MOVE RMS-STS TO sts.
MOVE RMS-STV TO stv.
DISPLAY "File status ", file-status, " STS=", sts, " STV=", stv.
END DECLARATIVES.

MAIN-CONTROL SECTION.
begin-here.
OPEN I-O the-file ALLOWING ALL.
CALL "DCOB$RMS_CURRENT_RAB" GIVING rab_pt
ADD 16 TO rab_pt GIVING rfa_pt.
The-loop.
CALL "OTS$MOVE3" USING BY VALUE 6, BY VALUE RFA_PT, BY REFERENCE RFA.
MOVE "----------------------------------------" TO some-data.

DISPLAY "1 Read, 2 Next, 3 Write, 4 Update, 5 Delete ? "
WITH NO ADVANCING
ACCEPT choice AT END STOP RUN.
GO TO 1-Read, 2-Next, 3-Write, 4-Update, 5-Delete
DEPENDING ON choice.
1-Read.
DISPLAY "Key value: " WITH NO ADVANCING.
ACCEPT txt-key AT END GO TO the-loop.
MOVE 0 to x.
INSPECT txt-key TALLYING x FOR CHARACTERS BEFORE INITIAL SPACE.
MOVE txt-key(1:x) TO the-key.
READ the-file RECORD.
DISPLAY the-key-txt, some-data.
GO TO the-loop.
2-Next.
READ the-file NEXT RECORD.
DISPLAY the-key-txt, some-data.
GO TO the-loop.
3-Write.
DISPLAY "Key value: " WITH NO ADVANCING.
ACCEPT txt-key AT END GO TO the-loop.
MOVE 0 to x.
INSPECT txt-key TALLYING x FOR CHARACTERS BEFORE INITIAL SPACE.
MOVE txt-key(1:x) TO the-key.
DISPLAY "New data : " WITH NO ADVANCING.
ACCEPT some-data AT END GO TO 3-Write.
WRITE the-record.
CALL "SYS$FLUSH" USING BY VALUE rab_pt.
GO TO the-loop.
4-Update.
DISPLAY "New data : " WITH NO ADVANCING.
ACCEPT some-data.
REWRITE the-record.
GO TO the-loop.
5-Delete.
DELETE the-file RECORD.
GO TO the-loop.

— VAXman

> that I wrote in 1988. I lost the source long ago (it was saved on a
> 9-track tape, and probably copied later to an 8mm tape, but when we
> converted the VAX to use the Charon-VAX emulator I didn't get it copied
> over to some other format, alas), so I retyped it from a printout that
> recently turned up, and unfortunately in the process introduced a lot of
> bugs through typos.

I'll point out for completeness, if nothing else, that said 9track
can still be read, if it's around.

De

On 9/18/2023 4:24 PM, Dennis Boone wrote:
> > that I wrote in 1988. I lost the source long ago (it was saved on a
> > 9-track tape, and probably copied later to an 8mm tape, but when we
> > converted the VAX to use the Charon-VAX emulator I didn't get it copied
> > over to some other format, alas), so I retyped it from a printout that
> > recently turned up, and unfortunately in the process introduced a lot of
> > bugs through typos.
>
> I'll point out for completeness, if nothing else, that said 9track
> can still be read, if it's around.
>

I have a 9-track drive. SCSI, so it can definitely still be read.

bill

On 9/16/2023 4:16 PM, Arne Vajhøj wrote:
> I don't think I have ever used ORG=REL.

But then I could start now!

:-)

Arne

On 9/19/2023 8:44 PM, Arne Vajhøj wrote:
> On 9/16/2023 4:16 PM, Arne Vajhøj wrote:
>> I don't think I have ever used ORG=REL.
>
> But then I could start now!

Fortran:

$ type relwrt.for
program relwrt
integer*4 i, buflen
character*80 buf
open(unit=1,file='rel.dat',status='new',form='formatted',
+ organization='relative',recl=512,recordtype='variable',
+ access='direct')
do 100 i = 1, 100
write(buf,'(14HThis is line #,i4.4,1H!)') i
buflen = index(buf,'!')
write(unit=1,rec=i) buf(1:buflen)
100 continue
close(unit=1)
end
$ for relwrt
$ link relwrt
$ run relwrt
$ type relrdseq.for
program relrdseq
integer*4 i, buflen
character*80 buf
open(unit=1,file='rel.dat',status='old',form='formatted',
+ organization='relative',recl=512,recordtype='variable',
+ access='sequential')
100 read(unit=1,fmt='(q,a)',end=200) buflen,buf
write(*,*) '|'//buf(1:buflen)//'|'
goto 100
200 close(unit=1)
end
$ for relrdseq
$ link relrdseq
$ run relrdseq
|This is line #0001!|
|This is line #0002!|
....
|This is line #0100!|
$ type relrddir.for
program relrddir
integer*4 i, buflen
character*80 buf
open(unit=1,file='rel.dat',status='old',form='formatted',
+ organization='relative',recl=512,recordtype='variable',
+ access='direct')
do 200 i = 1, 100
read(unit=1,fmt='(q,a)',rec=i) buflen,buf
write(*,*) '|'//buf(1:buflen)//'|'
200 continue
close(unit=1)
end
$ for relrddir
$ link relrddir
$ run relrddir
|This is line #0001!|
|This is line #0002!|
....
|This is line #0100!|

Arne

On 9/19/2023 8:44 PM, Arne Vajhøj wrote:
> On 9/16/2023 4:16 PM, Arne Vajhøj wrote:
>> I don't think I have ever used ORG=REL.
>
> But then I could start now!

Pascal:

$ type relwrt.pas
program relwrt(input,output);

type
string = varying [255] of char;

var
i : integer;
buf : string;
f : file of string;

begin
open(f, 'rel.dat', new,
organization := relative, record_length := 512, record_type :=
variable,
access_method := direct);
rewrite(f);
for i := 1 to 100 do begin
buf := 'This is line #' + dec(i, 4);
locate(f, i);
f^ := buf;
put(f);
end;
close(f);
end.
$ pas relwrt
$ link relwrt
$ run relwrt
$ type relrdseq.pas
program relrddir(input,output);

type
string = varying [255] of char;

var
i : integer;
buf : string;
f : file of string;

begin
open(f, 'rel.dat', old,
organization := relative, record_length := 512, record_type :=
variable,
access_method := sequential);
reset(f);
while not eof(f) do begin
buf := f^;
writeln('|' + buf + '|');
get(f);
end;
close(f);
end.
$ pas relrdseq
$ link relrdseq
$ run relrdseq
|This is line #0001|
|This is line #0002|
....
|This is line #0100|
$ type relrddir.pas
program relrddir(input,output);

type
string = varying [255] of char;

var
i : integer;
buf : string;
f : file of string;

begin
open(f, 'rel.dat', old,
organization := relative, record_length := 512, record_type :=
variable,
access_method := direct);
reset(f);
for i := 1 to 100 do begin
find(f, i);
buf := f^;
writeln('|' + buf + '|');
end;
close(f);
end.
$ pas relrddir
$ link relrddir
$ run relrddir
|This is line #0001|
|This is line #0002|
....
|This is line #0100|

Arne

On 9/19/2023 8:44 PM, Arne Vajhøj wrote:
> On 9/16/2023 4:16 PM, Arne Vajhøj wrote:
>> I don't think I have ever used ORG=REL.
>
> But then I could start now!

C / RMS:

$ type relwrt.c
#include <stdio.h>
#include <string.h>

#include <starlet.h>
#include <rms.h>

#define FNM "rel.dat"

int main(int argc, char *argv[])
{ long stat;
struct FAB fab;
struct RAB rab;
int i;
char buf[80];
fab = cc$rms_fab;
fab.fab$l_fna = (char *)FNM;
fab.fab$b_fns = strlen(FNM);
fab.fab$b_org = FAB$C_REL;
fab.fab$b_rfm = FAB$C_VAR;
fab.fab$l_fop = FAB$M_CIF;
fab.fab$w_mrs = 512;
fab.fab$b_fac = FAB$M_PUT;
stat = sys$create(&fab, 0, 0);
if(!(stat & 1)) {
printf("sys$create stat = %d\n", stat);
}
rab = cc$rms_rab;
rab.rab$l_fab = &fab;
rab.rab$b_rac = RAB$C_KEY;
stat = sys$connect(&rab, 0 ,0);
if(!(stat & 1)) {
printf("sys$connect stat = %d\n", stat);
}
for(i = 1; i <= 100; i++)
{
sprintf(buf, "This is line #%04d!", i);
rab.rab$l_kbf = (char *)&i;
rab.rab$b_ksz = sizeof(i);
rab.rab$l_rbf = buf;
rab.rab$w_rsz = strlen(buf);
stat = sys$put(&rab, 0, 0);
if(!(stat & 1)) {
printf("sys$put stat = %d\n", stat);
}
}
stat = sys$disconnect(&rab, 0, 0);
if(!(stat & 1)) {
printf("sys$disconnect stat = %d\n", stat);
}
stat = sys$close(&fab, 0, 0);
if(!(stat & 1)) {
printf("sys$close stat = %d\n", stat);
}
return 0;
}

$ cc relwrt
$ link relwrt
$ run relwrt
$ type relrdseq.c
#include <stdio.h>
#include <string.h>

#include <starlet.h>
#include <rms.h>

#define FNM "rel.dat"

int main(int argc, char *argv[])
{ long stat;
struct FAB fab;
struct RAB rab;
char buf[80];
fab = cc$rms_fab;
fab.fab$l_fna = (char *)FNM;
fab.fab$b_fns = strlen(FNM);
fab.fab$b_org = FAB$C_REL;
fab.fab$b_rfm = FAB$C_VAR;
fab.fab$w_mrs = 512;
fab.fab$b_fac = FAB$M_GET;
stat = sys$open(&fab, 0, 0);
if(!(stat & 1)) {
printf("sys$open stat = %d\n", stat);
}
rab = cc$rms_rab;
rab.rab$l_fab = &fab;
rab.rab$b_rac = RAB$C_SEQ;
stat = sys$connect(&rab, 0 ,0);
if(!(stat & 1)) {
printf("sys$connect stat = %d\n", stat);
}
for(;;)
{
rab.rab$l_ubf = buf;
rab.rab$w_usz = sizeof(buf);
stat = sys$get(&rab, 0, 0);
if(stat == RMS$_EOF) break;
if(!(stat & 1)) {
printf("sys$get stat = %d\n", stat);
}
buf[rab.rab$w_rsz] = 0;
printf("|%s|\n", buf);
}
stat = sys$disconnect(&rab, 0, 0);
if(!(stat & 1)) {
printf("sys$disconnect stat = %d\n", stat);
}
stat = sys$close(&fab, 0, 0);
if(!(stat & 1)) {
printf("sys$close stat = %d\n", stat);
}
return 0;
}

$ cc relrdseq
$ link relrdseq
$ run relrdseq
|This is line #0001!|
|This is line #0002!|
....
|This is line #0100!|
$ type relrddir.c
#include <stdio.h>
#include <string.h>

#include <starlet.h>
#include <rms.h>

#define FNM "rel.dat"

int main(int argc, char *argv[])
{ long stat;
struct FAB fab;
struct RAB rab;
int i;
char buf[80];
fab = cc$rms_fab;
fab.fab$l_fna = (char *)FNM;
fab.fab$b_fns = strlen(FNM);
fab.fab$b_org = FAB$C_REL;
fab.fab$b_rfm = FAB$C_VAR;
fab.fab$w_mrs = 512;
fab.fab$b_fac = FAB$M_GET;
stat = sys$open(&fab, 0, 0);
if(!(stat & 1)) {
printf("sys$open stat = %d\n", stat);
}
rab = cc$rms_rab;
rab.rab$l_fab = &fab;
rab.rab$b_rac = RAB$C_KEY;
stat = sys$connect(&rab, 0 ,0);
if(!(stat & 1)) {
printf("sys$connect stat = %d\n", stat);
}
for(i = 1; i <= 100; i++)
{
rab.rab$l_kbf = (char *)&i;
rab.rab$b_ksz = sizeof(i);
rab.rab$l_ubf = buf;
rab.rab$w_usz = sizeof(buf);
stat = sys$get(&rab, 0, 0);
if(!(stat & 1)) {
printf("sys$get stat = %d\n", stat);
}
buf[rab.rab$w_rsz] = 0;
printf("|%s|\n", buf);
}
stat = sys$disconnect(&rab, 0, 0);
if(!(stat & 1)) {
printf("sys$disconnect stat = %d\n", stat);
}
stat = sys$close(&fab, 0, 0);
if(!(stat & 1)) {
printf("sys$close stat = %d\n", stat);
}
return 0;
}

$ cc relrddir
$ link relrddir
$ run relrddir
|This is line #0001!|
|This is line #0002!|
....
|This is line #0100!|

Arne

On Tuesday, September 19, 2023 at 5:46:29 PM UTC-7, Arne Vajhøj wrote:

(snip)

> open(unit=1,file='rel.dat',status='new',form='formatted',
> + organization='relative',recl=512,recordtype='variable',
> + access='direct')
OP asked about fixed record size, and traditionally that is
the way it was done. I haven't followed that detail of later
Fortran standards. They have to, at least, allocate to the
maximum size.

On 9/19/2023 8:50 PM, Arne Vajhøj wrote:
> On 9/19/2023 8:44 PM, Arne Vajhøj wrote:
>> On 9/16/2023 4:16 PM, Arne Vajhøj wrote:
>>> I don't think I have ever used ORG=REL.
>>
>> But then I could start now!
>
> C / RMS:
>
> $ type relwrt.c
> #include <stdio.h>
> #include <string.h>
>
> #include <starlet.h>
> #include <rms.h>
>
> #define FNM "rel.dat"
>
> int main(int argc, char *argv[])
> {
> long stat;
> struct FAB fab;
> struct RAB rab;
> int i;
> char buf[80];
> fab = cc$rms_fab;
> fab.fab$l_fna = (char *)FNM;
> fab.fab$b_fns = strlen(FNM);
> fab.fab$b_org = FAB$C_REL;
> fab.fab$b_rfm = FAB$C_VAR;
> fab.fab$l_fop = FAB$M_CIF;
> fab.fab$w_mrs = 512;
> fab.fab$b_fac = FAB$M_PUT;
> stat = sys$create(&fab, 0, 0);
> if(!(stat & 1)) {
> printf("sys$create stat = %d\n", stat);
> }
> rab = cc$rms_rab;
> rab.rab$l_fab = &fab;
> rab.rab$b_rac = RAB$C_KEY;
> stat = sys$connect(&rab, 0 ,0);
> if(!(stat & 1)) {
> printf("sys$connect stat = %d\n", stat);
> }
> for(i = 1; i <= 100; i++)
> {
> sprintf(buf, "This is line #%04d!", i);
> rab.rab$l_kbf = (char *)&i;
> rab.rab$b_ksz = sizeof(i);
> rab.rab$l_rbf = buf;
> rab.rab$w_rsz = strlen(buf);
> stat = sys$put(&rab, 0, 0);
> if(!(stat & 1)) {
> printf("sys$put stat = %d\n", stat);
> }
> }
> stat = sys$disconnect(&rab, 0, 0);
> if(!(stat & 1)) {
> printf("sys$disconnect stat = %d\n", stat);
> }
> stat = sys$close(&fab, 0, 0);
> if(!(stat & 1)) {
> printf("sys$close stat = %d\n", stat);
> }
> return 0;
> }
>
> $ cc relwrt
> $ link relwrt
> $ run relwrt
> $ type relrdseq.c
> #include <stdio.h>
> #include <string.h>
>
> #include <starlet.h>
> #include <rms.h>
>
> #define FNM "rel.dat"
>
> int main(int argc, char *argv[])
> {
> long stat;
> struct FAB fab;
> struct RAB rab;
> char buf[80];
> fab = cc$rms_fab;
> fab.fab$l_fna = (char *)FNM;
> fab.fab$b_fns = strlen(FNM);
> fab.fab$b_org = FAB$C_REL;
> fab.fab$b_rfm = FAB$C_VAR;
> fab.fab$w_mrs = 512;
> fab.fab$b_fac = FAB$M_GET;
> stat = sys$open(&fab, 0, 0);
> if(!(stat & 1)) {
> printf("sys$open stat = %d\n", stat);
> }
> rab = cc$rms_rab;
> rab.rab$l_fab = &fab;
> rab.rab$b_rac = RAB$C_SEQ;
> stat = sys$connect(&rab, 0 ,0);
> if(!(stat & 1)) {
> printf("sys$connect stat = %d\n", stat);
> }
> for(;;)
> {
> rab.rab$l_ubf = buf;
> rab.rab$w_usz = sizeof(buf);
> stat = sys$get(&rab, 0, 0);
> if(stat == RMS$_EOF) break;
> if(!(stat & 1)) {
> printf("sys$get stat = %d\n", stat);
> }
> buf[rab.rab$w_rsz] = 0;
> printf("|%s|\n", buf);
> }
> stat = sys$disconnect(&rab, 0, 0);
> if(!(stat & 1)) {
> printf("sys$disconnect stat = %d\n", stat);
> }
> stat = sys$close(&fab, 0, 0);
> if(!(stat & 1)) {
> printf("sys$close stat = %d\n", stat);
> }
> return 0;
> }
>
> $ cc relrdseq
> $ link relrdseq
> $ run relrdseq
> |This is line #0001!|
> |This is line #0002!|
> ...
> |This is line #0100!|
> $ type relrddir.c
> #include <stdio.h>
> #include <string.h>
>
> #include <starlet.h>
> #include <rms.h>
>
> #define FNM "rel.dat"
>
> int main(int argc, char *argv[])
> {
> long stat;
> struct FAB fab;
> struct RAB rab;
> int i;
> char buf[80];
> fab = cc$rms_fab;
> fab.fab$l_fna = (char *)FNM;
> fab.fab$b_fns = strlen(FNM);
> fab.fab$b_org = FAB$C_REL;
> fab.fab$b_rfm = FAB$C_VAR;
> fab.fab$w_mrs = 512;
> fab.fab$b_fac = FAB$M_GET;
> stat = sys$open(&fab, 0, 0);
> if(!(stat & 1)) {
> printf("sys$open stat = %d\n", stat);
> }
> rab = cc$rms_rab;
> rab.rab$l_fab = &fab;
> rab.rab$b_rac = RAB$C_KEY;
> stat = sys$connect(&rab, 0 ,0);
> if(!(stat & 1)) {
> printf("sys$connect stat = %d\n", stat);
> }
> for(i = 1; i <= 100; i++)
> {
> rab.rab$l_kbf = (char *)&i;
> rab.rab$b_ksz = sizeof(i);
> rab.rab$l_ubf = buf;
> rab.rab$w_usz = sizeof(buf);
> stat = sys$get(&rab, 0, 0);
> if(!(stat & 1)) {
> printf("sys$get stat = %d\n", stat);
> }
> buf[rab.rab$w_rsz] = 0;
> printf("|%s|\n", buf);
> }
> stat = sys$disconnect(&rab, 0, 0);
> if(!(stat & 1)) {
> printf("sys$disconnect stat = %d\n", stat);
> }
> stat = sys$close(&fab, 0, 0);
> if(!(stat & 1)) {
> printf("sys$close stat = %d\n", stat);
> }
> return 0;
> }
>
> $ cc relrddir
> $ link relrddir
> $ run relrddir
> |This is line #0001!|
> |This is line #0002!|
> ...
> |This is line #0100!|
>
> Arne
>
>

Is it just me, or, was my Basic example shorter and easier to read than your
Cobol, Fortran, and C examples?

--
David Froble Tel: 724-529-0450
Dave Froble Enterprises, Inc. E-Mail: davef@tsoft-inc.com
DFE Ultralights, Inc.
170 Grimplin Road
Vanderbilt, PA 15486

On Tuesday, September 19, 2023 at 11:15:21 PM UTC-4, gah4 wrote:
> On Tuesday, September 19, 2023 at 5:46:29 PM UTC-7, Arne Vajhøj wrote:
>
> (snip)
> > open(unit=1,file='rel.dat',status='new'
,form='formatted',
> > + organization='relative',recl=512,recordtype='variable',
> > + access='direct')
> OP asked about fixed record size, and traditionally that is
> the way it was done. I haven't followed that detail of later
> Fortran standards. They have to, at least, allocate to the
> maximum size.

Yes indeed traditionally folks only had half a clue about RMS and vaguely know 512 was a special value and very popular.

With that they proceeded to maximize their storage losses.

The one flag byte overhead relative file records have (plus two for variable) makes the cells larger than 512
By default FORTRANT/RMS will now use the default 2 block bucketsize
Thus wasting 511 (509) bytes per 512 byte record.

Running Arne's sample code:

$ sear/log rel.dat blah
%SEARCH-S-NOMATCH, DSA3:[DECUSERVE_USER.HEIN]REL.DAT;1 - 100 records
$ dire/full rel.dat
: File organization: Relative, maximum record number: 2147483647
File attributes: Allocation: 201, Extend: 0, Bucket size: 2, Global buffer count: 0, No version limit
Record format: Variable length, maximum 512 bytes, longest 0 bytes
: Total of 1 file, 201/201 blocks.
$

Grins,
Hein.

On Tuesday, September 19, 2023 at 9:18:43 PM UTC-7, Hein RMS van den Heuvel wrote:
> On Tuesday, September 19, 2023 at 11:15:21 PM UTC-4, gah4 wrote:

(snip)
> > OP asked about fixed record size, and traditionally that is
> > the way it was done. I haven't followed that detail of later
> > Fortran standards. They have to, at least, allocate to the
> > maximum size.

> Yes indeed traditionally folks only had half a clue about RMS and vaguely know 512 was a special value and very popular.
>
> With that they proceeded to maximize their storage losses.
>
> The one flag byte overhead relative file records have (plus two for variable) makes the cells larger than 512
> By default FORTRANT/RMS will now use the default 2 block bucketsize
> Thus wasting 511 (509) bytes per 512 byte record.
>
> Running Arne's sample code:
>
> $ sear/log rel.dat blah
> %SEARCH-S-NOMATCH, DSA3:[DECUSERVE_USER.HEIN]REL.DAT;1 - 100 records
> $ dire/full rel.dat
> :
> File organization: Relative, maximum record number: 2147483647
> File attributes: Allocation: 201, Extend: 0, Bucket size: 2, Global buffer count: 0, No version limit
> Record format: Variable length, maximum 512 bytes, longest 0 bytes
> :
> Total of 1 file, 201/201 blocks.
> $
I was remembering the PDP-10, which has 128 36bit words per disk block.

And I do remember carefully designing the record to be 128 words.
(There are no overhead words for direct access file for Fortran-10.)

I wrote a Fortran-10 program as a translation of a BASIC program
called PCAVES, public caves ,which allowed you to move, write on
the walls, and dig new rooms. It was one file block per room.

The HP BASIC system uses, I believe, 256 byte blocks for its files.

That was the time of FILDAE, which allowed one to have file that could
be accessed by others running (only) your program.

And I had record locking, which was done with MACRO-10 subroutines,
as Fortran didn't do it.

IBM OS/360 formats the disk tracks for the record size you select.
There is no need for a special size, though there is overhead.

On 9/20/2023 12:02 AM, Dave Froble wrote:
> On 9/19/2023 8:50 PM, Arne Vajhøj wrote:
>> On 9/19/2023 8:44 PM, Arne Vajhøj wrote:
>>> On 9/16/2023 4:16 PM, Arne Vajhøj wrote:
>>>> I don't think I have ever used ORG=REL.
>>>
>>> But then I could start now!
>>
>> C / RMS:
>
> Is it just me, or, was my Basic example shorter and easier to read than
> your Cobol, Fortran, and C examples?

The Basic code was a bit shorter than the Fortran and Pascal code.
No so surprising VMS Basic is pretty good in expressing logic
in few lines.

The Basic code was a lot shorter than the C code, because
that was using RMS calls and not language specific statement -
working with RMS Calls and FAB & RAB blocks always require
way more code than language specific statements.

What is easier to read depends a lot on what language
people know.

:-)

Arne

On 9/19/2023 11:15 PM, gah4 wrote:
> On Tuesday, September 19, 2023 at 5:46:29 PM UTC-7, Arne Vajhøj wrote:
>> open(unit=1,file='rel.dat',status='new',form='formatted',
>> + organization='relative',recl=512,recordtype='variable',
>> + access='direct')
>
> OP asked about fixed record size, and traditionally that is
> the way it was done. I haven't followed that detail of later
> Fortran standards. They have to, at least, allocate to the
> maximum size.

True.

I added a little more for my example.

If I understand the docs correctly then the above
allocates 512 bytes (per recl) for each cell, but
handles actual lengths 0-512 within that cell.

Arne

On 2023-09-20, Arne Vajhøj <arne@vajhoej.dk> wrote:
> On 9/19/2023 11:15 PM, gah4 wrote:
>> On Tuesday, September 19, 2023 at 5:46:29?PM UTC-7, Arne Vajhøj wrote:
>>> open(unit=1,file='rel.dat',status='new',form='formatted',
>>> + organization='relative',recl=512,recordtype='variable',
>>> + access='direct')
>>
>> OP asked about fixed record size, and traditionally that is
>> the way it was done. I haven't followed that detail of later
>> Fortran standards. They have to, at least, allocate to the
>> maximum size.
>
> True.
>
> I added a little more for my example.
>
> If I understand the docs correctly then the above
> allocates 512 bytes (per recl) for each cell, but
> handles actual lengths 0-512 within that cell.
>

It allocates 512 bytes for the _data_ within that cell. It then allocates
a bit more per record to store the length of each record. Look at the
example Hein posted.

$ set response/mode=good_natured

Even without your statement about never having used relative files,
at this point I would be actively suspecting that to be the case. :-)

I _have_ used relative files in the past in a number of cases, but I have
never, ever, used anything other than fixed length records with them.

The idea of variable length records within a relative file is utterly
alien to me.

Simon.

--
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Walking destinations on a map are further away than they appear.

On 2023-09-20, Dave Froble <davef@tsoft-inc.com> wrote:
>
> Is it just me, or, was my Basic example shorter and easier to read than your
> Cobol, Fortran, and C examples?
>

Arne could always add a Macro-32 example to that list... :-)

Simon.

--
Simon Clubley, clubley@remove_me.eisner.decus.org-Earth.UFP
Walking destinations on a map are further away than they appear.

On 9/19/2023 11:15 PM, gah4 wrote:
> On Tuesday, September 19, 2023 at 5:46:29 PM UTC-7, Arne Vajhøj wrote:
>
> (snip)
>
>> open(unit=1,file='rel.dat',status='new',form='formatted',
>> + organization='relative',recl=512,recordtype='variable',
>> + access='direct')
>
> OP asked about fixed record size, and traditionally that is
> the way it was done. I haven't followed that detail of later
> Fortran standards. They have to, at least, allocate to the
> maximum size.

I have an example in COBOL I just wrote if anyone is interested.

Funny thing about this. I found very little about it in any of
the (many) COBOL books I have. I also don't remember ever having
done it in a production program in my entire 40 year career.
This kind of task was done much better with ISAM and today it
would be database.

bill

On Wednesday, September 20, 2023 at 5:22:55 AM UTC-7, Simon Clubley wrote:

(snip)
> >> On Tuesday, September 19, 2023 at 5:46:29?PM UTC-7, Arne Vajhøj wrote:
> >>> open(unit=1,file='rel.dat',status='new',form='formatted',
> >>> + organization='relative',recl=512,recordtype='variable',
> >>> + access='direct')

(then I wrote)
> >> OP asked about fixed record size, and traditionally that is
> >> the way it was done. I haven't followed that detail of later
> >> Fortran standards. They have to, at least, allocate to the
> >> maximum size.

(snip)

> It allocates 512 bytes for the _data_ within that cell. It then allocates
> a bit more per record to store the length of each record. Look at the
> example Hein posted.

OK, I finally got back to checking the Fortran standard.

It seems that variable length direct access hasn't made its
way to the Fortran standard yet. Implementations are allowed to
have extensions, so it seems that VMS has this one.

On Wednesday, September 20, 2023 at 8:24:48 AM UTC-4, Simon Clubley wrote:
> On 2023-09-20, Dave Froble <da...@tsoft-inc.com> wrote:
> >
> > Is it just me, or, was my Basic example shorter and easier to read than your
> > Cobol, Fortran, and C examples?
> >
> Arne could always add a Macro-32 example to that list... :-)

We all realize that the OP question has been answered and that RMS Relative files are really a moot point in the whole discussion right?

That said... Macro anyone? See below.

Hein.

.psect data, wrt, noexe
buf: .blkb 32*1024
fao_d: .ascid "This is line #!4ZL!!"
out_s: .long 0
out_d: .long 512
.address buf
outfab: $FAB fnm=rel.dat, org=rel, fac=put, bks=32, mrs=512, rfm=var, rat=cr
outrab: $RAB fab=outfab, rbf=buf, rsz=500

.psect code, nowrt, exe
.entry start,0
$create fab=outfab
$connect rab=outrab
blbc r0, end
clrl r10
loop: incl r10
cmpl r10, #100
bgtr end
movl #512, out_d
pushl r10
pushal out_d
pushal out_s
pushal fao_d
calls #4, g^sys$fao
blbc r0, end
movw out_s, outrab+rab$w_rsz
$put rab=outrab
blbs r0, loop
end:
ret
.end start