Rosetta Code

Create a file on magnetic tape: Difference between revisions

Page Discussion

Create a file on magnetic tape (view source)

Revision as of 12:26, 21 November 2023

7,151 bytes added ,  5 months ago
m
→‎{{header|Wren}}: Changed to Wren S/H
m (→‎{{header|Ring}}: Remove vanity tags)
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(29 intermediate revisions by 16 users not shown)
Line 3:
{{omit from|AWK|not OO}}
{{omit from|BASIC|not OO}}
{{omit from|C sharp}}
{{omit from|Fortran|not OO}}
{{omit from|GUISS}}
Line 14 ⟶ 15:
{{omit from|Retro}}
{{omit from|TI-89 BASIC}}
{{omit from|Visual Basic .NET}}
{{omit from|zkl}}
 
The task is to create a new file called "TAPE.FILE" of any size on Magnetic Tape.
 
=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC Save(CHAR ARRAY text)
BYTE dev=[1]
 
Close(dev)
Open(dev,"C:",8,128)
PrintE("Saving started...")
PrintF("Saving text: ""%S""%E",text)
PrintD(dev,text)
Close(dev)
PrintE("Saving finished.")
RETURN
 
PROC Load()
CHAR ARRAY result(255)
BYTE dev=[1]
 
Close(dev)
Open(dev,"C:",4,128)
PrintE("Loading started...")
WHILE Eof(dev)=0
DO
InputSD(dev,result)
PrintF("Loading text: ""%S""%E",result)
OD
Close(dev)
PrintE("Loading finished.")
RETURN
 
PROC Main()
BYTE CH=$02FC ;Internal hardware value for last key pressed
 
PrintE("Press any key to save a file on tape.")
Save("Atari Action!")
 
PutE()
PrintE("Rewind the tape and press any key to load previously saved file from tape.")
Load()
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Create_a_file_on_magnetic_tape.png Screenshot from Atari 8-bit computer]
<pre>
Press any key to save a file on tape.
Saving started...
Saving text: "Atari Action!"
Saving finished.
 
Rewind the tape and press any key to load previously saved file from tape.
Loading started...
Loading text: "Atari Action"
Loading finished.
</pre>
 
=={{header|Applesoft BASIC}}==
<syntaxhighlight lang ApplesoftBasic="applesoftbasic">SAVE</langsyntaxhighlight>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="rebol">write "TAPE.FILE" {
This code
should be able to write
a file
to magnetic tape
}</syntaxhighlight>
 
=={{header|C}}==
The program is self explanatory. :)
<syntaxhighlight lang="c">
<lang C>
/*Abhishek Ghosh, 24th September 2017*/
 
#include<stdio.h>
 
Line 46 ⟶ 108:
}
 
</syntaxhighlight>
</lang>
 
=={{header|C++}}==
{{trans|D}}
<syntaxhighlight lang="cpp">#include <iostream>
#include <fstream>
 
#if defined(_WIN32) || defined(WIN32)
constexpr auto FILENAME = "tape.file";
#else
constexpr auto FILENAME = "/dev/tape";
#endif
 
int main() {
std::filebuf fb;
fb.open(FILENAME,std::ios::out);
std::ostream os(&fb);
os << "Hello World\n";
fb.close();
return 0;
}</syntaxhighlight>
 
=={{header|Clojure}}==
<langsyntaxhighlight lang="clojure">(spit "/dev/tape" "Hello, World!")</langsyntaxhighlight>
 
=={{header|COBOL}}==
 
{{works with|OpenCOBOLCOBOL 2002}}
 
<langsyntaxhighlight COBOLlang="cobolfree"> >>SOURCE FORMAT IS FREE
IDENTIFICATION DIVISION.
PROGRAM-ID. MAKE-TAPE-FILE.
Line 62 ⟶ 145:
FILE-CONTROL.
SELECT TAPE-FILE
ASSIGN TO "./TAPE.FILE"
ORGANIZATION IS LINE SEQUENTIAL.
ACCESS MODE IS SEQUENTIAL.
 
DATA DIVISION.
FILE SECTION.
FD TAPE-FILE RECORD CONTAINS 51 CHARACTERS.
01 TAPE-FILE-RECORD PICPICTURE IS X(51).
 
PROCEDURE DIVISION.
Line 75 ⟶ 159:
FROM "COBOL treats tape files and text files identically."
END-WRITE
STOPCLOSE RUN.</lang>TAPE-FILE
STOP RUN.
 
END PROGRAM MAKE-TAPE-FILE.</syntaxhighlight>
 
=={{header|Crystal}}==
{{trans|D}}
<syntaxhighlight lang="ruby">filename = {% if flag?(:win32) %}
"TAPE.FILE"
{% else %}
"/dev/tape"
{% end %}
File.write filename, "howdy, planet!"</syntaxhighlight>
 
=={{header|D}}==
<langsyntaxhighlight Dlang="d">import std.stdio;
 
void main() {
Line 87 ⟶ 183:
}
f.writeln("Hello World!");
}</langsyntaxhighlight>
 
=={{header|Delphi}}==
{{Trans|D}}
<syntaxhighlight lang="delphi">
program Create_a_file_on_magnetic_tape;
 
{$APPTYPE CONSOLE}
 
const
{$IFDEF WIN32}
FileName = 'tape.file';
{$ELSE}
FileName = '/dev/tape';
{$ENDIF}
 
var
f: TextFile;
 
begin
Assign(f, FileName);
Rewrite(f);
Writeln(f, 'Hello World');
close(f);
end.
</syntaxhighlight>
 
=={{header|F#}}==
<syntaxhighlight lang="fsharp">
open System
open System.IO
 
let env = Environment.OSVersion.Platform
let msg = "Hello Rosetta!"
 
match env with
| PlatformID.Win32NT | PlatformID.Win32S | PlatformID.Win32Windows | PlatformID.WinCE -> File.WriteAllText("TAPE.FILE", msg)
| _ -> File.WriteAllText("/dev/tape", msg)
</syntaxhighlight>
 
=={{header|Factor}}==
<syntaxhighlight lang="factor">USING: io.encodings.ascii io.files kernel system ;
 
"Hello from Rosetta Code!"
os windows? "tape.file" "/dev/tape" ?
ascii set-file-contents</syntaxhighlight>
 
=={{header|Fortran}}==
Line 98 ⟶ 239:
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|FreeBASIC}}==
<syntaxhighlight lang="freebasic">Dim As Integer numarch = Freefile
Open "tape.file" For Output As #numarch
Print #numarch, "Soy un archivo de cinta ahora, o espero serlo pronto."
Close #numarch</syntaxhighlight>
 
=={{header|Go}}==
Line 106 ⟶ 253:
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.
<langsyntaxhighlight lang="go">package main
 
import (
Line 158 ⟶ 305:
log.Fatal("writing data:", err)
}
}</langsyntaxhighlight>
{{out}}
<pre>
% go run tapefile.go -data "Hello World" -gzip | tar -tvzf -
-rw-rw---- 0 guest guest 11 11 Aug 13:42 TAPE.FILE</pre>
 
=={{header|Groovy}}==
{{trans|Java}}
<syntaxhighlight lang="groovy">import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.Paths
 
class CreateFile {
static void main(String[] args) throws IOException {
String os = System.getProperty("os.name")
if (os.contains("Windows")) {
Path path = Paths.get("tape.file")
Files.write(path, Collections.singletonList("Hello World!"))
} else {
Path path = Paths.get("/dev/tape")
Files.write(path, Collections.singletonList("Hello World!"))
}
}
}</syntaxhighlight>
 
=={{header|Haskell}}==
 
<langsyntaxhighlight lang="haskell">module Main (main) where
 
main :: IO ()
main = writeFile "/dev/tape" "Hello from Rosetta Code!"</langsyntaxhighlight>
 
=={{header|Icon}} and {{header|Unicon}}==
 
This solution mimics the solution used in many other languages here and works in both Icon and Unicon.
<langsyntaxhighlight lang="unicon">procedure main()
write(open("/dev/tape","w"),"Hi")
end</langsyntaxhighlight>
 
=={{header|IS-BASIC}}==
<syntaxhighlight lang="is-basic">100 OPEN #1:"Tape1:README.TXT" ACCESS OUTPUT
110 PRINT #1:"I am a tape file now, or hope to be soon."
120 CLOSE #1</syntaxhighlight>
 
=={{header|Java}}==
<syntaxhighlight lang="java">import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Collections;
 
public class CreateFile {
public static void main(String[] args) throws IOException {
String os = System.getProperty("os.name");
if (os.contains("Windows")) {
Path path = Paths.get("tape.file");
Files.write(path, Collections.singletonList("Hello World!"));
} else {
Path path = Paths.get("/dev/tape");
Files.write(path, Collections.singletonList("Hello World!"));
}
}
}</syntaxhighlight>
 
=={{header|JCL}}==
<langsyntaxhighlight JCLlang="jcl">// EXEC PGM=IEBGENER
//* Create a file named "TAPE.FILE" on magnetic tape; "UNIT=TAPE"
//* may vary depending on site-specific esoteric name assignment
Line 187 ⟶ 378:
//SYSUT1 DD *
DATA TO BE WRITTEN TO TAPE
/* </langsyntaxhighlight>
 
=={{header|Julia}}==
<syntaxhighlight lang="julia">
open("/dev/tape", "w") do f
write(f, "Hello tape!")
end
</syntaxhighlight>
 
=={{header|Kotlin}}==
{{trans|Scala}}
<langsyntaxhighlight lang="scala">// version 1.1.0 (Linux)
 
import java.io.FileWriter
Line 199 ⟶ 397:
lp0.write("Hello, world!")
lp0.close()
}</langsyntaxhighlight>
 
=={{header|Lua}}==
<syntaxhighlight lang="lua">require "lfs"
 
local out
if lfs.attributes('/dev/tape') then
out = '/dev/tape'
else
out = 'tape.file'
end
file = io.open(out, 'w')
file:write('Hello world')
io.close(file)</syntaxhighlight>
 
=={{header|Nim}}==
<langsyntaxhighlight lang="nim">var t = open("/dev/tape", fmWrite)
t.writeln "Hi Tape!"
t.close</langsyntaxhighlight>
 
=={{header|Perl 6Phix}}==
<syntaxhighlight lang="phix">include builtins/write_file.e
<lang perl6>my $tape = open "/dev/tape", :w or die "Can't open tape: $!";
constant filepath = iff(platform()=WINDOWS?"tape.file":"/dev/tape"),
$tape.say: "I am a tape file now, or hope to be soon.";
write_file(file_path,"Hello world!")</syntaxhighlight>
$tape.close;</lang>
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(out "/dev/tape"
(prin "Hello World!") )</langsyntaxhighlight>
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">>>> with open('/dev/tape', 'w') as t: t.write('Hi Tape!\n')
...
>>> </langsyntaxhighlight>
 
=={{header|Racket}}==
<syntaxhighlight lang="racket">
<lang 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")))
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>my $tape = open "/dev/tape", :w or die "Can't open tape: $!";
$tape.say: "I am a tape file now, or hope to be soon.";
$tape.close;</syntaxhighlight>
 
=={{header|REXX}}==
Line 233 ⟶ 450:
<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.
<langsyntaxhighlight lang="rexx">/*REXX pgm demonstrates writing records to an attached magnetic tape.*/
dsName = 'TAPE.FILE' /*dsName of "file" being written.*/
 
Line 239 ⟶ 456:
call lineout dsName, 'this is record' j || "."
end /*j*/
/*stick a fork in it, we're done.*/</langsyntaxhighlight>
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
# Project : Create a file on magnetic tape
 
Line 250 ⟶ 467:
fwrite(fp, str)
fclose(fp)
</syntaxhighlight>
</lang>
 
=={{header|Ruby}}==
{{trans|C}}
<syntaxhighlight lang="ruby">File.open("tape.file", "w") do |fh|
fh.syswrite("This code should be able to write a file to magnetic tape.\n")
end</syntaxhighlight>
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">use std::io::Write;
use std::fs::File;
 
fn main() -> std::io::Result<()> {
File::open("/dev/tape")?.write_all(b"Hello from Rosetta Code!")
}</syntaxhighlight>
 
=={{header|Scala}}==
===[[Unix]]===
Assuming device is attached to "tape"
<langsyntaxhighlight Scalalang="scala">object LinePrinter extends App {
import java.io.{ FileWriter, IOException }
{
Line 262 ⟶ 493:
lp0.close()
}
}</langsyntaxhighlight>
 
=={{header|Seed7}}==
 
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const proc: main is func
local
var file: tapeFile is STD_NULL;
begin
tapeFile := open("/dev/tape", "w");
if tapeFile = STD_NULL then
tapeFile := open("tape.file", "w");
end if;
if tapeFile <> STD_NULL then
writeln(tapeFile, "Hello, world!");
close(tapeFile);
else
writeln(" ***** Cannot open tape file.");
end if;
end func;</syntaxhighlight>
 
=={{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}}
<langsyntaxhighlight lang="tcl">cd /tmp
 
# Create the file
Line 278 ⟶ 530:
fcopy $fin $fout
close $fin
close $fout</langsyntaxhighlight>
 
=={{header|TUSCRIPT}}==
<langsyntaxhighlight lang="tuscript">$$ MODE TUSCRIPT
STATUS = CREATE ("tape.file",tape-o,-std-)
PRINT STATUS</langsyntaxhighlight>
{{Out}}
<pre>
Line 290 ⟶ 542:
 
=={{header|UNIX Shell}}==
<langsyntaxhighlight lang="bash">#!/bin/sh
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
# tar c hello.jnk > /dev/tape # With newer archivers redirection is needed</langsyntaxhighlight>
 
=={{header|Wren}}==
<syntaxhighlight lang="wren">import "os" for Platform
import "io" for File
 
var fileName = (Platform.isWindows) ? "TAPE.FILE" : "/dev/tape"
File.create(fileName) { |file|
file.writeBytes("Hello World!\n")
}</syntaxhighlight>
 
=={{header|ZX Spectrum Basic}}==
Line 302 ⟶ 563:
We can use any start address, depending on where we want the data to come from.
Here we dump the contents of the screen:
<langsyntaxhighlight lang="zxbasic">SAVE "TAPEFILE" CODE 16384,6912</langsyntaxhighlight>
 
{{omit from|C sharp}}
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/220582...351738"