Rosetta Code

Fixed length records: Difference between revisions

Page Discussion

Fixed length records (view source)

Revision as of 09:36, 6 December 2023

41,799 bytes added ,  5 months ago
m
→‎{{header|Wren}}: Minor tidy
(→‎{{header|J}}: Fix misunderstanding of specs)
m (→‎{{header|Wren}}: Minor tidy)
 
(33 intermediate revisions by 22 users not shown)
Line 1:
{{task}}Fixed length read/write
Fixed length read/write
 
Before terminals, computers commonly used [https://en.wikipedia.org/wiki/Punched_card_reader punch card readers] or paper tape input.
Line 46 ⟶ 47:
The COBOL example uses forth.txt and forth.blk filenames.
<br /><br />
 
=={{header|Ada}}==
Ada string type is a fixed-length string.
<syntaxhighlight lang="ada">
with Ada.Text_IO; use Ada.Text_IO;
 
procedure Main is
subtype Block is String (1 .. 80);
Infile_Name : String := "infile.dat";
outfile_Name : String := "outfile.dat";
Infile : File_Type;
outfile : File_Type;
 
Line : Block := (Others => ' ');
begin
Open (File => Infile, Mode => In_File, Name => Infile_Name);
Create (File => outfile, Mode => Out_File, Name => outfile_Name);
 
Put_Line("Input data:");
New_Line;
while not End_Of_File (Infile) loop
Get (File => Infile, Item => Line);
Put(Line);
New_Line;
for I in reverse Line'Range loop
Put (File => outfile, Item => Line (I));
end loop;
end loop;
Close (Infile);
Close (outfile);
 
Open(File => infile,
Mode => In_File,
Name => outfile_name);
New_Line;
Put_Line("Output data:");
New_Line;
while not End_Of_File(Infile) loop
Get(File => Infile,
Item => Line);
Put(Line);
New_Line;
end loop;
end Main;
</syntaxhighlight>
{{Output}}
<pre>
Input data:
 
Line 1...1.........2.........3.........4.........5.........6.........7.........8
Line 2
Line 3
Line 4
Line 6
Line 7
Indented line 8............................................................
Line 9 RT MARGIN
 
Output data:
 
8.........7.........6.........5.........4.........3.........2.........1...1 eniL
2 eniL
3 eniL
4 eniL
6 eniL
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL
</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f FIXED_LENGTH_RECORDS.AWK
BEGIN {
vlr_fn = "FIXED_LENGTH_RECORDS.TXT"
flr_fn = "FIXED_LENGTH_RECORDS.TMP"
print("bef:")
while (getline rec <vlr_fn > 0) { # read variable length records
printf("%-80.80s",rec) >flr_fn # write fixed length records without CR/LF
printf("%s\n",rec)
}
close(vlr_fn)
close(flr_fn)
print("aft:")
getline rec <flr_fn # read entire file
while (length(rec) > 0) {
printf("%s\n",revstr(substr(rec,1,80),80))
rec = substr(rec,81)
}
exit(0)
}
function revstr(str,start) {
if (start == 0) {
return("")
}
return( substr(str,start,1) revstr(str,start-1) )
}
</syntaxhighlight>
{{out}}
<pre>
bef:
Line 1...1.........2.........3.........4.........5.........6.........7.........8
Line 2
Line 3
Line 4
 
Line 6
Line 7
Indented line 8............................................................
Line 9 RT MARGIN
aft:
8.........7.........6.........5.........4.........3.........2.........1...1 eniL
2 eniL
3 eniL
4 eniL
 
6 eniL
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL
</pre>
 
=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <algorithm>
#include <cstdlib>
#include <fstream>
#include <iostream>
 
void reverse(std::istream& in, std::ostream& out) {
constexpr size_t record_length = 80;
char record[record_length];
while (in.read(record, record_length)) {
std::reverse(std::begin(record), std::end(record));
out.write(record, record_length);
}
out.flush();
}
 
int main(int argc, char** argv) {
std::ifstream in("infile.dat", std::ios_base::binary);
if (!in) {
std::cerr << "Cannot open input file\n";
return EXIT_FAILURE;
}
std::ofstream out("outfile.dat", std::ios_base::binary);
if (!out) {
std::cerr << "Cannot open output file\n";
return EXIT_FAILURE;
}
try {
in.exceptions(std::ios_base::badbit);
out.exceptions(std::ios_base::badbit);
reverse(in, out);
} catch (const std::exception& ex) {
std::cerr << "I/O error: " << ex.what() << '\n';
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}</syntaxhighlight>
 
{{out}}
After converting with dd:
<pre>
8.........7.........6.........5.........4.........3.........2.........1...1 eniL
2 eniL
3 eniL
4 eniL
 
6 eniL
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL
</pre>
 
=={{header|COBOL}}==
 
<langsyntaxhighlight lang="cobol"> *> Rosetta Code, fixed length records
*> Tectonics:
*> cobc -xj lrecl80.cob
Line 137 ⟶ 314:
 
goback.
end program lrecl80.</langsyntaxhighlight>
 
Given a starting file sample.txt of
Line 174 ⟶ 351:
Demonstrate text to Forth source block form.
 
<langsyntaxhighlight lang="cobol"> *> Rosetta Code fixed length records, text to Forth block
identification division.
program-id. blocking.
Line 263 ⟶ 440:
 
goback.
end program blocking.</langsyntaxhighlight>
 
Demonstrate Forth source block to text form.
 
<langsyntaxhighlight lang="cobol"> *> Rosetta Code fixed length records, Forth blocks to text.
identification division.
program-id. unblocking.
Line 338 ⟶ 515:
 
goback.
end program unblocking.</langsyntaxhighlight>
 
=={{header|JDelphi}}==
''See [[#Pascal|Pascal]]''
'''Solution:'''
 
=={{header|Free Pascal}}==
Using the 720 byte input file linked to in the Perl6 entry.
''See [[#Pascal|Pascal]]''
<lang j> _80 ]\ fread 'flr-infile.dat' NB. reads the file into a n by 80 array
_80 |.\ fread 'flr-infile.dat' NB. as above but reverses each 80 byte chunk
'flr-outfile.dat' fwrite~ , _80 |.\ fread 'flr-infile.dat' NB. as above but writes result to file (720 bytes)</lang>
 
=={{header|jq}}==
 
=={{header|FreeBASIC}}==
To read the raw input and write out raw strings, the command-line options -R (raw input), -s ("slurp"), and -r (raw output) options are necessary:
<syntaxhighlight lang="freebasic">
Const As Byte longRegistro = 80
Const archivoEntrada As String = "infile.dat"
Const archivoSalida As String = "outfile.dat"
 
Dim As String linea
jq -Rrs -f program.jq infile.dat
 
'Abre el archivo origen para lectura
program.jq:
Open archivoEntrada For Input As #1
'Abre el archivo destino para escritura
Open archivoSalida For Output As #2
 
Print !"Datos de entrada:\n"
For the sake of generality, we define `cut` with an argument corresponding to the number of columns. To illustrate that an efficient recursive definition is possible, we define an inner helper function, `c`, with arity 0, as currently jq's tail-call optimization is restricted to zero-arity filters:
Do While Not Eof(1)
Line Input #1, linea 'lee una linea
Print linea 'imprime por pantalla esa linea
For i As Integer = longRegistro To 1 Step -1
Print #2, Chr(Asc(linea, i)); 'escribe el inverso de la linea
Next i
Print #2, Chr(13);
Loop
Close #1, #2
 
Dim As Integer a
<lang jq>def cut($n):
Open archivoSalida For Input As #2
def c: if length==0 then empty else .[:$n] , (.[$n:] | c) end;
c;
 
Print !"\nDatos de salida:\n"
cut(80) | explode | reverse | implode;</lang>
Do While Not Eof(2)
Line Input #2, linea
For j As Integer = 0 To Len(linea)-1
Print Chr(linea[j]);
a += 1: If a = longRegistro Then a = 0 : Print Chr(13)
Next j
Loop
Close
Sleep
</syntaxhighlight>
 
=={{header|Julia}}==
The program reads from an "infile.dat" file created with dd, as described in the task instructions.
<lang julia>
function processfixedlengthrecords(infname, blocksize, outfname)
inf = open(infname)
outf = open(outfname, "w")
filedata = [ read(inf, blocksize) for _ in 1:10 ]
for line in filedata
s = join([Char(c) for c in line], "")
@assert(length(s) == blocksize)
write(outf, s)
end
end
processfixedlengthrecords("infile.dat", 80, "outfile.dat")
</lang>
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 436 ⟶ 618:
check(err)
fmt.Println(string(bytes))
}</langsyntaxhighlight>
 
{{out}}
Line 453 ⟶ 635:
'''Bonus round'''
 
<langsyntaxhighlight lang="go">package main
 
import (
Line 527 ⟶ 709:
block2text("block.dat", "block.txt")
text2block("block.txt", "block2.dat")
}</langsyntaxhighlight>
 
=={{header|J}}==
'''Solution:'''
 
Using the 720 byte input file linked to in the Raku entry.
<syntaxhighlight lang="j"> _80 ]\ fread 'flr-infile.dat' NB. reads the file into a n by 80 array
_80 |.\ fread 'flr-infile.dat' NB. as above but reverses each 80 byte chunk
'flr-outfile.dat' fwrite~ , _80 |.\ fread 'flr-infile.dat' NB. as above but writes result to file (720 bytes)
processFixLenFile=: fwrite~ [: , _80 |.\ fread NB. represent operation as a verb/function</syntaxhighlight>
 
'''Example Usage:'''
 
<syntaxhighlight lang="j"> 'flr-outfile.dat' processFixLenFile 'flr-infile.dat' NB. returns number of bytes written
720</syntaxhighlight>
 
=={{header|jq}}==
 
To read the raw input and write out raw strings, the command-line options -R (raw input), -r (raw output) and -j options are necessary:
 
jq -Rrj -f program.jq infile.dat
 
program.jq:
 
Currently gojq does not include the `_nwise/1` filter provided by jq, and in any case jq's implementation is suboptimal,
so we define `nwise` here so that it can be used for both array and string inputs. Notice that the inner helper function, `n`, has arity 0, allowing jq's tail-call optimization to work.
<syntaxhighlight lang="jq">def cut($n):
def nwise($n):
def n: if length <= $n then . else .[0:$n] , (.[$n:] | n) end;
n;
nwise(80) | explode | reverse | implode
</syntaxhighlight>
To show that this does indeed work, the output of `/bin/dd cbs=80 conv=unblock` is shown:
{{output}}
<pre>
8.........7.........6.........5.........4.........3.........2.........1...1 eniL
2 eniL
3 eniL
4 eniL
 
6 eniL
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL
1+1 records in
1+1 records out
644 bytes transferred in 0.030319 secs (21241 bytes/sec)
</pre>
 
=={{header|Julia}}==
The program reads from an "infile.dat" file created with dd, as described in the task instructions.
<syntaxhighlight lang="julia">
function processfixedlengthrecords(infname, blocksize, outfname)
inf = open(infname)
outf = open(outfname, "w")
filedata = [ read(inf, blocksize) for _ in 1:10 ]
for line in filedata
s = join([Char(c) for c in line], "")
@assert(length(s) == blocksize)
write(outf, s)
end
end
processfixedlengthrecords("infile.dat", 80, "outfile.dat")
</syntaxhighlight>
 
 
=={{header|Lua}}==
<syntaxhighlight lang="lua">-- prep: convert given sample text to fixed length "infile.dat"
local sample = [[
Line 1...1.........2.........3.........4.........5.........6.........7.........8
Line 2
Line 3
Line 4
Line 6
Line 7
Indented line 8............................................................
Line 9 RT MARGIN]]
local txtfile = io.open("sample.txt", "w")
txtfile:write(sample)
txtfile:close()
os.execute("dd if=sample.txt of=infile.dat cbs=80 conv=block > /dev/null 2>&1")
 
-- task: convert fixed length "infile.dat" to fixed length "outfile.dat" (reversed lines)
local infile = io.open("infile.dat", "rb")
local outfile = io.open("outfile.dat", "wb")
while true do
local line = infile:read(80)
if not line then break end
outfile:write(string.reverse(line))
end
infile:close()
outfile:close()
 
-- output:
os.execute("dd if=outfile.dat cbs=80 conv=unblock")</syntaxhighlight>
{{out}}
<pre>8.........7.........6.........5.........4.........3.........2.........1...1 eniL
2 eniL
3 eniL
4 eniL
 
6 eniL
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL
1+1 records in
1+1 records out</pre>
 
=={{header|M2000 Interpreter}}==
===Fixed length Record===
Form Buffer object (hold a memory block) we can read a byte at offset. So Print Eval(Line80,3) return the 4th byte, and Return Line80, 2:=255,5:=0 set two bytes (unsigned, we place any number and interpreter convert it to byte).
 
<syntaxhighlight lang="m2000 interpreter">
<lang M2000 Interpreter>
Module FixedFile {
Read fixed$
Line 623 ⟶ 915:
FixedFile "fixed.random"
 
</syntaxhighlight>
</lang>
===Forth Blocks===
<syntaxhighlight lang="m2000 interpreter">
<lang M2000 Interpreter>
Form 80,50
Print "Forth's Blocks"
Line 747 ⟶ 1,039:
Page1=NewBlock()
Return
</syntaxhighlight>
</lang>
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
 
<syntaxhighlight lang="mathematica">
FixedRecordReverse[inFile_File, outFile_File, length_ : 80] :=
Module[{inStream, outStream, line, byte},
WithCleanup[
inStream = OpenRead[inFile, BinaryFormat -> True];
outStream = OpenWrite[outFile, BinaryFormat -> True];
,
While[True,
line = {};
Do[
byte = BinaryRead[inStream, "Byte"];
AppendTo[line, byte]
,
length
];
If[byte === EndOfFile, Break[]];
line = Reverse[line];
BinaryWrite[outStream, line]
]
,
Close[outStream];
Close[inStream];
];
(* Verify the result *)
RunProcess[{"dd", "if=" <> outFile[[1]], "cbs=" <> ToString[length], "conv=unblock"}, "StandardOutput"]
];
</syntaxhighlight>
 
This function will both return the reversed string in the notebook AND write the record to outfile.dat:
{{in}}
<pre>
In[]:= FixedRecordReverse[File["infile.dat"], File["outfile.dat"]]
</pre>
{{out}}
<pre>
 
Out[]= "\
8.........7.........6.........5.........4.........3.........2.........1...1 eniL
2 eniL
3 eniL
4 eniL
 
6 eniL
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL
"
</pre>
 
=={{header|Neko}}==
<syntaxhighlight lang="actionscript">/**
<lang ActionScript>/**
fixed length records, in Neko
*/
Line 788 ⟶ 1,131:
}
file_close(input)
file_close(output)</langsyntaxhighlight>
 
{{out}}
Line 807 ⟶ 1,150:
</pre>
 
=={{header|PerlNim}}==
===Task: fixed length records===
<lang perl>open $in, '<', 'flr-infile.dat';
 
open $out, '>', 'flr-outfile.dat';
<syntaxhighlight lang="nim">import algorithm
 
proc reverse(infile, outfile: string) =
 
let input = infile.open(fmRead)
defer: input.close()
let output = outfile.open(fmWrite)
defer: output.close()
 
var buffer: array[80, byte]
while not input.endOfFile:
let countRead = input.readBytes(buffer, 0, 80)
if countRead < 80:
raise newException(IOError, "truncated data when reading")
buffer.reverse()
let countWrite = output.writeBytes(buffer, 0, 80)
if countWrite < 80:
raise newException(IOError, "truncated data when writing")
 
reverse("infile.dat", "outfile.dat")</syntaxhighlight>
 
while ($n=sysread($in, $record, 80)) { # read in fixed sized binary chunks
syswrite $out, reverse $record; # write reversed records to file
print reverse($record)."\n" # display reversed records, line-by-line
}
close $out;</lang>
{{out}}
Contents of file “result.txt" created by command <code>dd if=outfile.dat of=result.txt cbs=80 conv=unblock</code>:
<pre>8.........7.........6.........5.........4.........3.........2.........1...1 eniL
2 eniL
3 eniL
4 eniL
 
6 eniL
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL</pre>
[https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/flr-infile.dat input file]
and
[https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/flr-outfile.dat output file]
=={{header|Perl 6}}==
Link to a copy of the input file used: [https://github.com/thundergnat/rc/blob/master/resouces/flr-infile.dat flr-infile.dat]
 
===Bonus: Forth blocks===
Essentially the same as task [[Selective_File_Copy]] except more boring.
<syntaxhighlight lang="nim">import strutils
 
const EmptyRecord = repeat(' ', 64)
<lang perl6>$*OUT = './flr-outfile.dat'.IO.open(:w, :bin) orelse .die; # open a file in binary mode for writing
 
while my $record = $*IN.read(80) { # read in fixed sized binary chunks
#---------------------------------------------------------------------------------------------------
$*OUT.write: $record.=reverse; # write reversed records out to $outfile
 
$*ERR.say: $record.decode('ASCII'); # display decoded records on STDERR
proc textToBlock(infile, outfile: string) =
## Read lines of a text file and write them as 64 bytes records.
 
let input = infile.open(fmRead)
defer: input.close()
let output = outfile.open(fmWrite)
defer: output.close()
 
var count = 0
while not input.endOfFile:
var record = input.readLine()
if record.len > 64:
record.setLen(64) # Truncate to 64 bytes.
elif record.len < 64:
record &= repeat(' ', 64 - record.len) # Pad to 64 bytes.
if output.writeChars(record, 0, 64) != 64:
raise newException(IOError, "error while writing block file")
inc count
 
# Complete block with empty records.
let rem = count mod 16
if rem != 0:
for _ in 1..(16 - rem):
if output.writeChars(EmptyRecord, 0, 64) != 64:
raise newException(IOError, "error while writing block file")
 
#---------------------------------------------------------------------------------------------------
 
proc blockToText(infile, outfile: string) =
## Read 64 bytes records and write them as lines trimming spaces.
 
let input = infile.open(fmRead)
defer: input.close()
let output = outfile.open(fmWrite)
defer: output.close()
 
var line: string
while not input.endOfFile:
line.setLen(64) # Allocate space for the 64 bytes to read.
if input.readChars(line, 0, 64) != 64:
raise newException(IOError, "error while reading block file")
line = line.strip(leading = false, trailing = true) & '\n'
output.write(line)
 
#———————————————————————————————————————————————————————————————————————————————————————————————————
 
when isMainModule:
textToBlock("block1.txt", "block.dat")
blockToText("block.dat", "block2.txt")</syntaxhighlight>
 
=={{header|Pascal}}==
<syntaxhighlight lang="pascal">program reverseFixedLines(input, output, stdErr);
const
lineLength = 80;
var
// in Pascal, `string[n]` is virtually an alias for `array[1..n] of char`
line: string[lineLength];
i: integer;
begin
while not eof() do
begin
for i := 1 to lineLength do
begin
read(line[i]);
end;
for i := lineLength downto 1 do
begin
write(line[i]);
end;
writeLn();
end;
end.</syntaxhighlight>
 
=={{header|Perl}}==
<syntaxhighlight lang="perl">open $in, '<', 'flr-infile.dat';
open $out, '>', 'flr-outfile.dat';
 
while ($n=sysread($in, $record, 80)) { # read in fixed sized binary chunks
syswrite $out, reverse $record; # write reversed records to file
print reverse($record)."\n" # display reversed records, line-by-line
}
close $*OUTout;</langsyntaxhighlight>
{{out}}
<pre>8.........7.........6.........5.........4.........3.........2.........1...1 eniL
Line 850 ⟶ 1,286:
............................................................8 enil detnednI
NIGRAM TR 9 eniL</pre>
[https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/flr-infile.dat input file]
and
[https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/flr-outfile.dat output file]
===There Is More Than One Way To Do It===
Read with standard <> using $/ set to a ref-to-int to read a fixed block size.
<syntaxhighlight lang="perl">{
local ($/, @ARGV) = (\80, 'infile.dat');
open my $out, '>', 'outfile.dat' or die $!;
print $out scalar reverse while <>; # can read fixed length too :)
close $out;
}</syntaxhighlight>
Slurp and reverse each line in place.
<syntaxhighlight lang="perl">use Path::Tiny;
path('outfile.dat')->spew(path('infile.dat')->slurp =~ s/.{80}/reverse $&/gesr);</syntaxhighlight>
Double reverse.
<syntaxhighlight lang="perl">use Path::Tiny;
path('outfile.dat')->spew(reverse unpack '(a80)*', reverse path('infile.dat')->slurp);
</syntaxhighlight>
Bonus round: convert the sample file to Forth Block format.
<syntaxhighlight lang="perl">use Path::Tiny;
path('outfile.dat')->spew(pack '(A64)16', split /\n/, path('sample.txt')->slurp);</syntaxhighlight>
Bonus Round: convert Forth Block format to plain text format.
<syntaxhighlight lang="perl">use Path::Tiny;
path('sample2.txt')->spew(map "$_\n", unpack '(A64)16', path('outfile.dat')->slurp);</syntaxhighlight>
 
=={{header|Phix}}==
Line 855 ⟶ 1,315:
never really designed for fixed length record handling and for me, for this task, their limits
outweight any advantages. To simplify matters, this creates any files needed on the fly.
<!--<syntaxhighlight lang="phix">(notonline)-->
<lang Phix>constant sample_text = """
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- file i/o</span>
Line 1...1.........2.........3.........4.........5.........6.........7.........8
<span style="color: #008080;">constant</span> <span style="color: #000000;">sample_text</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""
Line 2
Line 1...1.........2.........3.........4.........5.........6.........7.........8
Line 3
Line 42
Line 3
 
Line 64
Line 7
Line 6
Indented line 8............................................................
Line 7
Line 9 RT MARGIN"""
Indented line 8............................................................
 
Line 9 RT MARGIN"""</span>
constant indat = "infile.dat",
outdat = "outfile.dat"
<span style="color: #008080;">constant</span> <span style="color: #000000;">indat</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"infile.dat"</span><span style="color: #0000FF;">,</span>
 
<span style="color: #000000;">outdat</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"outfile.dat"</span>
if not file_exists(indat) then
object text = get_text("sample.txt")
<span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">file_exists</span><span style="color: #0000FF;">(</span><span style="color: #000000;">indat</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
if text=-1 then text = sample_text end if
<span style="color: #004080;">object</span> <span style="color: #000000;">text</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_text</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"sample.txt"</span><span style="color: #0000FF;">)</span>
sequence s = split(text,'\n')
<span style="color: #008080;">if</span> <span style="color: #000000;">text</span><span style="color: #0000FF;">=-</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span> <span style="color: #000000;">text</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">sample_text</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
integer fn = open(indat,"wb")
<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #000000;">text</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'\n'</span><span style="color: #0000FF;">)</span>
for i=1 to length(s) do
<span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #000000;">indat</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"wb"</span><span style="color: #0000FF;">)</span>
puts(fn,s[i]&repeat(' ',80-length(s[i])))
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
end for
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]&</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">' '</span><span style="color: #0000FF;">,</span><span style="color: #000000;">80</span><span style="color: #0000FF;">-</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])))</span>
close(fn)
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
printf(1,"%s created (%d bytes)\n",{indat,get_file_size(indat)})
<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
end if
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s created (%d bytes)\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">indat</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">get_file_size</span><span style="color: #0000FF;">(</span><span style="color: #000000;">indat</span><span style="color: #0000FF;">)})</span>
 
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
function get_block(integer fn, size)
string res = ""
<span style="color: #008080;">function</span> <span style="color: #000000;">get_block</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">size</span><span style="color: #0000FF;">)</span>
for i=1 to size do
<span style="color: #004080;">string</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span>
res &= getc(fn)
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">size</span> <span style="color: #008080;">do</span>
end for
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #7060A8;">getc</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
return res
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
end function
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
 
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
integer fn = open(indat,"rb"),
isize = get_file_size(indat)
<span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #000000;">indat</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"rb"</span><span style="color: #0000FF;">),</span>
puts(1,"reversed:\n")
<span style="color: #000000;">isize</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_file_size</span><span style="color: #0000FF;">(</span><span style="color: #000000;">indat</span><span style="color: #0000FF;">)</span>
for i=1 to isize by 80 do
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"reversed:\n"</span><span style="color: #0000FF;">)</span>
?reverse(get_block(fn,80))
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">isize</span> <span style="color: #008080;">by</span> <span style="color: #000000;">80</span> <span style="color: #008080;">do</span>
end for
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">reverse</span><span style="color: #0000FF;">(</span><span style="color: #000000;">get_block</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">80</span><span style="color: #0000FF;">))</span>
close(fn)
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
 
<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
-- Bonus part, 16*64 (=1024) block handling:
 
<span style="color: #000080;font-style:italic;">-- Bonus part, 16*64 (=1024) block handling:</span>
procedure put_block(integer fn, sequence lines)
lines &= repeat("",16-length(lines))
<span style="color: #008080;">procedure</span> <span style="color: #000000;">put_block</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">lines</span><span style="color: #0000FF;">)</span>
for i=1 to length(lines) do
<span style="color: #000000;">lines</span> <span style="color: #0000FF;">&=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">16</span><span style="color: #0000FF;">-</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lines</span><span style="color: #0000FF;">))</span>
string li = lines[i]
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lines</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
if length(li)>64 then
<span style="color: #004080;">string</span> <span style="color: #000000;">li</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">lines</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
li = li[1..64]
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">li</span><span style="color: #0000FF;">)></span><span style="color: #000000;">64</span> <span style="color: #008080;">then</span>
else
<span style="color: #000000;">li</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">li</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">64</span><span style="color: #0000FF;">]</span>
li &= repeat(' ',64-length(li))
<span style="color: #008080;">else</span>
end if
<span style="color: #000000;">li</span> <span style="color: #0000FF;">&=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">' '</span><span style="color: #0000FF;">,</span><span style="color: #000000;">64</span><span style="color: #0000FF;">-</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">li</span><span style="color: #0000FF;">))</span>
puts(fn,li)
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
end for
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">li</span><span style="color: #0000FF;">)</span>
end procedure
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
 
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
fn = open(outdat,"wb")
put_block(fn,split(sample_text,'\n'))
<span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #000000;">outdat</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"wb"</span><span style="color: #0000FF;">)</span>
close(fn)
<span style="color: #000000;">put_block</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sample_text</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'\n'</span><span style="color: #0000FF;">))</span>
integer osize = get_file_size(outdat)
<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
printf(1,"\n%s created (%d bytes):\n",{outdat,osize})
<span style="color: #004080;">integer</span> <span style="color: #000000;">osize</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_file_size</span><span style="color: #0000FF;">(</span><span style="color: #000000;">outdat</span><span style="color: #0000FF;">)</span>
fn = open(outdat,"rb")
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n%s created (%d bytes):\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">outdat</span><span style="color: #0000FF;">,</span><span style="color: #000000;">osize</span><span style="color: #0000FF;">})</span>
sequence lines = {}
<span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #000000;">outdat</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"rb"</span><span style="color: #0000FF;">)</span>
for i=1 to osize by 64 do
<span style="color: #004080;">sequence</span> <span style="color: #000000;">lines</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
string line = get_block(fn,64)
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">osize</span> <span style="color: #008080;">by</span> <span style="color: #000000;">64</span> <span style="color: #008080;">do</span>
?line
<span style="color: #004080;">string</span> <span style="color: #000000;">line</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">get_block</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">64</span><span style="color: #0000FF;">)</span>
lines = append(lines,trim_tail(line,' '))
<span style="color: #0000FF;">?</span><span style="color: #000000;">line</span>
end for
<span style="color: #000000;">lines</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lines</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">trim_tail</span><span style="color: #0000FF;">(</span><span style="color: #000000;">line</span><span style="color: #0000FF;">,</span><span style="color: #008000;">' '</span><span style="color: #0000FF;">))</span>
lines = trim_tail(lines,{""})
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
puts(1,"\ntrimmed:\n")
<span style="color: #000000;">lines</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">trim_tail</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lines</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">""</span><span style="color: #0000FF;">})</span>
pp(lines,{pp_Nest,1})
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\ntrimmed:\n"</span><span style="color: #0000FF;">)</span>
{} = delete_file(indat) -- (for consistent 2nd run)</lang>
<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lines</span><span style="color: #0000FF;">,{</span><span style="color: #004600;">pp_Nest</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">})</span>
<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">delete_file</span><span style="color: #0000FF;">(</span><span style="color: #000000;">indat</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (for consistent 2nd run)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 971 ⟶ 1,434:
"Line 9"}
</pre>
 
=={{header|Python}}==
<syntaxhighlight lang="python">
infile = open('infile.dat', 'rb')
outfile = open('outfile.dat', 'wb')
 
while True:
onerecord = infile.read(80)
if len(onerecord) < 80:
break
onerecordreversed = bytes(reversed(onerecord))
outfile.write(onerecordreversed)
 
infile.close()
outfile.close()
</syntaxhighlight>
 
Output:
<pre>
dd if=outfile.dat cbs=80 conv=unblock
8.........7.........6.........5.........4.........3.........2.........1...1 eniL
2 eniL
3 eniL
4 eniL
6 eniL
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL
1+1 records in
1+1 records out
</pre>
 
=={{header|Raku}}==
(formerly Perl 6)
Link to a copy of the input file used: [https://github.com/thundergnat/rc/blob/master/resouces/flr-infile.dat flr-infile.dat]
 
Essentially the same as task [[Selective_File_Copy]] except more boring.
 
<syntaxhighlight lang="raku" line>$*OUT = './flr-outfile.dat'.IO.open(:w, :bin) orelse .die; # open a file in binary mode for writing
while my $record = $*IN.read(80) { # read in fixed sized binary chunks
$*OUT.write: $record.=reverse; # write reversed records out to $outfile
$*ERR.say: $record.decode('ASCII'); # display decoded records on STDERR
}
close $*OUT;</syntaxhighlight>
{{out}}
<pre>8.........7.........6.........5.........4.........3.........2.........1...1 eniL
2 eniL
3 eniL
4 eniL
6 eniL
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL</pre>
 
=={{header|REBOL}}==
<syntaxhighlight lang="rebol">
inp: open %infile.dat
out: open/new %outfile.dat
 
while [ not empty? line: copy/part inp 80 ][ write out reverse line ]
 
close inp
close out
</syntaxhighlight>
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX pgm reads fixed-lengthfixed─length 80 byte records; reverses each record, displays to term. */
iFID= 'FIXEDLEN.TXT' /*the file's filename (used for input).*/
call charin iFID, 1, 0 /*open the file, point rec pointer to 1*/
/* [+] just to be safe, position file.*/
do j=1 while chars(iFID) >= 80 /*read data records of LRECL ≡ eighty. */
@.j= charin(iFID, , 80) /*read a data record of eighty bytes. */
end /*j*/
#= j - 1 /*adjust # of records (J is 1 too high)*/
do k=1 for # /* [+↓] process all the records read. */
say reverse(@.k) /* reverse a record and write to term. */
end /*k*/ /*stick a fork in it, we're all done. */</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default input file:}}
{{out}}
Line 995 ⟶ 1,524:
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">open("outfile.dat", "w") do |out_f|
open("infile.dat") do |in_f|
while record = in_f.read(80)
out_f << record.reverse
end
end
end # both files automatically closed
</syntaxhighlight>
=={{header|Rust}}==
<syntaxhighlight lang="rust">use std::fs::File;
use std::io::prelude::*;
use std::io::{BufReader, BufWriter};
 
fn reverse_file(
input_filename: &str,
output_filename: &str,
record_len: usize,
) -> std::io::Result<()> {
let mut input = BufReader::new(File::open(input_filename)?);
let mut output = BufWriter::new(File::create(output_filename)?);
let mut buffer = vec![0; record_len];
while input.read(&mut buffer)? == record_len {
buffer.reverse();
output.write_all(&buffer)?;
}
output.flush()?;
Ok(())
}
 
fn main() {
match reverse_file("infile.dat", "outfile.dat", 80) {
Ok(()) => {}
Err(error) => eprintln!("I/O error: {}", error),
}
}</syntaxhighlight>
 
{{out}}
After converting with dd:
<pre>
8.........7.........6.........5.........4.........3.........2.........1...1 eniL
2 eniL
3 eniL
4 eniL
 
6 eniL
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL
</pre>
 
=={{header|Tcl}}==
<syntaxhighlight lang="tcl">chan configure stdin -translation binary
chan configure stdout -translation binary
 
set lines [regexp -inline -all {.{80}} [read stdin]]
puts -nonewline [join [lmap line $lines {string reverse $line}] ""]
 
# More "traditional" way
 
# while {[set line [read stdin 80]] ne ""} {
# puts -nonewline [string reverse $line]
# }</syntaxhighlight>
 
{{out}}
<pre>$ exec 2>/dev/null
$ dd if=sample.txt cbs=80 conv=block | tclsh flr.tcl | dd cbs=80 conv=unblock
8.........7.........6.........5.........4.........3.........2.........1...1 eniL
2 eniL
3 eniL
4 eniL
 
6 eniL
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL</pre>
 
=={{header|TXR}}==
 
===80 Column Task===
 
At the shell prompt:
 
<pre>
$ txr -e '(let ((buf (make-buf 80))
(nread 80))
(while (eql nread 80)
(set nread (fill-buf-adjust buf))
(buf-set-length buf 80)
(put-buf (nreverse buf))))' < infile80.bin > outfile80.bin
$ dd if=outfile80.bin cbs=80 conv=unblock
8.........7.........6.........5.........4.........3.........2.........1...1 eniL
2 eniL
3 eniL
4 eniL
 
6 eniL
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL
 
1+1 records in
1+1 records out
725 bytes copied, 8.658e-05 s, 8.4 MB/s
</pre>
 
This handles a final bit that is shorter than 80. When <code>buf-set-length</code> sets the buffer size back to 80, zero padding is applied. The zero-padded record is reversed.
 
===Forth Blocks Task===
 
====Encoding====
 
The following program is called <code>forth-enblock.tl</code>:
 
<syntaxhighlight lang="txrlisp">(typedef forth-line (array 64 bchar))
 
(let ((lno 0)
(blanks (make-buf 64 #\space)))
(whilet ((line (get-line)))
(put-obj (fmt "~-64,64a" line) (ffi forth-line))
(inc lno))
(while (plusp (mod (pinc lno) 16))
(put-buf blanks)))</syntaxhighlight>
 
{{out}}
 
<pre>$ txr forth-enblock.tl < forth-enblock.tl > forth-enblock.blk
$ xxd forth-enblock.blk
00000000: 2874 7970 6564 6566 2066 6f72 7468 2d6c (typedef forth-l
00000010: 696e 6520 2861 7272 6179 2036 3420 6263 ine (array 64 bc
00000020: 6861 7229 2920 2020 2020 2020 2020 2020 har))
00000030: 2020 2020 2020 2020 2020 2020 2020 2020
00000040: 2020 2020 2020 2020 2020 2020 2020 2020
00000050: 2020 2020 2020 2020 2020 2020 2020 2020
00000060: 2020 2020 2020 2020 2020 2020 2020 2020
00000070: 2020 2020 2020 2020 2020 2020 2020 2020
00000080: 286c 6574 2028 286c 6e6f 2030 2920 2020 (let ((lno 0)
[... snip ...]
000003e0: 2020 2020 2020 2020 2020 2020 2020 2020
000003f0: 2020 2020 2020 2020 2020 2020 2020 2020</pre>
 
====Decoding====
 
This is <code>forth-deblock.tl</code>
 
<syntaxhighlight lang="txrlisp">(typedef forth-block (array 16 (array 64 bchar)))
 
(defsymacro fbsz (sizeof forth-block))
 
(let* ((buf (make-buf fbsz))
(block-view (carray-buf buf (ffi forth-block)))
(nread fbsz))
(while (eql fbsz nread)
(set nread (fill-buf-adjust buf))
(when (plusp nread)
(buf-set-length buf fbsz #\space)
(each ((row [block-view 0]))
(put-line (trim-right #/ +/ row))))))</syntaxhighlight>
 
{{out}}
 
<pre>$ txr forth-deblock.tl < forth-enblock.blk
(typedef forth-line (array 64 bchar))
 
(let ((lno 0)
(blanks (make-buf 64 #\space)))
(whilet ((line (get-line)))
(put-obj (fmt "~-64,64a" line) (ffi forth-line))
(inc lno))
(while (plusp (mod (pinc lno) 16))
(put-buf blanks)))
 
 
 
 
 
 
 
</pre>
 
=={{header|Wren}}==
{{libheader|Wren-str}}
<syntaxhighlight lang="wren">import "io" for File
import "./str" for Str
 
var records = File.read("infile.dat")
File.create("outfile.dat") { |f|
for (record in Str.chunks(records, 80)) {
record = record[-1..0]
f.writeBytes(record)
}
}
records = File.read("outfile.dat")
for (record in Str.chunks(records, 80)) System.print(record)</syntaxhighlight>
 
{{out}}
<pre>
8.........7.........6.........5.........4.........3.........2.........1...1 eniL
2 eniL
3 eniL
4 eniL
6 eniL
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL
</pre>
 
===Bonus round===
{{libheader|Wren-ioutil}}
<syntaxhighlight lang="wren">import "./ioutil" for File, FileUtil
import "./str" for Str
 
var blockToText = Fn.new { |blockFileName, textFileName|
var block = File.read(blockFileName)
var lb = FileUtil.lineBreak
File.create(textFileName) { |f|
for (chunk in Str.chunks(block, 64)) {
f.writeBytes(chunk.trimEnd() + lb)
}
}
}
 
var textToBlock = Fn.new { |textFileName, blockFileName|
var lines = FileUtil.readLines(textFileName).where { |l| l != "" }.toList
var text = lines.map { |l| (l.count < 64) ? l + (" " * (64-l.count)) : l[0..63] }.join()
var rem = text.count % 1024
if (rem > 0) text = text + (" " * (1024 - rem))
File.create(blockFileName) { |f| f.writeBytes(text) }
}
 
// create a block file
File.create("data.blk") { |f|
f.writeBytes("a" * 1024)
f.writeBytes("b" * 1024)
f.writeBytes("c" * 1024)
f.writeBytes("d" * 1024)
}
 
blockToText.call("data.blk", "data.txt")
textToBlock.call("data.txt", "data2.blk")
System.print(FileUtil.areDuplicates("data.blk", "data2.blk"))</syntaxhighlight>
 
{{out}}
<pre>
true
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang "XPL0">include xpllib;
int N, I;
char A(80);
[OpenInFile("infile.dat");
OpenOutFile("outfile.dat");
for N:= 1 to 9 do
[for I:= 0 to 80-1 do A(I):= ChIn(3);
for I:= 80-1 downto 0 do ChOut(3, A(I));
];
OpenInFile("outfile.dat");
for N:= 1 to 9 do
[for I:= 0 to 80-1 do ChOut(0, ChIn(3)); CrLf(0)];
]</syntaxhighlight>
{{out}}
<pre>
8.........7.........6.........5.........4.........3.........2.........1...1 eniL
2 eniL
3 eniL
4 eniL
6 eniL
7 eniL
............................................................8 enil detnednI
NIGRAM TR 9 eniL
</pre>
Line 1,003 ⟶ 1,807:
Line 1...1.........2.........3.........4.........5.........6.........7.........8Line 2 Line 3 Line 4 Line 6 Line 7 Indented line 8............................................................Line 9 RT MARGIN
</pre>
<langsyntaxhighlight lang="zkl">File("infile.dat","rb") // could contain nulls and newlines
// Since we are writing to a ASCII terminal, ignore nulls
.walker(3).chunk(80,String).pump(Console.println,"reverse"); // 3-->read chars</langsyntaxhighlight>
{{out}}
<pre>
Line 1,019 ⟶ 1,823:
</pre>
To write to a file (as one big line), preserving nulls:
<langsyntaxhighlight lang="zkl">in,out := File("infile.dat","rb"), File("outfile.dat","wb");
in.walker(0).chunk(80).pump(out,"reverse"); // may contain nulls and newlines
// 0-->read bytes, chunk to list of bytes, reverse and write the bytes
in.close(); out.close();</langsyntaxhighlight>
outfile.dat:
{{out}}
Line 1,029 ⟶ 1,833:
</pre>
<b>Bonus Round</b>
<langsyntaxhighlight lang="zkl">// read block file (as in read a file of blocks) to text
fcn readFourthBlock(inFileNm){
out,f,buf := Sink(String), File(inFileNm,"rb"), Data(1024);
Line 1,037 ⟶ 1,841:
}
f.close(); out.close();
}</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">// read text file and write as block to file
fcn formatToFourthBlock(inFileNm,outFileNm){
n,blk,in,out := 0, Data(), File(inFileNm,"r"), File(outFileNm,"wb");
Line 1,048 ⟶ 1,852:
if(blk) out.write(blk, " "*(1024 - blk.len()));
f.close(); out.close();
}</langsyntaxhighlight>
PureFox
9,482

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/285872...353641"