Fixed length records: Difference between revisions

The COBOL example uses forth.txt and forth.blk filenames.

<br /><br />

 

=={{header|AWK}}==

# syntax: GAWK -f FIXED_LENGTH_RECORDS.AWK

BEGIN {

return( substr(str,start,1) revstr(str,start-1) )

}

{{out}}

<pre>

 

=={{header|C++}}==

#include <cstdlib>

#include <fstream>

}

return EXIT_SUCCESS;

 

{{out}}

=={{header|COBOL}}==

 

*> Tectonics:

*> cobc -xj lrecl80.cob

 

goback.

 

Given a starting file sample.txt of

Demonstrate text to Forth source block form.

 

identification division.

program-id. blocking.

 

goback.

 

Demonstrate Forth source block to text form.

 

identification division.

program-id. unblocking.

 

goback.

 

=={{header|Delphi}}==

=={{header|Free Pascal}}==

''See [[#Pascal|Pascal]]''

 

=={{header|Go}}==

 

import (

check(err)

fmt.Println(string(bytes))

 

{{out}}

'''Bonus round'''

 

 

import (

block2text("block.dat", "block.txt")

text2block("block.txt", "block2.dat")

 

=={{header|J}}==

 

Using the 720 byte input file linked to in the Raku entry.

_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)

 

'''Example Usage:'''

 

 

=={{header|jq}}==

 

 

 

program.jq:

 

 

 

=={{header|Julia}}==

The program reads from an "infile.dat" file created with dd, as described in the task instructions.

function processfixedlengthrecords(infname, blocksize, outfname)

inf = open(infname)

processfixedlengthrecords("infile.dat", 80, "outfile.dat")

 

 

=={{header|Lua}}==

local sample = [[

Line 1...1.........2.........3.........4.........5.........6.........7.........8

 

-- output:

{{out}}

<pre>8.........7.........6.........5.........4.........3.........2.........1...1 eniL

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).

 

Module FixedFile {

Read fixed$

FixedFile "fixed.random"

 

===Forth Blocks===

Form 80,50

Print "Forth's Blocks"

Page1=NewBlock()

Return

 

=={{header|Neko}}==

fixed length records, in Neko

*/

}

file_close(input)

 

{{out}}

NIGRAM TR 9 eniL

</pre>

 

=={{header|Pascal}}==

const

lineLength = 80;

writeLn();

end;

 

=={{header|Perl}}==

open $out, '>', 'flr-outfile.dat';

 

print reverse($record)."\n" # display reversed records, line-by-line

}

{{out}}

<pre>8.........7.........6.........5.........4.........3.........2.........1...1 eniL

and

[https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/flr-outfile.dat output file]

 

=={{header|Phix}}==

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.

{{out}}

<pre>

 

=={{header|Python}}==

infile = open('infile.dat', 'rb')

outfile = open('outfile.dat', 'wb')

infile.close()

outfile.close()

 

Output:

Essentially the same as task [[Selective_File_Copy]] except more boring.

 

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

}

{{out}}

<pre>8.........7.........6.........5.........4.........3.........2.........1...1 eniL

 

=={{header|REBOL}}==

inp: open %infile.dat

out: open/new %outfile.dat

close inp

close out

 

=={{header|REXX}}==

iFID= 'FIXEDLEN.TXT' /*the file's filename (used for input).*/

call charin iFID, 1, 0 /*open the file, point rec pointer to 1*/

do k=1 for # /* [↓] process all the records read. */

say reverse(@.k) /* reverse a record and write to term. */

{{out|output|text=&nbsp; when using the default input file:}}

{{out}}

</pre>

 

=={{header|Rust}}==

use std::io::prelude::*;

use std::io::{BufReader, BufWriter};

Err(error) => eprintln!("I/O error: {}", error),

}

 

{{out}}

7 eniL

............................................................8 enil detnednI

NIGRAM TR 9 eniL

</pre>

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>

// Since we are writing to a ASCII terminal, ignore nulls

{{out}}

<pre>

</pre>

To write to a file (as one big line), preserving nulls:

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

outfile.dat:

{{out}}

</pre>

<b>Bonus Round</b>

fcn readFourthBlock(inFileNm){

out,f,buf := Sink(String), File(inFileNm,"rb"), Data(1024);

}

f.close(); out.close();

fcn formatToFourthBlock(inFileNm,outFileNm){

n,blk,in,out := 0, Data(), File(inFileNm,"r"), File(outFileNm,"wb");

if(blk) out.write(blk, " "*(1024 - blk.len()));

f.close(); out.close();