Create a file on magnetic tape: Difference between revisions

 

The task is to create a new file called "TAPE.FILE" of any size on Magnetic Tape.

 

=={{header|Applesoft BASIC}}==

 

=={{header|C}}==

The program is self explanatory. :)

#include<stdio.h>

 

}

 

 

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

{{trans|D}}

#include <fstream>

 

fb.close();

return 0;

 

=={{header|Clojure}}==

 

=={{header|COBOL}}==

 

 

IDENTIFICATION DIVISION.

PROGRAM-ID. MAKE-TAPE-FILE.

FILE-CONTROL.

SELECT TAPE-FILE

 

DATA DIVISION.

FILE SECTION.

 

PROCEDURE DIVISION.

FROM "COBOL treats tape files and text files identically."

END-WRITE

 

=={{header|D}}==

 

void main() {

}

f.writeln("Hello World!");

=={{header|Delphi}}==

{{Trans|D}}

program Create_a_file_on_magnetic_tape;

 

close(f);

end.

=={{header|Fortran}}==

Fortran performs reads and writes to some device, without caring much about the precise nature of the device: card reader/punch, paper tape reader/punch, keyboard, display console, and of course magnetic tape. Sequential input or output is normal, but random access by record number is also possible, though the interface between the Fortran program and the device may not support such attempts, as with a card reader or a display screen. There are also special statements, such as REWIND and BACKSPACE, and ENDFILE. The file OPEN statement will specify such matters as record length and block size and so all is in place for dealing with magnetic tapes...

 

This was developed when tape drives used half-inch tapes in lengths up to 2,400 feet and seven or nine-track recording, storing up to about 150MB per reel - much depended on the length lost to IRG usage between blocks, but block sizes beyond 20,000 were considered large. Subsequent tape designs have included 18, 36, and 128 tracks, helical recording and storage capacities in tens of gigabytes. Naturally, the tape labelling protocols have become even more complex, but, these matters are handled by more complex operating systems.

 

=={{header|Go}}==

The tar archive will contain a single file, called <tt>TAPE.FILE</tt> by default,

with the contents of the command line <tt>-data</tt> option.

 

import (

log.Fatal("writing data:", err)

}

{{out}}

<pre>

=={{header|Groovy}}==

{{trans|Java}}

import java.nio.file.Path

import java.nio.file.Paths

}

}

 

=={{header|Haskell}}==

 

 

main :: IO ()

 

=={{header|Icon}} and {{header|Unicon}}==

 

This solution mimics the solution used in many other languages here and works in both Icon and Unicon.

write(open("/dev/tape","w"),"Hi")

 

=={{header|IS-BASIC}}==

110 PRINT #1:"I am a tape file now, or hope to be soon."

 

=={{header|Java}}==

import java.nio.file.Files;

import java.nio.file.Path;

}

}

 

=={{header|JCL}}==

//* Create a file named "TAPE.FILE" on magnetic tape; "UNIT=TAPE"

//* may vary depending on site-specific esoteric name assignment

//SYSUT1 DD *

DATA TO BE WRITTEN TO TAPE

 

=={{header|Julia}}==

open("/dev/tape", "w") do f

write(f, "Hello tape!")

end

 

=={{header|Kotlin}}==

{{trans|Scala}}

 

import java.io.FileWriter

lp0.write("Hello, world!")

lp0.close()

 

=={{header|Lua}}==

 

local out

file = io.open(out, 'w')

file:write('Hello world')

 

=={{header|Nim}}==

t.writeln "Hi Tape!"

 

=={{header|Phix}}==

constant filepath = iff(platform()=WINDOWS?"tape.file":"/dev/tape"),

 

=={{header|PicoLisp}}==

 

=={{header|Python}}==

...

 

=={{header|Racket}}==

#lang racket

(with-output-to-file "/dev/tape" #:exists 'append

(λ() (displayln "I am a cheap imitation of the Perl code for a boring problem")))

 

=={{header|Raku}}==

(formerly Perl 6)

$tape.say: "I am a tape file now, or hope to be soon.";

 

=={{header|REXX}}==

<br><br>VM/CMS would use a &nbsp; '''CP ATTACH''' &nbsp; command, coupled with a &nbsp; '''CMS FILEDEF''' &nbsp; command which associates a

<br>DSNAME &nbsp; (dataset name) &nbsp; that will be written to on the attached (and mounted) magnetic tape device.

dsName = 'TAPE.FILE' /*dsName of "file" being written.*/

 

call lineout dsName, 'this is record' j || "."

end /*j*/

 

=={{header|Ring}}==

# Project : Create a file on magnetic tape

 

fwrite(fp, str)

fclose(fp)

 

=={{header|Ruby}}==

{{trans|C}}

fh.syswrite("This code should be able to write a file to magnetic tape.\n")

 

=={{header|Rust}}==

use std::fs::File;

 

fn main() -> std::io::Result<()> {

File::open("/dev/tape")?.write_all(b"Hello from Rosetta Code!")

 

=={{header|Scala}}==

===[[Unix]]===

Assuming device is attached to "tape"

import java.io.{ FileWriter, IOException }

{

lp0.close()

}

 

=={{header|Seed7}}==

 

 

const proc: main is func

writeln(" ***** Cannot open tape file.");

end if;

 

=={{header|Tcl}}==

Tcl does not have built-in special support for tape devices, so it relies on the OS to handle most of the details for it. Assuming a relatively modern Unix:

{{trans|UNIX Shell}}

 

# Create the file

fcopy $fin $fout

close $fin

 

=={{header|TUSCRIPT}}==

STATUS = CREATE ("tape.file",tape-o,-std-)

{{Out}}

<pre>

 

=={{header|UNIX Shell}}==

cd # Make our home directory current

echo "Hello World!" > hello.jnk # Create a junk file

# tape rewind # Uncomment this to rewind the tape

tar c hello.jnk # Traditional archivers use magnetic tape by default

 

=={{header|Wren}}==

import "io" for File

 

File.create(fileName) { |file|

file.writeBytes("Hello World!\n")

 

=={{header|ZX Spectrum Basic}}==

We can use any start address, depending on where we want the data to come from.

Here we dump the contents of the screen: