Hello world/Line printer: Difference between revisions
No edit summary |
No edit summary |
||
Line 634: | Line 634: | ||
Another method is to include the CR+LF control characters as ^M^J. |
Another method is to include the CR+LF control characters as ^M^J. |
||
=={{header|ERRE |
=={{header|ERRE}}== |
||
<lang ERRE> |
<lang ERRE> |
||
! Hello World in ERRE language |
! Hello World in ERRE language |
Revision as of 15:00, 13 November 2014
You are encouraged to solve this task according to the task description, using any language you may know.
Cause a line printer attached to the computer to print a line containing the message Hello World!
Note: A line printer is not the same as standard output. A line printer was an older-style printer which prints one line at a time to a continuous ream of paper. With some systems, a line printer can be any device attached to an appropriate port (such as a parallel port).
Ada
Unix
Assuming that the line printer is attached to /dev/lp0 <lang Ada> with Ada.Text_IO; use Ada.Text_IO;
procedure Print_Line is
Printer : File_Type;
begin
begin Open (Printer, Mode => Out_File, Name => "/dev/lp0"); exception when others => Put_Line ("Unable to open printer."); return; end;
Set_Output (Printer); Put_Line ("Hello World!"); Close (Printer);
end Print_Line; </lang>
Applesoft BASIC
Assumes a printer card is installed in the Apple II's number 1 expansion slot.
<lang basic> PR#1 PRINT "HELLO WORLD!" </lang>
AutoHotkey
<lang AutoHotkey> Fileappend, Hello World!, print.txt Run, print "print.txt" </lang>
AWK
Unix / Linux: <lang AWK> BEGIN { print("Hello World!") >"/dev/lp0" } </lang>
BASIC
<lang qbasic>LPRINT "Hello World!"</lang>
Batch File
<lang dos>ECHO Hello world!>PRN</lang>
BBC BASIC
<lang bbcbasic> prn% = OPENOUT("PRN:")
PRINT #prn%, "Hello World!" CLOSE #prn%</lang>
C
Unix
Assuming that the line printer is attached to /dev/lp0 <lang C>#include <stdio.h>
int main() {
FILE *lp; lp = fopen("/dev/lp0","w"); fprintf(lp,"Hello world!\n"); fclose(lp); return 0;
}</lang>
C++
<lang cpp>#include <iostream>
- include <fstream>
int main(){
std::ofstream lprFile; lprFile.open( "/dev/lp0" ); lprFile << "Hello World!\n"; lprFile.close(); return 0;
}</lang>
C#
"My Printer" should be replaced with the friendly name of the printer. This is to avoid the extra step of locating the default printer, which is out of scope of this example.
<lang C sharp> [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] public class DOCINFOA {
[MarshalAs(UnmanagedType.LPStr)] public string pDocName; [MarshalAs(UnmanagedType.LPStr)] public string pOutputFile; [MarshalAs(UnmanagedType.LPStr)] public string pDataType;
}
[DllImport("winspool.Drv", EntryPoint = "OpenPrinterA", CharSet = CharSet.Ansi, ExactSpelling = true)] public static extern bool OpenPrinter([MarshalAs(UnmanagedType.LPStr)] string szPrinter, out IntPtr hPrinter, IntPtr pd);
[DllImport("winspool.Drv", EntryPoint = "StartDocPrinterA", CharSet = CharSet.Ansi, ExactSpelling = true)] public static extern bool StartDocPrinter(IntPtr hPrinter, int level, [In, MarshalAs(UnmanagedType.LPStruct)] DOCINFOA di);
[DllImport("winspool.Drv", EntryPoint = "StartPagePrinter", CharSet = CharSet.Ansi, ExactSpelling = true)] public static extern bool StartPagePrinter(IntPtr hPrinter);
[DllImport("winspool.Drv", EntryPoint = "EndPagePrinter", CharSet = CharSet.Ansi, ExactSpelling = true)] public static extern bool EndPagePrinter(IntPtr hPrinter);
[DllImport("winspool.Drv", EntryPoint = "EndDocPrinter", CharSet = CharSet.Ansi, ExactSpelling = true)] public static extern bool EndDocPrinter(IntPtr hPrinter);
[DllImport("winspool.Drv", EntryPoint = "ClosePrinter", CharSet = CharSet.Ansi, ExactSpelling = true)] public static extern bool ClosePrinter(IntPtr hPrinter);
[DllImport("winspool.Drv", EntryPoint = "WritePrinter", CharSet = CharSet.Ansi, ExactSpelling = true)] public static extern bool WritePrinter(IntPtr hPrinter, IntPtr pBytes, Int32 dwCount, out Int32 dwWritten);
public void HelloWorld() {
IntPtr hPrinter; bool openSuccessful = OpenPrinter("My Printer", out hPrinter, IntPtr.Zero); if (openSuccessful) { DOCINFOA docInfo = new DOCINFOA(); docInfo.pDocName = "Hello World Example"; docInfo.pOutputFile = null; docInfo.pDataType = "RAW";
if (StartDocPrinter(hPrinter, 1, docInfo)) { StartPagePrinter(hPrinter);
const string helloWorld = "Hello World!"; IntPtr buf = Marshal.StringToCoTaskMemAnsi(helloWorld);
int bytesWritten; WritePrinter(hPrinter, buf, helloWorld.Length, out bytesWritten);
Marshal.FreeCoTaskMem(buf); } if (EndPagePrinter(hPrinter)) if (EndDocPrinter(hPrinter)) ClosePrinter(hPrinter); }
}</lang>
Clipper
<lang Clipper>SET PRINT ON SET CONSOLE OFF ? "Hello World!" SET PRINT OFF SET CONSOLE ON </lang>
COBOL
<lang COBOL>IDENTIFICATION DIVISION. PROGRAM-ID. GOODBYE-WORLD-PRINTER.
PROCEDURE DIVISION. DISPLAY 'Hello World!' UPON PRINTER END-DISPLAY. STOP RUN.</lang>
D
<lang d>import std.stdio;
void main() {
auto lp = File("/dev/lp0", "w"); lp.writeln("Hello World!");
} </lang>
Delphi
<lang Delphi>program Project1;
{$APPTYPE CONSOLE}
uses Printers;
var
lPrinterAsTextFile: TextFile;
begin
AssignPrn(lPrinterAsTextFile); Rewrite(lPrinterAsTextFile); Writeln(lPrinterAsTextFile, 'Hello World!'); CloseFile(lPrinterAsTextFile);
end.</lang>
Factor
Prints through Unix "lpr" command.
<lang factor>( scratchpad ) USE: io.encodings.utf8 ( scratchpad ) USE: io.launcher ( scratchpad ) "lpr" utf8 [ "Hello World!" print ] with-process-writer</lang>
Go
<lang go>package main
import ( "fmt" "os" )
func main() { lp0, err := os.Create("/dev/lp0")
if err != nil { panic(err) }
defer lp0.Close()
fmt.Fprintln(lp0, "Hello World!") }</lang>
Groovy
<lang groovy>new File('/dev/lp0').write('Hello World!\n') </lang>
GUISS
<lang guiss>Start,Programs,Accessories,Notepad,Type:Goodbye World[pling], Menu:File,Print,Button:OK</lang>
Harbour
<lang visualfoxpro>SET PRINT ON SET CONSOLE OFF ? "Hello World!" SET PRINT OFF SET CONSOLE ON</lang>
Haskell
<lang haskell> import System.Cmd
cmd = "echo \"Hello World!\" | lpr"
main = system cmd </lang>
Icon and Unicon
Works in both languages, provided printer is attached to /dev/lp0.
<lang unicon>procedure main()
write(open("/dev/lp0","w"),"Hello, world!")
end</lang>
Integer BASIC
See Applesoft BASIC.
J
<lang j>require'print' print'Hello world!'</lang>
Java
<lang java>import java.io.FileWriter; import java.io.IOException;
public class LinePrinter {
public static void main(String[] args) { try { FileWriter lp0 = new FileWriter("/dev/lp0"); lp0.write("Hello World!"); lp0.close(); } catch (IOException ioe) { ioe.printStackTrace(); } }
}</lang>
JavaScript
<lang javascript>// This example runs on Node.js var fs = require('fs'); // Assuming lp is at /dev/lp0 var lp = fs.openSync('/dev/lp0', 'w'); fs.writeSync(lp, 'Hello, world!\n'); fs.close(lp);</lang>
<lang javascript> document.write("Hello World!"); print(); //Opens a dialog. </lang>
Lasso
<lang lasso>File_Write: '/dev/lp0', 'Hello world', -FileOverWrite;</lang>
Locomotive Basic
<lang locobasic>10 PRINT #8, "Hello World!"</lang>
Mathematica / Wolfram Language
<lang Mathematica>commandstring = "echo Hello World! | lpr -P Printer01" Run[commandstring]</lang>
MATLAB / Octave
Unix
Assuming that the line printer is attached to /dev/lp0 <lang Matlab> fid = fopen('/dev/lp0');
fprintf(fid,'Hello World!\n'); fclose(fid);</lang>
Nimrod
Assuming that the line printer is attached to /dev/lp0: <lang nimrod>var lp = open("/dev/lp0", fmWrite) lp.writeln "Hello World" lp.close()</lang>
MIXAL
<lang MIXAL> LPR EQU 18 STRING EQU 2000 ORIG 3000 START IOC 0(LPR) OUT STRING(LPR) HLT ORIG STRING ALF HELLO ALF WORL ALF D! END START </lang>
OCaml
Assuming that the line printer is attached to /dev/lp0 <lang ocaml>let () =
let oc = open_out "/dev/lp0" in output_string oc "Hello world!\n"; close_out oc ;;</lang>
OpenEdge/Progress
<lang progress>OUTPUT TO PRINTER. PUT UNFORMATTED "Hello world!" SKIP. OUTPUT CLOSE.</lang>
Pascal
Example from the FreePascal documentation: <lang pascal>program testprn; uses printer; var i: integer;
f: text;
begin
writeln ( 'Test of printer unit' ); writeln ( 'Writing to lst ...' ); for i := 1 to 80 do writeln ( lst, 'This is line', i, '.' #13 ); close ( lst ); writeln ( 'Done.' ); {$ifdef Unix } writeln ( 'Writing to pipe ...' ); assignlst ( f, '|/usr/bin/lpr −m' ); rewrite ( f ); for i:= 1 to 80 do writeln ( f, 'This is line ', i, '.'#13 ); close ( f ); writeln ( 'Done.' ) {$endif}
end.</lang>
Perl
Assuming that the line printer is attached to /dev/lp0 <lang perl>open O, ">", "/dev/lp0"; print O "Hello World!\n"; close O;</lang>
Perl 6
<lang perl6>given open '/dev/lp0', :w { # Open the device for writing as the default
.say('Hello World!'); # Send it the string .close;
- ^ The prefix "." says "use the default device here"
}</lang>
PHP
<lang PHP><?php file_put_contents('/dev/lp0', 'Hello world!'); ?></lang>
<lang PHP><?php fclose(STDOUT); $STDOUT = fopen('/dev/lp0', 'a'); echo 'Hello world!'; ?></lang>
PicoLisp
<lang PicoLisp>(out '(lpr "-P" "Printer01")
(prinl "Hello world") )</lang>
PL/I
<lang pli> hello: procedure options(main);
put skip list('Hello world.');
end hello;</lang>
PostScript
Technically not really correct, as this has to be sent to the printer directly. It will output Hello world, then, though. <lang postscript><</PageSize [595 842]>> setpagedevice % set page size to DIN A4 /Courier findfont % use Courier 12 scalefont setfont % 12 pt 28 802 moveto % 1 cm from the top and left edges (Hello world) show % draw the string</lang>
PureBasic
<lang PureBasic>MyPrinter$ = LPRINT_GetDefaultPrinter() If LPRINT_OpenPrinter(MyPrinter$)
If LPRINT_StartDoc("Printing a RC-Task") LPRINT_Print(Chr(27) + "E") ; PCL reset for HP Printers LPRINT_PrintN("Hello World!") LPRINT_NewPage() LPRINT_EndDoc() EndIf LPRINT_ClosePrinter()
EndIf</lang>
Python
Assuming that the line printer is attached to /dev/lp0: <lang python>lp = open("/dev/lp0") lp.write("Hello World!\n") lp.close()</lang>
If the above code gives you the error "IOError: File not open for writing", try: <lang python>lp = open("/dev/lp0","w") lp.write("Hello World!\n") lp.close()</lang>
Racket
<lang racket>
- lang racket
(define (print text)
;; try lpr first (define lpr-exe (find-executable-path "lpr")) ;; otherwise use a special file (if lpr-exe (with-input-from-string (~a text "\n") (λ() (void (system* lpr-exe)))) (with-output-to-file #:exists 'append (case (system-type) [(windows) "PRN"] [else "/dev/lp0"]) (λ() (displayln text)))))
(print "Hello World!") </lang>
REXX
There is no direct way for REXX programs to write to the printer,
but a shell command could be used.
In DOS (or under Windows):
<lang rexx>str='Hello World'
'@ECHO' str ">PRN"</lang>
RPG
<lang RPG>
Fqsysprt O F 80 printer C except C seton LR Oqsysprt E O 11 'Hello world'
</lang>
Ruby
Assumes that lpr
command reaches printer.
<lang ruby>open("| lpr", "w") { |f| f.puts "Hello World!" }</lang>
Run BASIC
<lang runbasic> shell$("echo \"Hello World!\" | lpr")</lang>
Salmon
Assuming /dev/lp0 accesses the printer:
<lang Salmon>open_output_text_file("/dev/lp0").print("Hello World!");</lang>
Assuming lpr is a command that prints to a printer: <lang Salmon>`echo "Hello World!" | lpr`;</lang>
Scala
All platforms
<lang scala>import java.awt.print.PrinterException import scala.swing.TextArea
object LinePrinter extends App {
val (show, context) = (false, "Hello, World!") try // Default Helvetica, 12p new TextArea(context) { append(" in printing.") peer.print(null, null, show, null, null, show) } catch { case ex: PrinterException => ex.getMessage() } println("Document printed.")
}</lang>
Unix
Assuming device is attached to lp0 <lang Scala>object LinePrinter extends App {
import java.io.{ FileWriter, IOException } { val lp0 = new FileWriter("/dev/lp0") lp0.write("Hello, world!") lp0.close() }
}</lang>
Scheme
Unix
Assuming device is attached to lp0 <lang scheme>(call-with-output-file "/dev/lp0" (lambda (printer) (write "Hello World!" printer)))</lang>
Seed7
Assuming that the line printer is attached to /dev/lp0: <lang seed7>$ include "seed7_05.s7i";
const proc: main is func
local var file: lp is STD_NULL; begin lp := open("/dev/lp0", "w"); writeln(lp, "Hello world!"); close(lp); end func;</lang>
Sidef
<lang ruby>Sys.open(\var fh, '>', '/dev/lp0')
&& fh.println("Hello World!") && fh.close;</lang>
Simula
<lang simula>BEGIN
OUTTEXT("Hello World!"); OUTIMAGE
END</lang>
SNOBOL4
In SNOBOL4, variables can be associated with input and output files. Assigning a value to an output-associated variable also writes it to the associated output file. (Likewise, accessing a variable associated with an input file returns as its value the next record from the associated input file.) By default, the variable "input" is associated with standard input, and the variable "output" is associated with standard output.
<lang SNOBOL4> output = "Hello, world."</lang>
You can associate the variable "print" with lpt1 (the default local printer port) using the output() function:
<lang SNOBOL4> output(.print,25,"lpt1")
print = "Hello, world."</lang>
Tcl
Unix
<lang tcl>exec lp << "Hello World!"</lang> <lang tcl>set f [open |lp w] puts $f "Hello World!" close $f</lang>
Windows
<lang tcl>set f [open prn w] puts $f "Hello World!" close $f</lang>
UNIX Shell
Use one of the following lines.
<lang bash># Use the default printer queue, with lp(1) or lpr(1).
- 1. The system must have a printer queue.
- 2. The printer queue must understand plain text.
- 3. System V has lp(1). BSD has lpr(1).
- CUPS has both lp(1) and lpr(1).
echo 'Hello World!' | lp echo 'Hello World!' | lpr
- Use a character device.
- 1. The device must understand plain text.
- 2. You must have write permission for the device.
- 3. Some systems have /dev/lp0, /dev/lp1, ...
- 4. BSD has /dev/lpt0, /dev/lpt1, ... for the parallel ports;
- and /dev/ulpt0, /dev/ulpt1, ... for the USB printers.
- Note that intermingling can occur if two processes write to the device at the
- same time. Using the print spooler method above avoids this problem,
echo 'Hello World!' >/dev/lp0 echo 'Hello World!' >/dev/lpt0 echo 'Hello World!' >/dev/ulpt0</lang>
XPL0
<lang XPL0>code Text=12; Text(2, "Hello World! ");</lang>
The 2 directs the output to the printer (LPT1). Output is usually directed to the console using device code 0 instead.
A carriage return and line feed are normally required to make a line printer actually print. (A laser or inkjet printer may require a form feed.) However, some printers, or printer drivers, have a timeout feature that print even without the CR+LF (or FF). The CR+LF can simply be included in the string as shown. Another method is to include the CR+LF control characters as ^M^J.
ERRE
<lang ERRE> ! Hello World in ERRE language PROGRAM HELLO BEGIN
!$REDIR PRINT("Hello World !") !NOREDIR
END PROGRAM </lang>
Prints on LPT1: (if exists) without opening a file
- Programming Tasks
- Solutions by Programming Task
- Hardware
- Printer
- PARI/GP/Omit
- ML/I/Omit
- Ada
- Applesoft BASIC
- AutoHotkey
- AWK
- BASIC
- Batch File
- BBC BASIC
- C
- C++
- C sharp
- Clipper
- COBOL
- D
- Delphi
- Factor
- Go
- Groovy
- GUISS
- Harbour
- Haskell
- Icon
- Unicon
- Integer BASIC
- J
- Java
- JavaScript
- Lasso
- Locomotive Basic
- Mathematica
- Wolfram Language
- MATLAB
- Octave
- Nimrod
- MIXAL
- OCaml
- OpenEdge/Progress
- Pascal
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- PostScript
- PureBasic
- PureLPRINT
- Python
- Racket
- REXX
- RPG
- Ruby
- Run BASIC
- Salmon
- Scala
- Scheme
- Seed7
- Sidef
- Simula
- SNOBOL4
- Tcl
- UNIX Shell
- XPL0
- ERRE