Selective file copy: Difference between revisions

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

Using formatted transput to process similar files to the COBOL sample.

MODE OUTPUTRECORD = STRUCT( STRING field a, INT field c, STRING field x );

 

close( output file );

close( input file )

 

Input file:

Output and formatting is done using printf().

 

 

BEGIN {

print "# Done."

}

 

{{out}}

levels. In this example only levels 01, and 05 are used.

 

01 ws-input-record.

:INPUT-RECORD:

 

01 ws-input-record.

05 field-a pic x(5).

05 field-c pic s9(5).

05 field-d pic x(5).

 

And finally, the example selective-copy.cob

*> Tectonics:

*> cobc -xj selective-copy.cob

.

 

 

The output file has no newlines, so normal '''cat''' type commands are not of

 

=={{header|Fortran}}==

TYPE PLACE

INTEGER N

IS.LATLONG = HERE.LATLONG !Piecemeal, as no common structure was defined.

WRITE (6,*) IS !Reveal the result.

This produces a file in a standard format. All output starts with a space in column one (in case this output were to be sent to a lineprinter, for which that would be the carriage control character), and begins the block of output with a special line that gives the name of the NAMELIST prefixed with an ampersand, and ends it with a slash. Each line starts with the name of a variable followed by an equals, then comes its value in the same style as would be used in free-form output, using a field large enough for its largest value. Some extra spaces are supplied before the = according to name length to improve readability. The whole line looks much as if it were an assignment statement in Fortran. There is special provision for listing the values of arrays which normally are shown one after another in the standard order. A run of equal values will be shown with a repetition count as in ... ,6*T, ... for six "true" values in a row, alas not using an @ symbol. CHARACTER variables will be shown with all their characters and even if they are all blank, they will not be shown as "" though that is acceptable for input. There is a default record length of 133 (again for lineprinters) and a variable may require multiple lines; CHARACTER variables split across lines include the content of the first character of the next line, but otherwise the line break is after a comma. Structure names alas use % instead of a full stop, but a full stop may be accepted as input. Before F90, such data aggregates were not available, so only ordinary variables could be named.

<pre>

=={{header|FreeBASIC}}==

{{trans|Julia}}

Open "m:\out.txt" For Output As #2

 

Loop

Close #1, #2

{{out}}<pre>in.txt:

A bbbbB0001+d2345

=={{header|Go}}==

JSON is popular these days for structured data and Go has support for this kind of selective copy in the JSON reader. The reader also supports custom conversions on fields. The common idiom for record construction and field initialization is shown.

 

import (

}

}

{{out|o1.json}}

<pre>

(Remember: J's prompt is three spaces, so indented lines here are J sentences, and the following line(s) is/are the result(s) from the sentence.)

 

R=: {{5{.y#x}}

('A'&R,'B'&R,N,'D'&R)&>1+i.5

AAAAABBBBB0005-DDDDD

(('A'&R,'B'&R,N,'D'&R)&>1+i.5) fwrite 'example'

 

Note that we've written 100 characters here -- there's no newlines in this file:

 

 

1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4 4

_20 ((##\)5 5 5 5)&(</.)\fread 'example'

├─────┼─────┼─────┼─────┤

│AAAAA│BBBBB│0005-│DDDDD│

 

A NB. first column

A

AAA

AAAA

 

0001+

0002+

_4

_5

 

1

2

-5

5#'X'

 

A 1XXXXX

AA 2XXXXX

AAAAA -5XXXXX

(A,"1('5.0' 8!:2,.N),"1(5#'X')) fwrite 'output'

 

Again, there's no newlines in the result file, so we would have to know something about its record structure to make sense of it:

 

A 1XXXXXAA 2XXXXXAAA 3XXXXXAAAA -4XXXXXAAAAA -5XXXXX

_15 ]\fread 'output'

AAA 3XXXXX

AAAA -4XXXXX

 

=={{header|Java}}==

With a little help from my friens

import java.io.FileWriter;

import java.io.File;

return;

}

 

=={{header|Julia}}==

for line in split(strip(read("in.txt", String)), "\n")

fielda, fieldb, fieldd = line[1:5], line[6:10], line[16:20]

print(out, fielda, fieldc, 'X'^length(fieldd), "\n")

end

<pre>

in.txt:

 

=={{header|Kotlin}}==

 

import java.io.File

// check it worked

println(out.readText())

 

Contents of selective_input.txt:

=={{header|NetRexx}}==

with a little help from a friend

-- nrc -keepasjava -savelog copys

options replace format comments java crossref symbols nobinary

ex.printStackTrace()

end

 

=={{header|Nim}}==

{{trans|Phix}}

{{trans|Kotlin}}

 

const Data = """

stdout.write s

outfile.write s

 

 

 

=={{header|ooRexx}}==

infile ="in.txt"

outfile="out.txt"

expose instream outstream

instream~close

{{out}}

<pre>AA 01XXXXX

=={{header|Perl}}==

{{trans|Raku}}

'field a' => { offset => 0, length => 5, type => 'Str' },

'field b' => { offset => 5, length => 5, type => 'Str' },

}

print "\n" . join "\n", @result;

{{out}}

<pre>field a : A field b : bbbbB field c : 1 field d : + field e : d2345

{{trans|Kotlin}}

Obviously it does not perform any actual file i/o under pwa/pj2s and merely shows the same screen output.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">data</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""

<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fout</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(in F

(until (eof)

(line) ) ) )

 

{{out}}

<pre>A 1XXXXX

 

=={{header|PL/I}}==

copys: Proc Options(Main);

Dcl 1 s1 unal,

eoj:

End;

{{out}}

<pre>AA 01XXXXX

{{trans|Kotlin}}

 

 

(define (read+write)

 

(with-output-to-file "selective-output.txt" #:mode 'text #:exists 'replace

 

{{in}}

Since the sfc.dat file is binary encoded, I can't include it here easily as text so [https://github.com/thundergnat/rc/blob/master/sfc.dat here is a link to an online copy] instead.

 

'field a' => { offset => 0, length => 5, type => 'Str' },

'field b' => { offset => 5, length => 5, type => 'Str' },

}

}

{{out}}

<pre>Input data as read from ./sfc.dat:

=={{header|REXX}}==

{{trans|PL/I}}

out='out.txt'; 'erase' out

Do While lines(in)>0

Call lineout in

Call lineout out

{{out}}

Using the test file produced by PL/I.

{{libheader|Wren-ioutil}}

{{libheader|Wren-fmt}}

 

var process = Fn.new { |line|

}

// check it worked

 

{{out}}

=={{header|zkl}}==

Taking a clue from ALGOL 68 and Awk.

// 012345678901234567890...

// A bbbbB0001+d2345

if(fld4=="-") fld3=-fld3.toInt();

"%-5s%5d%s\n".fmt(fld1,fld3,"X"*fld5.len())

{{out}}

<pre>