Create a file on magnetic tape: Difference between revisions

=={{header|Action!}}==

BYTE dev=[1]

PrintE("Rewind the tape and press any key to load previously saved file from tape.")

Load()

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Create_a_file_on_magnetic_tape.png Screenshot from Atari 8-bit computer]

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

=={{header|Arturo}}==

This code

should be able to write

a file

to magnetic tape

=={{header|C}}==

The program is self explanatory. :)

#include<stdio.h>

}

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

{{trans|D}}

#include <fstream>

fb.close();

return 0;

=={{header|Clojure}}==

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

IDENTIFICATION DIVISION.

PROGRAM-ID. MAKE-TAPE-FILE.

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|F#}}==

open System

open System.IO

| PlatformID.Win32NT | PlatformID.Win32S | PlatformID.Win32Windows | PlatformID.WinCE -> File.WriteAllText("TAPE.FILE", msg)

| _ -> File.WriteAllText("/dev/tape", msg)

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