RMS

[inherit('sys$library:pascal$lib_routines')]
program seq(input,output);

var
   cmd : varying [80] of char;
   line : varying [80] of char;
   f : text;

begin
   lib$get_foreign(cmd.body,,cmd.length);
   writeln('Pascal - ' + cmd);
   open(f, cmd, old);
   reset(f);
   while not(eof(f)) do begin
      readln(f, line);
      writeln('|' + line + '|', line.length);
   end;
   close(f);
end.

Pascal - var.txt
|A|         1
|BB|         2
|CCC|         3
Pascal - vfc.txt
|A|         1
|BB|         2
|CCC|         3
Pascal - stm.txt
|A|         1
|BB|         2
|CCC|         3
Pascal - stmlf.txt
|A|         1
|BB|         2
|CCC|         3
Pascal - stmcr.txt
|A|         1
|BB|         2
|CCC|         3
Pascal - fix1.txt
|A|         1
|B|         1
|C|         1
Pascal - fix2.txt
|AA|         2
|BB|         2
|CC|         2

identification division.
program-id.seq.
*
environment division.
input-output section.
file-control.
    select in-file assign to "dummy.dat" organization is line sequential.
*
data division.
file section.
fd in-file value of id is infnm.
01 in-record.
    03 lin pic x(80).
working-storage section.
01 infnm pic x(80).
01 cmd pic x(80).
01 cmdlen pic s9(8) comp.
01 eof-flag pic x.
01 linlen pic s9(8) comp.
01 linlen2 pic 9(8) display.
*
procedure division.
main-paragraph.
    call "lib$get_foreign" using by descriptor cmd, omitted, by reference cmdlen
    display "Cobol - " cmd(1:cmdlen)
    move cmd(1:cmdlen) to infnm
    open input in-file
    move 'N' to eof-flag
    perform until eof-flag = 'Y'
        read in-file
            at end move 'Y' to eof-flag
            not at end perform display-line-paragraph
        end-read
    end-perform
    close in-file
    stop run.
display-line-paragraph.
    move 80 to linlen
    call "trim" using lin, linlen giving linlen
    move linlen to linlen2
    display "|" lin(1:linlen) "| " linlen2.

identification division.
program-id.trim.

data division.
working-storage section.
01 actlen pic s9(8) comp.
linkage section.
01 s pic x(256).
01 len pic s9(8) comp.

procedure division using s,len giving actlen.
main-paragraph.
    move len to actlen.
    perform varying actlen from len by -1 until s(actlen:1) not = " " or actlen = 1
        continue
    end-perform.
    end program trim.

Cobol - var.txt
|A| 00000001
|BB| 00000002
|CCC| 00000003
Cobol - vfc.txt
|A| 00000001
|BB| 00000002
|CCC| 00000003
Cobol - stm.txt
|A| 00000001
|BB| 00000002
|CCC| 00000003
Cobol - stmlf.txt
|A| 00000001
|BB| 00000002
|CCC| 00000003
Cobol - stmcr.txt
|A| 00000001
|BB| 00000002
|CCC| 00000003
Cobol - fix1.txt
|A| 00000001
|B| 00000001
|C| 00000001
Cobol - fix2.txt
|AA| 00000002
|BB| 00000002
|CC| 00000002

program seq

option type = explicit

declare string cmd
map (buf) string lin = 80

external sub lib$get_foreign(string)
external string function trim(string)

call lib$get_foreign(cmd)
print "Basic - " + cmd
open "var.txt" for input as file #1, map buf
handler eof_handler
end handler
when error use eof_handler
    while 1 = 1
        get #1
        print "|" + trim(lin) + "|", len(trim(lin))
    next
end when
close #1

end program
!
function string trim(string s)

option type = explicit

declare integer ix

ix = len(s)
while ix > 1 and mid$(s, ix, 1) = chr$(0)
    ix = ix - 1
next
trim = mid$(s, 1, ix)

end function

Basic - var.txt
|A|            1
|BB|           2
|CCC|          3
Basic - vfc.txt
|A|            1
|BB|           2
|CCC|          3
Basic - stm.txt
|A|            1
|BB|           2
|CCC|          3
Basic - stmlf.txt
|A|            1
|BB|           2
|CCC|          3
Basic - stmcr.txt
|A|            1
|BB|           2
|CCC|          3
Basic - fix1.txt
|A|            1
|BB|           2
|CCC|          3
Basic - fix2.txt
|A|            1
|BB|           2
|CCC|          3

$ write sys$output "DCL - ''p1'"
$ open/read f 'p1'
$ loop:
$    read/end=endloop f line
$    write sys$output f$fao("|!AS| !SL", line, f$length(line))
$    goto loop
$ endloop:
$ close f
$ exit

DCL - VAR.TXT
|A| 1
|BB| 2
|CCC| 3
DCL - VFC.TXT
|A| 1
|BB| 2
|CCC| 3
DCL - STM.TXT
|A| 1
|BB| 2
|CCC| 3
DCL - STMLF.TXT
|A| 1
|BB| 2
|CCC| 3
DCL - STMCR.TXT
|A| 1
|BB| 2
|CCC| 3
DCL - FIX1.TXT
|A| 1
|B| 1
|C| 1
DCL - FIX2.TXT
|AA| 2
|BB| 2
|CC| 2

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main(int argc, char *argv[])
{
   cout << "C++ - " << argv[1] << endl;
   ifstream f(argv[1]);
   string line;
   while(getline(f, line))
   {
      cout << "|" << line << "| " << line.length() << endl;
   }
   f.close();
   return 0;
}

C++ - var.txt
|A| 1
|BB| 2
|CCC| 3
C++ - vfc.txt
|A| 1
|BB| 2
|CCC| 3
C++ - stm.txt
|A| 1
|BB| 2
|CCC| 3
C++ - stmlf.txt
|A| 1
|BB| 2
|CCC| 3
C++ - stmcr.txt
|A| 1
|BB| 2
|CCC| 3
C++ - fix1.txt
|A| 1
|B| 1
|C| 1
C++ - fix2.txt
|AA| 2
|BB| 2
|CC| 2

println("Groovy (lines) - " + args[0])
br = new BufferedReader(new FileReader(args[0]))
while((line = br.readLine()) != null) {
    println("|" + line + "| " + line.length())
}
br.close()

Groovy (lines) - VAR.TXT
|A| 1
|BB| 2
|CCC| 3
Groovy (lines) - VFC.TXT
|A| 1
|BB| 2
|CCC| 3
Groovy (lines) - STM.TXT
|A| 1
|BB| 2
|CCC| 3
Groovy (lines) - STMLF.TXT
|A| 1
|BB| 2
|CCC| 3
Groovy (lines) - STMCR.TXT
|A| 1
|BB| 2
|CCC| 3
Groovy (lines) - FIX1.TXT
|A| 1
|B| 1
|C| 1
Groovy (lines) - FIX2.TXT
|AA| 2
|BB| 2
|CC| 2

import sys

print('Python (lines) - ' + sys.argv[1])
f = open(sys.argv[1], 'r')
for line in f:
    print('|' + line.rstrip() + '| ' + str(len(line.rstrip())))
f.close()

Python (lines) - VAR.TXT
|A| 1
|BB| 2
|CCC| 3
Python (lines) - VFC.TXT
|A| 1
|BB| 2
|CCC| 3
Python (lines) - STM.TXT
|A| 1
|BB| 2
|CCC| 3
Python (lines) - STMLF.TXT
|A| 1
|BB| 2
|CCC| 3
Python (lines) - STMCR.TXT
|A| 1
|BB| 2
|CCC| 3
Python (lines) - FIX1.TXT
|A| 1
|B| 1
|C| 1
Python (lines) - FIX2.TXT
|AA| 2
|BB| 2
|CC| 2

<?php
echo "PHP (lines) - ${argv[1]}\n";
$fp = fopen($argv[1], 'r');
while($line = fgets($fp)) {
    $line = rtrim($line);
    $len = strlen($line);
    echo "|$line| $len\n";
}
fclose($fp);
?>

PHP (lines) - var.txt
|A| 1
|BB| 2
|CCC| 3
PHP (lines) - vfc.txt
|A| 1
|BB| 2
|CCC| 3
PHP (lines) - stm.txt
|A| 1
|BB| 2
|CCC| 3
PHP (lines) - stmlf.txt
|A| 1
|BB| 2
|CCC| 3
PHP (lines) - stmcr.txt
|A| 1
|BB| 2
|CCC| 3
PHP (lines) - fix1.txt
|A| 1
|B| 1
|C| 1
PHP (lines) - fix2.txt
|AA| 2
|BB| 2
|CC| 2

#include <stdio.h>

int main(int argc, char *argv[])
{
   printf("C (text, bytes, ctx=stm) - %s\n", argv[1]);
   FILE *fp = fopen(argv[1], "r", "ctx=stm");
   int eol;
   int c;
   while((c = fgetc(fp)) >= 0)
   {
      if(c == '\n')
      {
         printf("\n");
         eol = 1;
      }
      else
      {
         printf("%02X", c);
         eol = 0;
      }
   }
   if(!eol) printf("\n");
   fclose(fp);
}

C (text, bytes, ctx=stm) - var.txt
0100410002004242030043434300
C (text, bytes, ctx=stm) - vfc.txt
0300018D41000400018D42420500018D43434300
C (text, bytes, ctx=stm) - stm.txt
410D
42420D
4343430D
C (text, bytes, ctx=stm) - stmlf.txt
41
4242
434343
C (text, bytes, ctx=stm) - stmcr.txt
410D42420D4343430D
C (text, bytes, ctx=stm) - fix1.txt
410042004300
C (text, bytes, ctx=stm) - fix2.txt
414142424343

#include <stdio.h>

int main(int argc, char *argv[])
{
   printf("C (binary, bytes) - %s\n", argv[1]);
   FILE *fp = fopen(argv[1], "rb");
   int c;
   while((c = fgetc(fp)) >= 0)
   {
      printf("%02X", c);
   }
   printf("\n");
   fclose(fp);
}

C (binary, bytes) - var.txt
414242434343
C (binary, bytes) - vfc.txt
018D41018D4242018D434343
C (binary, bytes) - stm.txt
414242434343
C (binary, bytes) - stmlf.txt
410A42420A4343430A
C (binary, bytes) - stmcr.txt
414242434343
C (binary, bytes) - fix1.txt
414243
C (binary, bytes) - fix2.txt
414142424343

println("Groovy (bytes) - " + args[0])
is = new FileInputStream(args[0])
while((c = is.read()) >= 0) {
    if(c == '\n')
        printf("\n")
    else
        printf("%02X", c)
}
is.close()

Groovy (bytes) - VAR.TXT
41
4242
434343
Groovy (bytes) - VFC.TXT
41
4242
434343
Groovy (bytes) - STM.TXT
41
4242
434343
Groovy (bytes) - STMLF.TXT
41
4242
434343
Groovy (bytes) - STMCR.TXT
41
4242
434343
Groovy (bytes) - FIX1.TXT
41
42
43
Groovy (bytes) - FIX2.TXT
4141
4242
4343

import sys

print('Python (bytes) - ' + sys.argv[1])
f = open(sys.argv[1], 'r')
s = ''
while True:
    c = f.read(1)
    if c == '':
        break
    if c == '\n':
        print(s)
        s = ''
    else:
        s = s + ('%02X' % (ord(c)))
if len(s) > 0:
    print(s)
f.close()

Python (bytes) - VAR.TXT
41
4242
434343
Python (bytes) - VFC.TXT
41
4242
434343
Python (bytes) - STM.TXT
41
4242
434343
Python (bytes) - STMLF.TXT
41
4242
434343
Python (bytes) - STMCR.TXT
41
4242
434343
Python (bytes) - FIX1.TXT
41
42
43
Python (bytes) - FIX2.TXT
4141
4242
4343

import sys

print('Python (binary, bytes) - ' + sys.argv[1])
f = open(sys.argv[1], 'rb')
s = ''
while True:
    c = f.read(1)
    if c == '':
        break
    s = s + ('%02X' % (ord(c)))
print(s)
f.close()

Python (binary, bytes) - VAR.TXT
410A42420A4343430A
Python (binary, bytes) - VFC.TXT
410A42420A4343430A
Python (binary, bytes) - STM.TXT
410A42420A4343430A
Python (binary, bytes) - STMLF.TXT
410A42420A4343430A
Python (binary, bytes) - STMCR.TXT
410A42420A4343430A
Python (binary, bytes) - FIX1.TXT
410A420A430A
Python (binary, bytes) - FIX2.TXT
41410A42420A43430A

Python 2.x:

import sys

print('Python (binary, bytes) - ' + sys.argv[1])
f = open(sys.argv[1], 'rb')
s = ''
while True:
    c = f.read(1)
    if c == '':
        break
    s = s + ('%02X' % (ord(c)))
print(s)
f.close()

Python 3.x:

import sys

print('Python (binary, bytes) - ' + sys.argv[1])
f = open(sys.argv[1], 'rb')
s = ''
while True:
    c = f.read(1)
    if c == b'':
        break
    s = s + ('%02X' % (ord(c)))
print(s)
f.close()

(the Python 2.x - 3.x difference does not relate to IO)

Python (binary, bytes) - var.txt
0100410002004242030043434300
Python (binary, bytes) - vfc.txt
0300018D41000400018D42420500018D43434300
Python (binary, bytes) - stm.txt
410D0A42420D0A4343430D0A
Python (binary, bytes) - stmlf.txt
410A42420A4343430A
Python (binary, bytes) - stmcr.txt
410D42420D4343430D
Python (binary, bytes) - fix1.txt
410042004300
Python (binary, bytes) - fix2.txt
414142424343

<?php
echo "PHP (bytes) - ${argv[1]}\n";
$fp = fopen($argv[1], 'r');
$eol = false;
while($c = fgetc($fp)) {
    $c = ord($c);
    if($c == 10) {
        echo "\n";
        $eol = true;
    } else {
        echo sprintf('%02X', $c);
        $eol = false;
    }
}
if(!$eol) echo "\n";
fclose($fp);
?>

PHP (bytes) - var.txt
41
4242
434343
PHP (bytes) - vfc.txt
41
4242
434343
PHP (bytes) - stm.txt
41
4242
434343
PHP (bytes) - stmlf.txt
41
4242
434343
PHP (bytes) - stmcr.txt
41
4242
434343
PHP (bytes) - fix1.txt
41
42
43
PHP (bytes) - fix2.txt
4141
4242
4343

<?php
echo "PHP (binary, bytes) - ${argv[1]}\n";
$fp = fopen($argv[1], 'rb');
while($c = fgetc($fp)) {
    $c = ord($c);
    echo sprintf('%02X', $c);
}
echo "\n";
fclose($fp);
?>

PHP (binary, bytes) - var.txt
410A42420A4343430A
PHP (binary, bytes) - vfc.txt
410A42420A4343430A
PHP (binary, bytes) - stm.txt
414242434343
PHP (binary, bytes) - stmlf.txt
410A42420A4343430A
PHP (binary, bytes) - stmcr.txt
414242434343
PHP (binary, bytes) - fix1.txt
414243
PHP (binary, bytes) - fix2.txt
414142424343

println("Groovy (blocks) - " + args[0])
is = new FileInputStream(args[0])
buf = new byte[512]
while((n  = is.read(buf)) > 0) {
    for(i in 0..n-1) {
        if(buf[i] == '\n')
            printf("\n")
        else
            printf("%02X", buf[i])
    }
}
is.close()

Groovy (blocks) - VAR.TXT
41
4242
434343
Groovy (blocks) - VFC.TXT
41
4242
434343
Groovy (blocks) - STM.TXT
41
4242
434343
Groovy (blocks) - STMLF.TXT
41
4242
434343
Groovy (blocks) - STMCR.TXT
41
4242
434343
Groovy (blocks) - FIX1.TXT
41
42
43
Groovy (blocks) - FIX2.TXT
4141
4242
4343

import sys

print('Python (binary, blocks) - ' + sys.argv[1])
f = open(sys.argv[1], 'rb')
buf = f.read(512)
s = ''
for c in buf:
    s = s + ('%02X' % (ord(c)))
print(s)
f.close()

Python (binary, blocks) - var.txt
410A42420A4343430A
Python (binary, blocks) - vfc.txt
410A42420A4343430A
Python (binary, blocks) - stm.txt
410A42420A4343430A
Python (binary, blocks) - stmlf.txt
410A42420A4343430A
Python (binary, blocks) - stmcr.txt
410A42420A4343430A
Python (binary, blocks) - fix1.txt
410A420A430A
Python (binary, blocks) - fix2.txt
41410A42420A43430A

<?php
echo "PHP (binary, blocks) - ${argv[1]}\n";
$fp = fopen($argv[1], 'rb');
$buf = fread($fp, 512);
for($i = 0; $i < strlen($buf); $i++) {
    echo sprintf('%02X', ord($buf[$i]));
}
echo "\n";
fclose($fp);
?>

PHP (binary, blocks) - var.txt
410A42420A4343430A
PHP (binary, blocks) - vfc.txt
410A42420A4343430A
PHP (binary, blocks) - stm.txt
414242434343
PHP (binary, blocks) - stmlf.txt
410A42420A4343430A
PHP (binary, blocks) - stmcr.txt
414242434343
PHP (binary, blocks) - fix1.txt
414243
PHP (binary, blocks) - fix2.txt
414142424343

Pascal has default.

program cre(input,output);

var
   f : text;

begin
   open(f, 'pas.txt', new);
   rewrite(f);
   writeln(f, 'A');
   writeln(f, 'BB');
   writeln(f, 'CCC');
   close(f);
end.

Result:

$ pas cre
$ link cre
$ run cre
$ call dump "pas.txt"
pas.txt : ORG=SEQ RFM=VAR RAT=CR MRS=0

But file attributes can be specified explicit in OPEN.

program crex(input,output);

var
   f : text;

begin
   open(f, 'pasx.txt', new, record_type := stream_lf);
   rewrite(f);
   writeln(f, 'A');
   writeln(f, 'BB');
   writeln(f, 'CCC');
   close(f);
end.

Result:

$ pas crex
$ link crex
$ run crex
$ call dump "pasx.txt"
pasx.txt : ORG=SEQ RFM=STMLF RAT=CR MRS=0

Cobol has default.

identification division.
program-id.cre.
*
environment division.
input-output section.
file-control.
    select f assign to "cob.txt" organization is sequential.
*
data division.
file section.
fd f.
01 buf.
    03 lin pic x(80).
*
procedure division.
main-paragraph.
    open output  f
    move "A" to lin
    write buf
    move "BB" to lin
    write buf
    move "CCC" to lin
    write buf
    close f
    stop run.

Result:

$ cob cre
$ link cre
$ run cre
$ call dump "cob.txt"
cob.txt : ORG=SEQ RFM=FIX RAT=CR MRS=80

But there are a few options to impact file attributes in the way the file is opened.

identification division.
program-id.crex.
*
environment division.
input-output section.
file-control.
    select f assign to "cobx.txt" organization is line sequential.
*
data division.
file section.
fd f record is varying in size from 0 to 80 depending on linlen.
01 buf.
    03 lin pic x(80).
working-storage section.
01 linlen pic 9(9) comp.
*
procedure division.
main-paragraph.
    open output  f
    move "A" to lin
    move 1 to linlen
    write buf
    move "BB" to lin
    move 2 to linlen
    write buf
    move "CCC" to lin
    move 3 to linlen
    write buf
    close f
    stop run.

Result:

$ cob crex
$ link crex
$ run crex
$ call dump "cobx.txt"
cobx.txt : ORG=SEQ RFM=STMLF RAT=CR MRS=80

Basic got default.

program cre

open "bas.txt" for output as file #1
print #1, "A"
print #1, "BB"
print #1, "CCC"
close #1

end program

Result:

$ bas cre
$ link cre
$ run cre
bas.txt : ORG=SEQ RFM=VAR RAT=CR MRS=132

But file attributes can to some extent be controlled in OPEN.

program cre

open "basx.txt" for output as file #1, organization sequential stream
print #1, "A"
print #1, "BB"
print #1, "CCC"
close #1

end program

Result:

$ bas crex
$ link crex
$ run crex
$ call dump "basx.txt"
basx.txt : ORG=SEQ RFM=STM RAT=CR MRS=132

$ open/write f dcl.txt
$ write f "A"
$ write f "BB"
$ write f "CCC"
$ close f
$ exit

Result:

$ @cre
$ call dump "dcl.txt"
dcl.txt : ORG=SEQ RFM=VFC RAT=PRN MRS=0

$ create/fdl="record; format var" dclx.txt
$ open/append f dclx.txt
$ write f "A"
$ write f "BB"
$ write f "CCC"
$ close f
$ exit

Result:

$ @crex
$ call dump "dclx.txt"
dclx.txt : ORG=SEQ RFM=VAR RAT=CR MRS=0

Other JVM languages like Groovy obviously behave like Java.

pw = new PrintWriter(new FileWriter(args[0]))
pw.println("A")
pw.println("BB")
pw.println("CCC")
pw.close()

Result:

$ groovy Cre.groovy gr.txt
$ call dump "gr.txt"
gr.txt : ORG=SEQ RFM=STMLF RAT=CR MRS=0

Result:

$ define/nolog java$filename_match_list "GRX.TXT=rfm=var/rat=cr"
$ groovy Cre.groovy grx.txt
$ call dump "grx.txt"
grx.txt : ORG=SEQ RFM=VAR RAT=CR MRS=0

Other JVM languages like Jython obviously behave like Java.

from sys import argv

f = open(argv[1], 'w')
f.write('A\n')
f.write('BB\n')
f.write('CCC\n')
f.close()

Result:

$ jython cre2.py
$ call dump "jy.txt"
jy.txt : ORG=SEQ RFM=STMLF RAT=CR MRS=0

Result (Jython 2.7 on Java 8 on VMS Itanium and VMS x86-64):

$ define/nolog java$filename_match_list "*JYX.TXT=rfm=var/rat=cr"
$ jython cre2.py jyx.txt
$ call dump "jyx.txt"
jyx.txt : ORG=SEQ RFM=VAR RAT=CR MRS=0

(Jython 2.5 on Java 5 on VMS Alpha gave an error)

<?php
$fp = fopen('php.txt', 'w');
fwrite($fp, "A\n");
fwrite($fp, "BB\n");
fwrite($fp, "CCC\n");
fclose($fp);
?>

Result:

$ php cre.php
$ call dump "php.txt"
php.txt : ORG=SEQ RFM=STMLF RAT=CR MRS=0

program dir(input,output);

type
   fixstr = packed array [1..4] of char;

var
   f : file of fixstr;

procedure test_write_one(ix : integer; val : fixstr);

begin
   locate(f, ix);
   f^ := val;
   put(f);
end;

procedure test_write;

begin
   open(f, 'pas.fix', new,
        organization := sequential, record_length := 4, record_type := fixed,
        access_method := direct);
   rewrite(f);
   test_write_one(3, 'CCCC');
   test_write_one(2, 'BBBB');
   test_write_one(1, 'AAAA');
   close(f);
end;

procedure test_read_sequential;

var
   val : fixstr;

begin
   open(f, 'pas.fix', old,
        organization := sequential, record_length := 4, record_type := fixed,
        access_method := sequential);
   reset(f);
   while not(eof(f)) do begin
      val := f^;
      writeln('|' + val + '|', length(val));
      get(f);
   end;
   close(f);
end;

procedure test_read_random_one(ix : integer);

var
   val : fixstr;

begin
   find(f, ix);
   val := f^;
   writeln('|' + val + '|', length(val));   
end;

procedure test_read_random;

begin
   open(f, 'pas.fix', old,
        organization := sequential, record_length := 4, record_type := fixed,
        access_method := direct);
   test_read_random_one(3);
   test_read_random_one(2);
   test_read_random_one(1);
   close(f);
end;

begin
   writeln('Pascal');
   test_write;
   test_read_sequential;
   test_read_random;
end.

program dir

option type = explicit

external sub test_write()
external sub test_read_sequential()
external sub test_write_random()

print "Basic"
call test_write
call test_read_sequential
call test_read_random

end program
!
sub test_write()

option type = explicit

map(buf) string lin = 4

open "bas.fix" for output as file #1, organization sequential fixed, recordsize 4, map buf
lin = "CCCC"
put #1, record 3
lin = "BBBB"
find #1, record 2
update #1
lin = "AAAA"
find #1, record 1
update #1
close #1

end sub
!
sub test_read_sequential()

option type = explicit

map (buf) string lin = 4

open "bas.fix" for input as file #1, organization sequential fixed, recordsize 4, map buf
handler eof_handler
end handler
when error use eof_handler
    while 1 = 1
        get #1
        print "|" + trm$(lin) + "|", len(trm$(lin))
    next
end when
close #1

end sub
!
sub test_read_random()

option type = explicit

map (buf) string lin = 4

open "bas.fix" for input as file #1, organization sequential fixed, recordsize 4, map buf
get #1, record 3
print "|" + trm$(lin) + "|", len(trm$(lin))
get #1, record 2
print "|" + trm$(lin) + "|", len(trm$(lin))
get #1, record 1
print "|" + trm$(lin) + "|", len(trm$(lin))
close #1

end sub

import groovy.transform.Field

@Field static final int RECSIZ = 4
@Field static final String FNM = "grx.fix"

def recno(ix) {
    return (ix - 1) * Seek.RECSIZ
}

@Field static int eof = 0;
@Field static final byte[] ZERO = new byte[RECSIZ];

def testWriteOne(raf, ix, buf) {
    if(ix > eof + 1) {
        raf.seek(recno(eof + 1))
        for(i in (eof + 1)..(ix - 1)) {
            raf.write(ZERO)
        }
        eof = ix
    }
    raf.seek(recno(ix))
    raf.write(buf.getBytes())
}

def testWrite() {
    raf = new RandomAccessFile(Seek.FNM, "rw")
    testWriteOne(raf, 3, "CCCC")
    testWriteOne(raf, 2, "BBBB")
    testWriteOne(raf, 1, "AAAA")
    raf.close()
}

def testReadSequential() {
    is = new FileInputStream(Seek.FNM)
    buf = new byte[Seek.RECSIZ+1] // will read a fictive LF
    while(is.read(buf) > 0) {
        s = new String(buf, 0, Seek.RECSIZ)
        printf("|%s| %d\n", s, s.length())
    }
    is.close()
}

def testReadRandomOne(raf, ix) {
    raf.seek(recno(ix))
    buf = new byte[Seek.RECSIZ]
    raf.read(buf)
    s = new String(buf)
    printf("|%s| %d\n", s, s.length())
}

def testReadRandom() {
    raf = new RandomAccessFile(Seek.FNM, "rw")
    testReadRandomOne(raf, 3)
    testReadRandomOne(raf, 2)
    testReadRandomOne(raf, 1)
    raf.close()
}

println("Groovy seek")
testWrite()
testReadSequential()
testReadRandom()

Run:

$ define/nolog java$filename_match_list "*grx.fix=rfm=fix/mrs=4/rat=cr"
$ groovy "Seek.groovy"

RECSIZ = 4
FNM = 'jyx.fix'

def recno(ix):
   return (ix - 1) * RECSIZ

eof = 0
ZERO = '\0\0\0\0\n'

def test_write_one(f, ix, buf):
    global eof
    if ix > eof + 1:
        f.seek(recno(eof + 1))
        for i in range(ix - eof - 1):
            f.write(ZERO)
        eof = ix
    f.seek(recno(ix))
    f.write(buf)

def test_write():
    f = open(FNM, 'wb')
    test_write_one(f, 3, 'CCCC')
    test_write_one(f, 2, 'BBBB')
    test_write_one(f, 1, 'AAAA')
    f.close()

def test_read_sequential():
    f = open(FNM, 'rb')
    while True:
        buf = f.read(RECSIZ+1) # will read a fictive LF
        if len(buf) < RECSIZ:
            break
        buf = buf[:-1]
        print('|%s| %d' % (buf, len(buf)))
    f.close()

def test_read_random_one(f, ix):
    f.seek(recno(ix))
    buf = f.read(RECSIZ)
    print('|%s| %d' % (buf, len(buf)))

def test_read_random():
    f = open(FNM, 'rb')
    test_read_random_one(f, 3)
    test_read_random_one(f, 2)
    test_read_random_one(f, 1)
    f.close()

print('Jython seek')
test_write()
test_read_sequential()
test_read_random()

Run:

$ define/nolog java$filename_match_list "*jyx.fix=rfm=fix/mrs=4/rat=cr"
$ jython seek2.py

PHP also got seek - very similar to C.

Note that the file need to be created by DCL to get the right file attributes.

<?php

define('RECSIZ', '4');
define('FNM', 'phpx.fix');

function recno($ix) {
    return ($ix - 1) * RECSIZ;
}

$eof = 0;

function test_write_one($fp, $ix, $buf) {
    if($ix > $eof + 1) {
        fseek($fp, $eof + 1);
        $ZERO = "\0\0\0\0";
        for($i = $eof + 1; $i < $ix; $i++) {
            fwrite($fp, $ZERO);
        }
        $eof = $ix;
    }
    fseek($fp, recno($ix));
    fwrite($fp, $buf);
}

function test_write() {
    $fp = fopen(FNM, 'r+b');
    test_write_one($fp, 3, 'CCCC');
    test_write_one($fp, 2, 'BBBB');
    test_write_one($fp, 1, 'AAAA');
    fclose($fp);
}

function test_read_sequential() {
    $fp = fopen(FNM, 'rb');
    while(true) {
        $buf = fread($fp, 4);
        $len = strlen($buf);
        if($len <= 0) {
            break;
        }
        echo "|$buf| $len\r\n";
    }
    fclose($fp);
}

function test_read_random_one($fp, $ix) {
    fseek($fp, recno($ix));
    $buf = fread($fp, RECSIZ);
    $len = strlen($buf);
    echo "|$buf| $len\r\n";
}

function test_read_random() {
    $fp = fopen(FNM, 'rb');
    test_read_random_one($fp, 3);
    test_read_random_one($fp, 2);
    test_read_random_one($fp, 1);
    fclose($fp);
}

echo "PHP seek\r\n";
test_write();
test_read_sequential();
test_read_random();

?>

Run:

$ create/fdl="record; format fixed; size 4" phpx.fix
$ php seek.php

program rel(input,output);

type
   string = varying [255] of char;

var
   f : file of string;

procedure test_write_one(ix : integer; val : string);

begin
   locate(f, ix);
   f^ := val;
   put(f);
end;

procedure test_write;

begin
   open(f, 'pas.rel', new,
        organization := relative, record_length := 504, record_type := variable,
        access_method := direct);
   rewrite(f);
   test_write_one(3, 'CCC');
   test_write_one(2, 'BB');
   test_write_one(1, 'A');
   close(f);
end;

procedure test_read_sequential;

var
   val : string;

begin
   open(f, 'pas.rel', old,
        organization := relative, record_length := 504, record_type := variable,
        access_method := sequential);
   reset(f);
   while not(eof(f)) do begin
      val := f^;
      writeln('|' + val + '|', length(val));
      get(f);
   end;
   close(f);
end;

procedure test_read_random_one(ix : integer);

var
   val : string;

begin
   find(f, ix);
   val := f^;
   writeln('|' + val + '|', length(val));   
end;

procedure test_read_random;

begin
   open(f, 'pas.rel', old,
        organization := relative, record_length := 504, record_type := variable,
        access_method := direct);
   test_read_random_one(3);
   test_read_random_one(2);
   test_read_random_one(1);
   close(f);
end;

begin
   writeln('Pascal');
   test_write;
   test_read_sequential;
   test_read_random;
end.

identification division.
program-id.rel.
*
environment division.
input-output section.
file-control.
    select optional f assign to "cob.rel" organization is relative access mode is dynamic relative key is ix.
*
data division.
file section.
fd f.
01 buf.
   03 lin pic x(80).
working-storage section.
01 ix      pic 9(8) comp.
01 eof     pic x(1).
01 linlen  pic s9(8) comp.
01 linlen2 pic 9(8) display.
*
procedure division.
main-paragraph.
    display "Cobol"
    perform test-write-paragraph
    perform test-read-sequential-paragraph
    perform test-read-random-paragraph
    stop run.
test-write-paragraph.
    open i-o f
    move 3 to ix
    move "CCC" to lin
    perform test-write-one-paragraph
    move 2 to ix
    move "BB" to lin
    perform test-write-one-paragraph
    move 1 to ix
    move "A" to lin
    perform test-write-one-paragraph
    close f.
test-write-one-paragraph.
    write buf
        invalid key continue
        not invalid key continue
    end-write.
test-read-sequential-paragraph.
    open i-o f
    move "N" to eof
    perform until eof = 'Y'
        read f next
            at end move 'Y' to eof
            not at end perform display-line-paragraph
        end-read
    end-perform
    close f.
test-read-random-paragraph.
    open i-o f
    move 3 to ix
    perform test-read-random-one-paragraph
    move 2 to ix
    perform test-read-random-one-paragraph
    move 1 to ix
    perform test-read-random-one-paragraph
    close f.
test-read-random-one-paragraph.
    read f
        invalid key continue
        not invalid key perform display-line-paragraph
    end-read.
display-line-paragraph.
    move 80 to linlen
    call "trim" using lin, linlen giving linlen
    move linlen to linlen2
    display "|" lin(1:linlen) "| " linlen2.

identification division.
program-id.trim.

data division.
working-storage section.
01 actlen pic s9(8) comp.
linkage section.
01 s pic x(256).
01 len pic s9(8) comp.

procedure division using s,len giving actlen.
main-paragraph.
    move len to actlen.
    perform varying actlen from len by -1 until s(actlen:1) not = " " or actlen = 1
        continue
    end-perform.
    end program trim.

program rel

option type = explicit

external sub test_write()
external sub test_read_sequential()
external sub test_write_random()

print "Basic"
call test_write
call test_read_sequential
call test_read_random

end program
!
sub test_write()

option type = explicit

map(buf) string lin = 504

open "bas.rel" for output as file #1, organization relative variable, recordsize 504, map buf
lin = "CCC"
put #1, record 3
lin = "BB"
put #1, record 2
lin = "A"
put #1, record 1
close #1

end sub
!
sub test_read_sequential()

option type = explicit

map (buf) string lin = 504

open "bas.rel" for input as file #1, organization relative variable, recordsize 504, map buf
handler eof_handler
end handler
when error use eof_handler
    while 1 = 1
        get #1
        print "|" + trm$(lin) + "|", len(trm$(lin))
    next
end when
close #1

end sub
!
sub test_read_random()

option type = explicit

map (buf) string lin = 504

open "bas.rel" for input as file #1, organization relative variable, recordsize 504, map buf
get #1, record 3
print "|" + trm$(lin) + "|", len(trm$(lin))
get #1, record 2
print "|" + trm$(lin) + "|", len(trm$(lin))
get #1, record 1
print "|" + trm$(lin) + "|", len(trm$(lin))
close #1

end sub

program isq(input,output);

type
   idstr = packed array [1..4] of char;
   datarec = record
                id : [key(0)] idstr;
                val : integer;
             end;

var
   db : file of datarec;

procedure test_write_one(id : idstr; val : integer);

var
   buf : datarec;

begin
   buf.id := id;
   buf.val := val;
   db^ := buf;
   put(db);
end;

procedure test_write;

begin
   open(db, 'pas.isq', new, organization := indexed, access_method := keyed);
   test_write_one('CCCC', 3);
   test_write_one('BBBB', 2);
   test_write_one('AAAA', 1);
   close(db);
end;

procedure test_read_sequential;

var
   buf : datarec;

begin
   open(db, 'pas.isq', old, organization := indexed, access_method := sequential);
   reset(db);
   while not(eof(db)) do begin
      buf := db^;
      writeln(buf.id, ' -> ', buf.val);
      get(db);
   end;
   close(db);
end;

procedure test_read_random_one(id : idstr);

var
   buf : datarec;

begin
   findk(db, 0, id);
   buf := db^;
   writeln(buf.id, ' -> ', buf.val);
end;

procedure test_read_random;

begin
   open(db, 'pas.isq', old, organization := indexed, access_method := keyed);
   test_read_random_one('CCCC');
   test_read_random_one('BBBB');
   test_read_random_one('AAAA');
   close(db);
end;

begin
   writeln('Pascal');
   test_write;
   test_read_sequential;
   test_read_random;
end.

identification division.
program-id.isq.
*
environment division.
input-output section.
file-control.
    select optional dbf assign to "cob.isq" organization is indexed access mode is dynamic record key is id.
*
data division.
file section.
fd dbf.
01 buf.
    03 id pic x(4).
    03 val pic 9(8) comp.
working-storage section.
01 val2 pic 9(8) display.
01 eof pic x(1).
*
procedure division.
main-paragraph.
    display "Cobol"
    perform test-write-paragraph
    perform test-read-sequential-paragraph
    perform test-read-random-paragraph
    stop run.
test-write-paragraph.
    open output dbf
    move "CCCC" to id
    move 3 to val
    perform test-write-one-paragraph
    move "BBBB" to id
    move 2 to val
    perform test-write-one-paragraph
    move "AAAA" to id
    move 1 to val
    perform test-write-one-paragraph
    close dbf.
test-write-one-paragraph.
    write buf
        invalid key display "Invalid key " id
        not invalid key continue
    end-write.
test-read-sequential-paragraph.
    open input dbf
    move "N" to eof
    perform until eof = "Y"
        read dbf next
            at end move "Y" to eof
            not at end perform display-buf-paragraph
        end-read
    end-perform
    close dbf.
test-read-random-paragraph.
    open input dbf
    move "CCCC" to id
    perform test-read-random-one-paragraph
    move "BBBB" to id
    perform test-read-random-one-paragraph
    move "AAAA" to id
    perform test-read-random-one-paragraph
    close dbf.
test-read-random-one-paragraph.
    read dbf
        invalid key display "Key not found " id
        not invalid key perform display-buf-paragraph
    end-read.
display-buf-paragraph.
    move val to val2
    display id " -> " val2.

program isq

option type = explicit

external sub test_write
external sub test_read_sequential
external sub test_read_random

print "Basic"
call test_write
call test_read_sequential
call test_read_random

end program
!
sub test_write

option type = explicit

record datarec
    string id = 4
    integer ival
end record
map (bufmap) datarec buf
external sub test_write_one(string, integer)

open "bas.isq" for output as file #1, indexed fixed, recordtype none, map bufmap, primary key buf::id
call test_write_one("CCCC", 3)
call test_write_one("BBBB", 2)
call test_write_one("AAAA", 1)
close #1

end sub
!
sub test_write_one(string id, integer ival)

option type = explicit

record datarec
    string id = 4
    integer ival
end record
map (bufmap) datarec buf

buf::id = id
buf::ival = ival
put #1

end sub
!
sub test_read_sequential

option type = explicit

record datarec
    string id = 4
    integer ival
end record
map (bufmap) datarec buf

open "bas.isq" for input as file #1, indexed fixed, recordtype none, map bufmap, primary key buf::id
handler eof_handler
end handler
when error use eof_handler
    while 1 = 1
        get #1
        print buf::id, " -> ", buf::ival
    next
end when
close #1

end sub
!
sub test_read_random

option type = explicit

record datarec
    string id = 4
    integer ival
end record
map (bufmap) datarec buf
external sub test_read_random_one(string)

open "bas.isq" for input as file #1, indexed fixed, recordtype none, map bufmap, primary key buf::id
call test_read_random_one("CCCC")
call test_read_random_one("BBBB")
call test_read_random_one("AAAA")
close #1

end sub
!
sub test_read_random_one(string id)

option type = explicit

record datarec
    string id = 4
    integer ival
end record
map (bufmap) datarec buf

get #1, key #0 eq id
print buf::id, " -> ", buf::ival

end sub

$ write sys$output "DCL"
$ call test_write
$ call test_read_sequential
$ call test_read_random
$ exit
$!
$ test_write: subroutine
$ create/fdl=sys$input dcl.isq
FILE
    ORGANIZATION            indexed

RECORD
    FORMAT                  fixed
    SIZE                    8

KEY 0
    SEG0_LENGTH             4
    SEG0_POSITION           0
    TYPE                    string
$
$ open/read/write db dcl.isq
$ call test_write_one "CCCC" 3
$ call test_write_one "BBBB" 2
$ call test_write_one "AAAA" 1
$ close db
$ return
$ endsubroutine
$!
$ test_write_one: subroutine
$ id = p1
$ val[0,32] = f$integer(p2)
$ buf = id + val
$ write db buf
$ return
$ endsuboutine
$!
$ test_read_sequential: subroutine
$ open/read db dcl.isq
$ loop:
$    read/end=endloop db buf
$    id = f$extract(0, 4, buf)
$    val = f$cvsi(0, 32, f$extract(4, 4, buf))
$    write sys$output f$fao("!AS -> !SL", id, val)
$    goto loop
$ endloop:
$ close db
$ return
$ endsubroutine
$!
$ test_read_random: subroutine
$ open/read db dcl.isq
$ call test_read_random_one "CCCC"
$ call test_read_random_one "BBBB"
$ call test_read_random_one "AAAA"
$ close db
$ return
$ endsubroutine
$!
$ test_read_random_one: subroutine
$ read/index=0/key="''p1'" db buf
$ id = f$extract(0, 4, buf)
$ val = f$cvsi(0, 32, f$extract(4, 4, buf))
$ write sys$output f$fao("!AS -> !SL", id, val)
$ return
$ endsubroutine

import dk.vajhoej.isam.KeyField;
import dk.vajhoej.record.FieldType;
import dk.vajhoej.record.Struct;
import dk.vajhoej.record.StructField;

@Struct
public class DataRec {
    @KeyField(n=0)
    @StructField(n=0, type=FieldType.FIXSTR, length=4)
    private String id;
    @StructField(n=1, type=FieldType.INT4)
    private int val;
    public DataRec() {
        this("    ", 0);
    }
    public DataRec(String id, int val) {
        this.id = id;
        this.val = val;
    }
    public String getId() {
        return id;
    }
    public int getVal() {
        return val;
    }
}

from dk.vajhoej.isam import Key0
from dk.vajhoej.isam.local import LocalIsamSource

import DataRec

def test_write_one(db, id, val):
    db.create(DataRec(id, val))

def test_write():
    db = LocalIsamSource('jy.isq', 'dk.vajhoej.vms.rms.IndexSequential', False)
    test_write_one(db, 'CCCC', 3)
    test_write_one(db, 'BBBB', 2)
    test_write_one(db, 'AAAA', 1)
    db.close()

def test_read_sequential():
    db = LocalIsamSource('jy.isq', 'dk.vajhoej.vms.rms.IndexSequential', True)
    it = db.readGE(DataRec, Key0('    '))
    while it.read():
        res = it.current()
        print('%s -> %d' % (res.id, res.val))
    db.close()

def test_read_random_one(db, id):
    res = db.read(DataRec, Key0(id))
    print('%s -> %d' % (res.id, res.val))

def test_read_random():
    db = LocalIsamSource('jy.isq', 'dk.vajhoej.vms.rms.IndexSequential', True)
    test_read_random_one(db, 'CCCC')
    test_read_random_one(db, 'BBBB')
    test_read_random_one(db, 'AAAA')
    db.close()

print('Jython')
test_write()
test_read_sequential()
test_read_random()

program emp(input,output);

type
   employee = record
                 no : [key(0)] packed array [1..4] of char;
                 name : [key(1,duplicates)] packed array [1..10] of char;
                 role : [key(2,duplicates)] packed array [1..10] of char;
              end;

var
  empdb : file of employee;
  res : employee;

begin
   writeln('Pascal');
   open(empdb, 'emp.isq', old, organization := indexed, access_method := keyed);
   findk(empdb, 0, '0002');
   if not(ufb(empdb)) then begin
      res := empdb^;
      writeln('By no   : ', res.no, ' ', res.name, ' ', res.role);
   end else begin
      writeln('Key not found : no');
   end;
   findk(empdb, 1, 'Brian B   ');
   if not(ufb(empdb)) then begin
      res := empdb^;
      writeln('By name : ', res.no, ' ', res.name, ' ', res.role);
   end else begin
      writeln('Key not found : name');
   end;
   findk(empdb, 2, 'Engineer  ');
   if not(ufb(empdb)) then begin
      res := empdb^;
      writeln('By role : ', res.no, ' ', res.name, ' ', res.role);
   end else begin
      writeln('Key not found : role');
   end;
   close(empdb);
end.

identification division.
program-id.emp.
*
environment division.
input-output section.
file-control.
    select empdb assign to "emp.isq"
                 organization is indexed
                 access mode is dynamic
                 record key is emp-no
                 alternate record key is emp-name with duplicates
                 alternate record key is emp-role with duplicates.
*
data division.
file section.
fd empdb.
01 employee.
   03 emp-no   pic x(4).
   03 emp-name pic x(10).
   03 emp-role pic x(10).
working-storage section.
*
procedure division.
main-paragraph.
    display "Cobol"
    open input empdb
    move "0002" to emp-no
    read empdb
        invalid key display "Key not found : no"
        not invalid key display "By no   : " emp-no " " emp-name " " emp-role
    end-read
    move "Brian B   " to emp-name
    read empdb key is emp-name
        invalid key display "Key not found : name"
        not invalid key display "By name : " emp-no " " emp-name " " emp-role
    end-read
    move "Engineer  " to emp-role
    read empdb key is emp-role
        invalid key display "Key not found : role"
        not invalid key display "By role : " emp-no " " emp-name " " emp-role
    end-read
    close empdb
    stop run.

program emp

option type = explicit

record employee
    string no = 4
    string empname = 10
    string role = 10
end record
map (buf) employee res

print "Basic"
open "emp.isq" for input as file #1, indexed fixed, map buf, primary key res::no
handler nono_handler
    print "Key not found : no"
end handler
when error use nono_handler
    get #1, key #0 eq "0002"
    print using "By no   : 'E 'E 'E", res::no, res::empname, res::role
end when
handler noname_handler
    print "Key not found : name"
end handler
when error use noname_handler
    get #1, key #1 eq "Brian B   "
    print using "By name : 'E 'E 'E", res::no, res::empname, res::role
end when
handler norole_handler
    print "Key not found : role"
end handler
when error use norole_handler
    get #1, key #2 eq "Engineer  "
    print using "By role : 'E 'E 'E", res::no, res::empname, res::role
end when
close #1

end program

$ write sys$output "DCL"
$ open/read db emp.isq
$ dono:
$    read/index=0/key="0002"/err=nono db res
$    write sys$output f$fao("By no   : !AS !AS !AS", f$extract(0, 4, res), f$extract(4, 10, res), f$extract(14, 10, res))
$    goto doname
$ nono:
$    write sys$output "Key not found : no"
$ doname:
$    read/index=1/key="Brian B   "/err=noname db res
$    write sys$output f$fao("By name : !AS !AS !AS", f$extract(0, 4, res), f$extract(4, 10, res), f$extract(14, 10, res))
$    goto dorole
$ noname:
$    write sys$output "Key not found : name"
$ dorole:
$    read/index=2/key="Engineer  "/err=norole db res
$    write sys$output f$fao("By rold : !AS !AS !AS", f$extract(0, 4, res), f$extract(4, 10, res), f$extract(14, 10, res))
$    goto finish
$ norole:
$    write sys$output "Key not found : role"
$ finish:
$ close db
$ exit

import dk.vajhoej.isam.KeyField;
import dk.vajhoej.record.FieldType;
import dk.vajhoej.record.Struct;
import dk.vajhoej.record.StructField;

@Struct
public class Employee {
    @KeyField(n=0)
    @StructField(n=0, type=FieldType.FIXSTR, length=4)
    private String no;
    @KeyField(n=1)
    @StructField(n=1, type=FieldType.FIXSTR, length=10)
    private String name;
    @KeyField(n=2)
    @StructField(n=2, type=FieldType.FIXSTR, length=10)
    private String role;
    public Employee() {
        this("    ", "          ", "          ");
    }
    public Employee(String no, String name, String role) {
        this.no = no;
        this.name = name;
        this.role = role;
    }
    public String getNo() {
        return no;
    }
    public String getName() {
        return name;
    }
    public String getRole() {
        return role;
    }
}

from dk.vajhoej.isam import Key
from dk.vajhoej.isam import Key0
from dk.vajhoej.isam import IsamException
from dk.vajhoej.isam.local import LocalIsamSource

import Employee

print('Jython')
db = LocalIsamSource('emp.isq', 'dk.vajhoej.vms.rms.IndexSequential', True)
res = db.read(Employee, Key0('0002'))
if res != None:
    print('By no   : %s %s %s' % (res.no, res.name, res.role))
else:
    print('Key not found : no')
if res != None:
    res = db.read(Employee, Key(1, 'Brian B   '))
    print('By name : %s %s %s' % (res.no, res.name, res.role))
else:
    print('Key not found : name')
if res != None:
    res = db.read(Employee, Key(2, 'Engineer  '))
    print('By role : %s %s %s' % (res.no, res.name, res.role))
else:
    print('Key not found : role')
db.close()