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

{{trans|D}}

"TAPE.FILE"

{% else %}

"/dev/tape"

{% end %}

 

=={{header|D}}==

 

void main() {

}

f.writeln("Hello World!");

 

=={{header|Delphi}}==

{{Trans|D}}

program Create_a_file_on_magnetic_tape;

 

close(f);

end.

 

=={{header|Factor}}==

 

"Hello from Rosetta Code!"

os windows? "tape.file" "/dev/tape" ?

 

=={{header|Fortran}}==

 

=={{header|FreeBASIC}}==

Open "tape.file" For Output As #numarch

Print #numarch, "Soy un archivo de cinta ahora, o espero serlo pronto."

 

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