Fixed length records: Difference between revisions

=={{header|Ada}}==

Ada string type is a fixed-length string.

with Ada.Text_IO; use Ada.Text_IO;

 

end loop;

end Main;

{{Output}}

<pre>

 

=={{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|FreeBASIC}}==

Const As Byte longRegistro = 80

Const archivoEntrada As String = "infile.dat"

Close

Sleep

 

 

=={{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}}==

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:

 

def c: if length==0 then empty else .[:$n] , (.[$n:] | c) end;

c;

 

 

=={{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|Mathematica}} / {{header|Wolfram Language}}==

 

FixedRecordReverse[inFile_File, outFile_File, length_ : 80] :=

Module[{inStream, outStream, line, byte},

RunProcess[{"dd", "if=" <> outFile[[1]], "cbs=" <> ToString[length], "conv=unblock"}, "StandardOutput"]

];

 

This function will both return the reversed string in the notebook AND write the record to outfile.dat:

 

=={{header|Neko}}==

fixed length records, in Neko

*/

}

file_close(input)

 

{{out}}

===Task: fixed length records===

 

 

proc reverse(infile, outfile: string) =

raise newException(IOError, "truncated data when writing")

 

 

{{out}}

 

===Bonus: Forth blocks===

 

const EmptyRecord = repeat(' ', 64)

when isMainModule:

textToBlock("block1.txt", "block.dat")

 

=={{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

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

local ($/, @ARGV) = (\80, 'infile.dat');

open my $out, '>', 'outfile.dat' or die $!;

print $out scalar reverse while <>; # can read fixed length too :)

close $out;

Slurp and reverse each line in place.

Double reverse.

path('outfile.dat')->spew(reverse unpack '(a80)*', reverse path('infile.dat')->slurp);

Bonus round: convert the sample file to Forth Block format.

Bonus Round: convert Forth Block format to plain text format.

 

=={{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.

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- file i/o</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">sample_text</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""

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

{{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}}

 

=={{header|Ruby}}==

open("infile.dat") do |in_f|

while record = in_f.read(80)

end

end # both files automatically closed

=={{header|Rust}}==

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

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

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

}

 

{{out}}

 

=={{header|Tcl}}==

chan configure stdout -translation binary

 

# while {[set line [read stdin 80]] ne ""} {

# puts -nonewline [string reverse $line]

 

{{out}}

=={{header|Wren}}==

{{libheader|Wren-str}}

import "/str" for Str

 

}

records = File.read("outfile.dat")

 

{{out}}

===Bonus round===

{{libheader|Wren-ioutil}}

import "/str" for Str

 

blockToText.call("data.blk", "data.txt")

textToBlock.call("data.txt", "data2.blk")

 

{{out}}

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();