Hello world/Line printer: Difference between revisions
m
→{{header|Wren}}: Minor tidy
(Added X86 assembly example.) |
m (→{{header|Wren}}: Minor tidy) |
||
(27 intermediate revisions by 18 users not shown) | |||
Line 17:
With some systems, a line printer can be any device attached to an appropriate port (such as a parallel port).
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">V lp = File(‘/dev/lp0’, ‘w’)
lp.write("Hello World!\n")
lp.close()</syntaxhighlight>
=={{header|360 Assembly}}==
<
PRINT NOGEN
BALR 12,0
Line 31 ⟶ 38:
L1 DS 0CL133
HW DC C'Hello World!'
END HELLO</
=={{header|Action!}}==
<syntaxhighlight lang="action!">Proc Main()
Open(1,"P:",8,0)
PrintDE(1,"HELLO WORLD!")
Close(1)
Return
</syntaxhighlight>
=={{header|Ada}}==
===[[Unix]]===
Assuming that the line printer is attached to /dev/lp0
<syntaxhighlight lang="ada">
with Ada.Text_IO; use Ada.Text_IO;
Line 54 ⟶ 69:
Close (Printer);
end Print_Line;
</syntaxhighlight>
=={{header|ALGOL 68}}==
Line 62 ⟶ 77:
remote printer interfaced via CUPS. Extending it to other
environments is left as an exercise for the reader.
<
BEGIN
STRING printer name = "/dev/lp0";
Line 82 ⟶ 97:
FI
END
</
<pre>
Can't contact line printer on /dev/lp0
Line 92 ⟶ 107:
Assumes a printer card is installed in the Apple II's number 1 expansion slot.
<
PR#1
PRINT "HELLO WORLD!"
</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">write "/dev/lp0" "Hello World\n"</syntaxhighlight>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">
Fileappend, Hello World!, print.txt
Run, print "print.txt"
</syntaxhighlight>
=={{header|AWK}}==
Unix / Linux:
<syntaxhighlight lang="awk">
BEGIN { print("Hello World!") >"/dev/lp0" }
</syntaxhighlight>
=={{header|BASIC}}==
{{works with|GW-BASIC}}
{{works with|QBasic}}
{{works with|MSX BASIC}}
{{works with|ZX Spectrum Basic}}
{{works with|Liberty BASIC}}
<syntaxhighlight lang="qbasic">LPRINT "Hello World!"</syntaxhighlight>
==={{header|BaCon}}===
Piping data to ''lp'' would also work. This example demonstrates writing to a device.
<
READ msg$
DATA "Hello World!\n"
Line 128 ⟶ 144:
OPEN "/dev/lp0" FOR DEVICE AS printer
PUTBYTE msg$ TO printer SIZE LEN(msg$)
CLOSE DEVICE printer</
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">printeron
font "Arial", 20, 50
text 10,100, "Hello World!"
printeroff</syntaxhighlight>
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> prn% = OPENOUT("PRN:")
PRINT #prn%, "Hello World!"
CLOSE #prn%</syntaxhighlight>
==={{header|GW-BASIC}}===
{{works with|BASICA}}
{{works with|PC-BASIC}}
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">LPRINT "Hello World!"</syntaxhighlight>
==={{header|IS-BASIC}}===
<
==={{header|
<syntaxhighlight lang="qbasic">LPRINT "Hello World!"</syntaxhighlight>
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">OPEN #1: PRINTER !Open channel #1 for the printer
PRINT #1: "Hello World!"
END</syntaxhighlight>
==={{header|
<syntaxhighlight lang="yabasic">open window 100,100
open printer
text 10,
close printer
close window</syntaxhighlight>
=={{header|Batch File}}==
<syntaxhighlight lang="dos">ECHO Hello world!>PRN</syntaxhighlight>
=={{header|C}}==
===[[Unix]]===
Assuming that the line printer is attached to /dev/lp0
<
int main()
Line 155 ⟶ 197:
fclose(lp);
return 0;
}</
=={{header|C sharp}}==
Line 162 ⟶ 204:
which is out of scope of this example.
<
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public class DOCINFOA
Line 222 ⟶ 264:
ClosePrinter(hPrinter);
}
}</
=={{header|C++}}==
<
#include <fstream>
Line 234 ⟶ 276:
lprFile.close();
return 0;
}</
=={{header|Clipper}}==
<
SET CONSOLE OFF
? "Hello World!"
SET PRINT OFF
SET CONSOLE ON
</syntaxhighlight>
=={{header|Clojure}}==
Translated from Java (mechanically, as I don't understand how to test a line printer):
<
(:import java.io.FileWriter))
(defn -main [& args]
(with-open [wr (new FileWriter "/dev/lp0")]
(.write wr "Hello, World!")))</
=={{header|COBOL}}==
<
PROGRAM-ID. GOODBYE-WORLD-PRINTER.
Line 261 ⟶ 303:
UPON PRINTER
END-DISPLAY.
STOP RUN.</
=={{header|Commodore BASIC}}==
Most Commodore printer peripherals operate off the IEC bus commonly as device 4 or 5. It is also possible that some printers may be connected through the RS-232 serial port (typically device 2). This example assumes a device on the IEC bus with a default setting of device 4. This example does not utilize any printer control codes to change font, pitch, quality, graphics, etc., as those can vary between brands and models of printer.
<syntaxhighlight lang="commodorebasicv2">
10 rem rosetta code - "Hello World" on line printer
20 open 7,4 : rem open <logical file number>, <device number>
30 print#7,"hello world!" : rem print line as shown to logical file number
40 close 7 : rem close the file number
</syntaxhighlight>
=={{header|Common Lisp}}==
Assuming that the line printer is attached to /dev/lp0
<
(with-open-file (stream "/dev/lp0"
:direction :output
Line 282 ⟶ 324:
(format stream "Hello World~%")))
(main)
</syntaxhighlight>
=={{header|D}}==
<
void main()
Line 292 ⟶ 334:
lp.writeln("Hello World!");
}
</syntaxhighlight>
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 308 ⟶ 350:
Writeln(lPrinterAsTextFile, 'Hello World!');
CloseFile(lPrinterAsTextFile);
end.</
=={{header|Diego}}==
Once the caller has met the computer and its printer...
<syntaxhighlight lang="diego">with_computer(comp1)_printer(lp1)_text(Hello World!);</syntaxhighlight>
If the caller is the computer...
<syntaxhighlight lang="diego">with_printer(lp1)_text(Hello World!);</syntaxhighlight>
=={{header|Dragon}}==
<
select "files"
Line 319 ⟶ 367:
flush(f2)
fclose(f2)
</syntaxhighlight>
=={{header|EchoLisp}}==
EchoLisp supports a virtual printer which is not stdout. It is actually an extensible division of the HTML document, with printer pages as subdivisions. Printer and pages may be hidden/shown at convenience.
<
(printer-font "Courier") ;; change printer font
(printer-page "ROSETTA CODE") ;; starts a new page with nice header
(printer-writeln "Hello World!") ;; prints new line (not seen on stdout)
</syntaxhighlight>
=={{header|EDSAC order code}}==
This program uses self-modifying code to loop through an array of characters. Since the EDSAC character set does not include lower-case letters or exclamation marks, we actually print <tt>HELLO WORLD</tt> followed by a carriage return and a line feed. Strings cannot be null-terminated, because 0 happens to be the character code for <tt>P</tt>; instead, we mark the final character by including a 1 (which has no printable effect) in the least significant bit.
<
===========
Line 391 ⟶ 439:
&D [ Line feed + 1 ]
EZPF</
=== Alternative ===
As noted, null in the sense of zero cannot be used as a string terminator on EDSAC. However, it is possible to use the EDSAC null, whose 5-bit code is 10000. The subroutine below demonstrates this.
After the string characters, the terminating null is also sent to the teleprinter. This is because the teleprinter had a one-character buffer, so that an O order did not print its own character immediately, but stored it in the buffer and printed the character set up by the previous O order (Wilkes, Wheeler & Gill, 1951 edition, page 50). Sending the terminating null to the teleprinter ensures that the last character of the string is printed at the same time as the rest.
The EDSAC PC simulator allows .F for null and *F for letter shift, but it seems from WWG that on the original EDSAC these had to be input as K4096F and K2048F respectively.
<syntaxhighlight lang="edsac">
[Alternative "Hello World" for Rosetta Code]
[Subroutine to print a string.]
[Parameter: A order for first character follows subroutine call (G order).]
[Modified 2022-07-13: A order for first character was formerly passed in 0F.]
[String is terminated with EDSAC null, which is printed]
T56K GK [load at 56; set relative addressing]
A18@ U17@ [plant return link, increasing address by 3
instead of 2 as usual]
S19@ [make A order to load A order after subroutine call]
T4@ [plant in code]
[4] AF [(planted) load A order after subroutine call]
[5] T6@ [loop: plant A order for next character]
[6] AF [load next character]
UF [to 0F for printing; keep it in acc]
OF [output to teleprinter]
E12@ [if char >= 0, not EDSAC null]
A20@ [if char < 0, add 15 to test for EDSAC null]
G16@ [jump to exit if null]
[12] TF [clear acc]
A6@ A2F [inc address in A order above]
G5@ [loop back, because top 5 bits = A = 11100]
[16] TF [clear acc on exit (EDSAC convention)]
[17] ZF [(planted) jump back to caller]
[18] U3F [constant for making return link]
[19] U1F [constant for picking up parameter]
[20] K2048F [constant for testing final null]
[Main routine]
T96K GK [load at 96; set relative addressing
[Enter with acc = 0]
[0] A@ G56F [call print subroutine]
A4@ [A order for first character of string]
ZF [subroutine returns here; halt machine]
[4] K2048F HF EF LF LF OF !F WF OF RF LF DF @F &F K4096F
[The above string is: letter shift, 'HELLO WORLD', CR, LF, null]
EZ [define entry point]
PF [acc = 0 on entry]
[end]
</syntaxhighlight>
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
! Hello World in ERRE language
PROGRAM HELLO
Line 402 ⟶ 498:
!$NOREDIR
END PROGRAM
</syntaxhighlight>
Prints on LPT1: (if exists) without opening a file.
Line 411 ⟶ 507:
Prints through Unix "lpr" command.
<
( scratchpad ) USE: io.launcher
( scratchpad ) "lpr" utf8 [ "Hello World!" print ] with-process-writer</
=={{header|Forth}}==
Forth systems currently run on everything from bare metal to modern multi-user operating systems and printers are handled differently on each. This demonstration shows a common way that text output is re-directed to printers and/or other devices by vectoring the action of the Forth word EMIT. Emit takes one character off the stack and outputs it to a device. By defining all I/O with the primitive operation EMIT, we can vector the output anywhere we choose, even on hardware with no O/S. Here we show a very basic printer device driver for an embedded system that adds I/O re-direction to the system's Forth language.
<
defer emit \ deferred words in Forth are a place holder for an
Line 442 ⟶ 538:
\ vector control words
: >console ['] console-emit is EMIT ; \ assign the execution token of console-emit to EMIT
: >printer ['] printer-emit is EMIT ; \ assign the execution token of printer-emit to EMIT</
Usage Examples:
Line 466 ⟶ 562:
Since for a new job, output would commence with the lineprinter already at the top of a new page, an overprint (no carriage advance) thus means writing to the very first line. If however, top-of-page placement was not assured at your installation, then "1HELLO WORLD!" would do.
<
1 FORMAT ("+HELLO WORLD!")
END </
=={{header|FreeBASIC}}==
<
Open Lpt "Lpt:" As #1 '' prints to default printer
Print #1, "Hello World!"
Close #1</
=={{header|FutureBasic}}==
The legacy lprint statemenet sends a line of text to the printer. The @(col,row) and %(h,v) options specify where on the page the line should be printed (see the print statement); if you don't specify one of these, the line is printed at the current pen position, usually just under the previously-printed line. lprint is inefficient if you are printing many lines to a page because it reroutes the output each time lprint is executed. In such cases, it's better to execute a sequence of print statements, with the entire sequence preceded by a single route _toPrinter statement and followed by a single route _toScreen statement. FB progammers today use much more sophisticated printer functions designed for complex pagination.
<syntaxhighlight lang="futurebasic">
// lprint [@(col,row)|%(h,v)] "Hello,World!"
lprint "Hello,World!"
route _toScreen
close lprint
</syntaxhighlight>
=={{header|Go}}==
<
import (
Line 495 ⟶ 600:
fmt.Fprintln(lp0, "Hello World!")
}</
=={{header|Groovy}}==
<
</syntaxhighlight>
=={{header|GUISS}}==
<
Menu:File,Print,Button:OK</
=={{header|Harbour}}==
<
SET CONSOLE OFF
? "Hello World!"
SET PRINT OFF
SET CONSOLE ON</
=={{header|Haskell}}==
<
main :: IO ProcessHandle
main = runCommand "echo \"Hello World!\" | lpr"</
=={{header|Icon}} and {{header|Unicon}}==
Line 523 ⟶ 628:
Works in both languages, provided printer is attached to <tt>/dev/lp0</tt>.
<
write(open("/dev/lp0","w"),"Hello, world!")
end</
=={{header|Integer BASIC}}==
Line 533 ⟶ 638:
=={{header|J}}==
<
print'Hello world!'</
=={{header|Java}}==
<
import java.io.IOException;
Line 551 ⟶ 656:
}
}
}</
=={{header|JavaScript}}==
{{works with|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);</
{{works with|Firefox}}
{{works with|Chromium}}
<
document.write("Hello World!");
print(); //Opens a dialog.
</syntaxhighlight>
=={{header|Joy}}==
<syntaxhighlight lang="joy">"/dev/lp" "w" fopen "Hello World!\n" fputchars fclose.</syntaxhighlight>
=={{header|Julia}}==
<
lineprinter = Sys.iswindows() ? "LPT3" : "/dev/lp0"
lp = open(lineprinter, "w")
write(lp, "Hello world")
</syntaxhighlight>
=={{header|Kotlin}}==
{{Works with|Ubuntu|14.04}}
<
fun main(args: Array<String>) {
val text = "Hello World!\n"
File("/dev/lp0").writeText(text)
}</
=={{header|Lasso}}==
<
=={{header|Locomotive Basic}}==
<
=={{header|M2000 Interpreter}}==
We can use printer like a page printer
<syntaxhighlight lang="m2000 interpreter">
Printer {
\\ just change the current layer to Print Page
Line 600 ⟶ 708:
Print "Hello World!"
}
</syntaxhighlight>
Or we can use ANSI output using a file for export in Lpt1
<syntaxhighlight lang="m2000 interpreter">
Try ok {
Open "Lpt1" For OutPut As N '' prints to Lpt1 if exist a printer
Line 611 ⟶ 719:
}
If Not Ok Then Print "Can't Print"
</syntaxhighlight>
If we have a file in current dir we can use a Dos command:
<syntaxhighlight lang="m2000 interpreter">
Dos "Print /d:lpt1 file " +quote$(dir$+"this.txt");
</syntaxhighlight>
Using ; at the end of DOS command we have no open terminal
<syntaxhighlight lang="m2000 interpreter">
Dos "command" [, sleep time after call] [;]
</syntaxhighlight>
=={{header|Maple}}==
<
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
Run[commandstring]</
=={{header|MATLAB}} / {{header|Octave}}==
===[[Unix]]===
Assuming that the line printer is attached to /dev/lp0
<
fprintf(fid,'Hello World!\n');
fclose(fid);</
=={{header|MIXAL}}==
<syntaxhighlight lang="mixal">
LPR EQU 18
STRING EQU 2000
Line 650 ⟶ 758:
ALF D!
END START
</syntaxhighlight>
=={{header|N/t/roff}}==
Line 665 ⟶ 773:
Because /.ROFF/ is a document formatting language, the majority of lines in a typical /.ROFF/ source file is to be textual input. This input is typeset directly onto the output medium. Therefore, the user need not call a procedure to print text to any terminal.
<
Hello World!
</syntaxhighlight>
=={{header|Nim}}==
Assuming that the line printer is attached to /dev/lp0:
<
lp.
lp.close()</
=={{header|OCaml}}==
Assuming that the line printer is attached to /dev/lp0
<
let oc = open_out "/dev/lp0" in
output_string oc "Hello world!\n";
close_out oc ;;</
=={{header|Oforth}}==
<
=={{header|Ol}}==
<syntaxhighlight lang="scheme">
(define p (open-output-file "/dev/lp0"))
(when p
(print-to p "Hello world!")
(close-port p))
</syntaxhighlight>
=={{header|OpenEdge/Progress}}==
<
PUT UNFORMATTED "Hello world!" SKIP.
OUTPUT CLOSE.</
=={{header|Pascal}}==
Line 694 ⟶ 810:
{{libheader|Printer}}
Example from the FreePascal documentation:
<
uses printer;
var i: integer;
Line 714 ⟶ 830:
writeln ( 'Done.' )
{$endif}
end.</
=={{header|Perl}}==
Assuming that the line printer is attached to /dev/lp0
<
print O "Hello World!\n";
close O;</
=={{header|Phix}}==
If you have not got something appropriate attached, this will just hang. Other values you can try, on windows: "AUX", "COM1", "COM2", "LPT1"
<!--<syntaxhighlight lang="phix">-->
<span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()=</span><span style="color: #000000;">WIN32</span><span style="color: #0000FF;">?</span><span style="color: #008000;">"PRN"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"/dev/lp0"</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"w"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">fn</span><span style="color: #0000FF;">=-</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"some error"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">else</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Hello World!"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"success!"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #0000FF;">{}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>
<!--</syntaxhighlight>-->
=={{header|PHP}}==
<
file_put_contents('/dev/lp0', 'Hello world!');
?></
<
fclose(STDOUT);
$STDOUT = fopen('/dev/lp0', 'a');
echo 'Hello world!';
?></
=={{header|Picat}}==
{{works with|Picat}}
<syntaxhighlight lang="picat">
main =>
Printer = open("/dev/lp0", write),
println(Printer, "Hello, world!"),
flush(Printer),
close(Printer).
</syntaxhighlight>
=={{header|PicoLisp}}==
<
(prinl "Hello world") )</
=={{header|PL/I}}==
<
hello: procedure options(main);
put skip list('Hello world.');
end hello;</
=={{header|PostScript}}==
Technically not really correct, as this has to be sent to the printer directly.
It will output Hello world, then, though.
<
/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</
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<syntaxhighlight lang="prolog">
:- initialization(main).
main :-
open("/dev/lp0", write, Printer),
writeln(Printer, "Hello, world!"),
flush_output(Printer),
close(Printer).
</syntaxhighlight>
=={{header|PureBasic}}==
{{libheader|PureLPRINT}}
<
If LPRINT_OpenPrinter(MyPrinter$)
If LPRINT_StartDoc("Printing a RC-Task")
Line 775 ⟶ 915:
EndIf
LPRINT_ClosePrinter()
EndIf</
=={{header|Python}}==
Assuming that the line printer is attached to /dev/lp0:
<
lp.write("Hello World!\n")
lp.close()</
If the above code gives you the error "IOError: File not open for writing", try:
<
lp.write("Hello World!\n")
lp.close()</
=={{header|Racket}}==
<
#lang racket
(define (print text)
Line 802 ⟶ 942:
(λ() (displayln text)))))
(print "Hello World!")
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku"
$lp.say: 'Hello World!';
$lp.close;</
Or using <code>given</code> to avoid having to write the variable name repeatedly:
<syntaxhighlight lang="raku"
.say: 'Hello World!';
.close;
}</
=={{header|REXX}}==
Line 822 ⟶ 962:
but a shell command could be used.
<br><br>In DOS (or under Windows):
<
$= 'Hello World!' /*define a string to be used for output*/
'@ECHO' $ ">PRN" /*stick a fork in it, we're all done. */</
=={{header|Ring}}==
<
lp = fopen("/dev/lp0","w") fputs(lp,"Hello world!") fclose(lp)
</syntaxhighlight>
=={{header|RPG}}==
{{works with|ILE RPG}}
<syntaxhighlight lang="rpg">
Fqsysprt O F 80 printer
C except
Line 839 ⟶ 979:
Oqsysprt E
O 11 'Hello world'
</syntaxhighlight>
=={{header|RPL}}==
"Hello world!" PR1
=={{header|Ruby}}==
Assumes that <code>lpr</code> command reaches printer.
<
=={{header|Run BASIC}}==
<
=={{header|Rust}}==
===Unix===
<
use std::io::Write;
Line 857 ⟶ 1,000:
let file = OpenOptions::new().write(true).open("/dev/lp0").unwrap();
file.write(b"Hello, World!").unwrap();
}</
=={{header|Salmon}}==
Assuming /dev/lp0 accesses the printer:
<
Assuming lpr is a command that prints to a printer:
<
=={{header|Scala}}==
{{libheader|Scala}}
===All platforms===
<
import scala.swing.TextArea
Line 884 ⟶ 1,027:
}
println("Document printed.")
}</
===[[Unix]]===
Assuming device is attached to lp0
<
import java.io.{ FileWriter, IOException }
{
Line 895 ⟶ 1,038:
lp0.close()
}
}</
=={{header|Scheme}}==
===[[Unix]]===
Assuming device is attached to lp0
<
(lambda (printer)
(write "Hello World!" printer)))</
=={{header|Seed7}}==
Assuming that the line printer is attached to /dev/lp0:
<
const proc: main is func
Line 915 ⟶ 1,058:
writeln(lp, "Hello world!");
close(lp);
end func;</
=={{header|Sidef}}==
<
&& fh.say("Hello World!") \
&& fh.close</
=={{header|Simula}}==
{{works with|SIMULA-67}}
<
OUTTEXT("Hello World!");
OUTIMAGE
END</
=={{header|Slope}}==
<syntaxhighlight>(file-append-to "/dev/lp0" "Hello world!")</syntaxhighlight>
=={{header|Smalltalk}}==
{{works with|Smalltalk/X}}
portable (dispatches to one of bellow):
<syntaxhighlight lang="smalltalk">s := PrinterStream defaultPrinter new.
s nextPutLine:'Hello, world'.
s close</syntaxhighlight>
===[[Unix]]===
<syntaxhighlight lang="smalltalk">s := PipeStream writingTo:'lpr'.
s nextPutLine:'Hello, world'.
s close.</syntaxhighlight>
alternative:
<syntaxhighlight lang="smalltalk">'/dev/lp0' asFilename writingFileDo:[:s |
s nextPutLine:'Hello, world'.
]</syntaxhighlight>
===[[Windows]]===
<syntaxhighlight lang="smalltalk">s := WinPrinterStream new.
s nextPutLine:'Hello, world'.
s close.</syntaxhighlight>
=={{header|SNOBOL4}}==
Line 935 ⟶ 1,100:
By default, the variable "input" is associated with standard input, and the variable "output" is associated with standard output.
<
You can associate the variable "print" with lpt1 (the default local printer port) using the output() function:
<
print = "Hello, world."</
=={{header|Swift}}==
<
let out = NSOutputStream(toFileAtPath: "/dev/lp0", append: true)
Line 949 ⟶ 1,114:
out?.open()
out?.write(UnsafePointer<UInt8>(data!.bytes), maxLength: data!.length)
out?.close()</
=={{header|Tcl}}==
===[[Unix]]===
<
<
puts $f "Hello World!"
close $f</
===[[Windows]]===
<
puts $f "Hello World!"
close $f</
=={{header|UNIX Shell}}==
Use ''one'' of the following lines.
<
# 1. The system must have a printer queue.
# 2. The printer queue must understand plain text.
Line 988 ⟶ 1,153:
echo 'Hello World!' >/dev/lp0
echo 'Hello World!' >/dev/lpt0
echo 'Hello World!' >/dev/ulpt0</
=={{header|Wisp}}==
===[[Unix]]===
Assuming that the device is attached to lp0
<syntaxhighlight lang="wisp">call-with-output-file "/dev/lp0"
λ : printer
write "Hello World!" printer</syntaxhighlight>
=={{header|Wren}}==
It is not currently possible to communicate with the printer using Wren-cli. So we need to write a minimal embedded program (no error checking) so the C host can do this for us.
<syntaxhighlight lang="wren">/* Hello_world_Line_printer.wren */
class C {
foreign static lprint(s)
}
C.lprint("Hello World!")</syntaxhighlight>
<br>
We now embed this in the following C program, compile and run it.
<syntaxhighlight lang="c">/* gcc Hello_world_Line_printer.c -o Hello_world_Line_printer -lwren -lm */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "wren.h"
/* C <=> Wren interface functions */
void C_lprint(WrenVM* vm) {
const char *arg = wrenGetSlotString(vm, 1);
char command[strlen(arg) + 13];
strcpy(command, "echo \"");
strcat(command, arg);
strcat(command, "\" | lp");
system(command);
}
WrenForeignMethodFn bindForeignMethod(
WrenVM* vm,
const char* module,
const char* className,
bool isStatic,
const char* signature) {
if (strcmp(module, "main") == 0) {
if (strcmp(className, "C") == 0) {
if (isStatic && strcmp(signature, "lprint(_)") == 0) return C_lprint;
}
}
return NULL;
}
static void writeFn(WrenVM* vm, const char* text) {
printf("%s", text);
}
char *readFile(const char *fileName) {
FILE *f = fopen(fileName, "r");
fseek(f, 0, SEEK_END);
long fsize = ftell(f);
rewind(f);
char *script = malloc(fsize + 1);
fread(script, 1, fsize, f);
fclose(f);
script[fsize] = 0;
return script;
}
int main(int argc, char **argv) {
WrenConfiguration config;
wrenInitConfiguration(&config);
config.writeFn = &writeFn;
config.bindForeignMethodFn = &bindForeignMethod;
WrenVM* vm = wrenNewVM(&config);
const char* module = "main";
const char* fileName = "Hello_world_Line_printer.wren";
char *script = readFile(fileName);
WrenInterpretResult result = wrenInterpret(vm, module, script);
wrenFreeVM(vm);
free(script);
return 0;
}</syntaxhighlight>
=={{header|X86 Assembly}}==
<
;assume direction bit is clear (so si increments)
.model tiny
Line 1,008 ⟶ 1,254:
msg db "Hello World!", 0ch, 0 ;0ch = form feed (for laser printer)
end start</
=={{header|XPL0}}==
<
Text(2, "Hello World!
");</
The 2 directs the output to the printer (LPT1).
|