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

5,304 bytes added ,  5 months ago
m
→‎{{header|Wren}}: Changed to Wren S/H
mNo edit summary
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(18 intermediate revisions by 12 users not shown)
Line 19:
 
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>
#include<stdio.h>
 
Line 46 ⟶ 108:
}
 
</syntaxhighlight>
</lang>
 
=={{header|C++}}==
{{trans|D}}
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <fstream>
 
Line 66 ⟶ 128:
fb.close();
return 0;
}</langsyntaxhighlight>
 
=={{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 83 ⟶ 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 96 ⟶ 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 108 ⟶ 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 119 ⟶ 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 127 ⟶ 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 179 ⟶ 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}}==
<langsyntaxhighlight ISlang="is-BASICbasic">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</langsyntaxhighlight>
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
Line 222 ⟶ 367:
}
}
}</langsyntaxhighlight>
 
=={{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 233 ⟶ 378:
//SYSUT1 DD *
DATA TO BE WRITTEN TO TAPE
/* </langsyntaxhighlight>
 
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">
open("/dev/tape", "w") do f
write(f, "Hello tape!")
end
</syntaxhighlight>
</lang>
 
=={{header|Kotlin}}==
{{trans|Scala}}
<langsyntaxhighlight lang="scala">// version 1.1.0 (Linux)
 
import java.io.FileWriter
Line 253 ⟶ 397:
lp0.write("Hello, world!")
lp0.close()
}</langsyntaxhighlight>
 
=={{header|Lua}}==
<langsyntaxhighlight lang="lua">require "lfs"
 
local out
Line 266 ⟶ 410:
file = io.open(out, 'w')
file:write('Hello world')
io.close(file)</langsyntaxhighlight>
 
=={{header|Nim}}==
<langsyntaxhighlight lang="nim">var t = open("/dev/tape", fmWrite)
t.writeln "Hi Tape!"
t.close</langsyntaxhighlight>
 
=={{header|Perl 6}}==
<lang perl6>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;</lang>
 
=={{header|Phix}}==
<langsyntaxhighlight Phixlang="phix">include builtins/write_file.e
constant filepath = iff(platform()=WINDOWS?"tape.file":"/dev/tape"),
write_file(file_path,"Hello world!")</langsyntaxhighlight>
 
=={{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 305 ⟶ 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 311 ⟶ 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 322 ⟶ 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}}==
<langsyntaxhighlight Rustlang="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!")
}</langsyntaxhighlight>
 
=={{header|Scala}}==
===[[Unix]]===
Assuming device is attached to "tape"
<langsyntaxhighlight Scalalang="scala">object LinePrinter extends App {
import java.io.{ FileWriter, IOException }
{
Line 342 ⟶ 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 358 ⟶ 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 370 ⟶ 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 382 ⟶ 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>
PureFox
9,476

edits

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