Hello world/Line printer: Difference between revisions

{{trans|Python}}

 

lp.write("Hello World!\n")

 

=={{header|360 Assembly}}==

PRINT NOGEN

BALR 12,0

L1 DS 0CL133

HW DC C'Hello World!'

 

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

Open(1,"P:",8,0)

PrintDE(1,"HELLO WORLD!")

Close(1)

Return

 

=={{header|Ada}}==

===[[Unix]]===

Assuming that the line printer is attached to /dev/lp0

with Ada.Text_IO; use Ada.Text_IO;

 

Close (Printer);

end Print_Line;

 

=={{header|ALGOL 68}}==

remote printer interfaced via CUPS. Extending it to other

environments is left as an exercise for the reader.

BEGIN

STRING printer name = "/dev/lp0";

FI

END

<pre>

Can't contact line printer on /dev/lp0

Assumes a printer card is installed in the Apple II's number 1 expansion slot.

 

PR#1

PRINT "HELLO WORLD!"

 

=={{header|AutoHotkey}}==

Fileappend, Hello World!, print.txt

Run, print "print.txt"

 

=={{header|AWK}}==

Unix / Linux:

BEGIN { print("Hello World!") >"/dev/lp0" }

 

=={{header|BASIC}}==

{{works with|QBasic}}

{{works with|ZX Spectrum Basic}}

{{works with|Liberty BASIC}}

 

==={{header|BaCon}}===

Piping data to ''lp'' would also work. This example demonstrates writing to a device.

READ msg$

DATA "Hello World!\n"

OPEN "/dev/lp0" FOR DEVICE AS printer

PUTBYTE msg$ TO printer SIZE LEN(msg$)

 

==={{header|IS-BASIC}}===

 

 

 

 

=={{header|C}}==

===[[Unix]]===

Assuming that the line printer is attached to /dev/lp0

 

int main()

fclose(lp);

return 0;

 

=={{header|C sharp}}==

which is out of scope of this example.

 

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]

public class DOCINFOA

ClosePrinter(hPrinter);

}

 

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

#include <fstream>

 

lprFile.close();

return 0;

 

=={{header|Clipper}}==

SET CONSOLE OFF

? "Hello World!"

SET PRINT OFF

SET CONSOLE ON

 

=={{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")]

 

=={{header|COBOL}}==

PROGRAM-ID. GOODBYE-WORLD-PRINTER.

 

UPON PRINTER

END-DISPLAY.

 

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

 

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

 

 

=={{header|Common Lisp}}==

Assuming that the line printer is attached to /dev/lp0

(with-open-file (stream "/dev/lp0"

:direction :output

(format stream "Hello World~%")))

(main)

 

=={{header|D}}==

 

void main()

lp.writeln("Hello World!");

}

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln(lPrinterAsTextFile, 'Hello World!');

CloseFile(lPrinterAsTextFile);

 

=={{header|Dragon}}==

select "files"

 

flush(f2)

fclose(f2)

 

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

 

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

===========

 

&D [ Line feed + 1 ]

 

 

=={{header|ERRE}}==

! Hello World in ERRE language

PROGRAM HELLO

!$NOREDIR

END PROGRAM

 

Prints on LPT1: (if exists) without opening a file.

Prints through Unix "lpr" command.

 

( scratchpad ) USE: io.launcher

 

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

\ vector control words

: >console ['] console-emit is EMIT ; \ assign the execution token of console-emit to EMIT

 

Usage Examples:

 

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!")

 

=={{header|FreeBASIC}}==

 

Open Lpt "Lpt:" As #1 '' prints to default printer

Print #1, "Hello World!"

 

=={{header|Go}}==

 

import (

 

fmt.Fprintln(lp0, "Hello World!")

 

=={{header|Groovy}}==

 

=={{header|GUISS}}==

 

 

=={{header|Harbour}}==

SET CONSOLE OFF

? "Hello World!"

SET PRINT OFF

 

=={{header|Haskell}}==

 

main :: IO ProcessHandle

 

=={{header|Icon}} and {{header|Unicon}}==

Works in both languages, provided printer is attached to <tt>/dev/lp0</tt>.

 

write(open("/dev/lp0","w"),"Hello, world!")

 

=={{header|Integer BASIC}}==

=={{header|J}}==

 

 

=={{header|Java}}==

 

import java.io.IOException;

}

}

 

=={{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');

{{works with|Firefox}}

{{works with|Chromium}}

document.write("Hello World!");

print(); //Opens a dialog.

 

=={{header|Julia}}==

lineprinter = Sys.iswindows() ? "LPT3" : "/dev/lp0"

lp = open(lineprinter, "w")

write(lp, "Hello world")

 

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

Printer {

\\ just change the current layer to Print Page

Print "Hello World!"

}

 

Or we can use ANSI output using a file for export in Lpt1

 

Try ok {

Open "Lpt1" For OutPut As N '' prints to Lpt1 if exist a printer

}

If Not Ok Then Print "Can't Print"

 

If we have a file in current dir we can use a Dos command:

Dos "Print /d:lpt1 file " +quote$(dir$+"this.txt");

Using ; at the end of DOS command we have no open terminal

 

Dos "command" [, sleep time after call] [;]

 

=={{header|Maple}}==

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|MATLAB}} / {{header|Octave}}==

===[[Unix]]===

Assuming that the line printer is attached to /dev/lp0

fprintf(fid,'Hello World!\n');

 

=={{header|MIXAL}}==

LPR EQU 18

STRING EQU 2000

ALF D!

END START

 

=={{header|N/t/roff}}==

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!

 

=={{header|Nim}}==

Assuming that the line printer is attached to /dev/lp0:

 

=={{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";

 

=={{header|Oforth}}==

 

=={{header|Ol}}==

(define p (open-output-file "/dev/lp0"))

(when p

(print-to p "Hello world!")

(close-port p))

 

=={{header|OpenEdge/Progress}}==

PUT UNFORMATTED "Hello world!" SKIP.

 

=={{header|Pascal}}==

{{libheader|Printer}}

Example from the FreePascal documentation:

uses printer;

var i: integer;

writeln ( 'Done.' )

{$endif}

 

=={{header|Perl}}==

Assuming that the line printer is attached to /dev/lp0

print O "Hello World!\n";

 

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

<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: #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>

 

=={{header|PHP}}==

file_put_contents('/dev/lp0', 'Hello world!');

 

fclose(STDOUT);

$STDOUT = fopen('/dev/lp0', 'a');

echo 'Hello world!';

 

=={{header|PicoLisp}}==

 

=={{header|PL/I}}==

hello: procedure options(main);

put skip list('Hello world.');

 

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

 

=={{header|PureBasic}}==

{{libheader|PureLPRINT}}

If LPRINT_OpenPrinter(MyPrinter$)

If LPRINT_StartDoc("Printing a RC-Task")

EndIf

LPRINT_ClosePrinter()

 

=={{header|Python}}==

Assuming that the line printer is attached to /dev/lp0:

lp.write("Hello World!\n")

 

If the above code gives you the error "IOError: File not open for writing", try:

lp.write("Hello World!\n")

 

=={{header|Racket}}==

 

#lang racket

(define (print text)

(λ() (displayln text)))))

(print "Hello World!")

 

=={{header|Raku}}==

(formerly Perl 6)

 

$lp.say: 'Hello World!';

 

Or using <code>given</code> to avoid having to write the variable name repeatedly:

 

.say: 'Hello World!';

.close;

 

=={{header|REXX}}==

but a shell command could be used.

<br><br>In DOS (or under Windows):

$= 'Hello World!' /*define a string to be used for output*/

 

=={{header|Ring}}==

lp = fopen("/dev/lp0","w") fputs(lp,"Hello world!") fclose(lp)

 

=={{header|RPG}}==

{{works with|ILE RPG}}

Fqsysprt O F 80 printer

C except

Oqsysprt E

O 11 'Hello world'

 

=={{header|Ruby}}==

Assumes that <code>lpr</code> command reaches printer.

 

 

=={{header|Run BASIC}}==

 

=={{header|Rust}}==

===Unix===

use std::io::Write;

 

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

 

}

println("Document printed.")

 

===[[Unix]]===

Assuming device is attached to lp0

import java.io.{ FileWriter, IOException }

{

lp0.close()

}

 

=={{header|Scheme}}==

===[[Unix]]===

Assuming device is attached to lp0

  (lambda (printer)

 

=={{header|Seed7}}==

Assuming that the line printer is attached to /dev/lp0:

const proc: main is func

writeln(lp, "Hello world!");

close(lp);

 

=={{header|Sidef}}==

&& fh.say("Hello World!") \

 

=={{header|Simula}}==

{{works with|SIMULA-67}}

OUTTEXT("Hello World!");

OUTIMAGE

 

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

portable (dispatches to one of bellow):

s nextPutLine:'Hello, world'.

===[[Unix]]===

s nextPutLine:'Hello, world'.

alternative:

s nextPutLine:'Hello, world'.

===[[Windows]]===

s nextPutLine:'Hello, world'.

 

=={{header|SNOBOL4}}==

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:

 

 

=={{header|Swift}}==

 

let out = NSOutputStream(toFileAtPath: "/dev/lp0", append: true)

out?.open()

out?.write(UnsafePointer<UInt8>(data!.bytes), maxLength: data!.length)

 

=={{header|Tcl}}==

 

===[[Unix]]===

puts $f "Hello World!"

 

===[[Windows]]===

 

puts $f "Hello World!"

 

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

echo 'Hello World!' >/dev/lp0

echo 'Hello World!' >/dev/lpt0

 

=={{header|Wisp}}==

===[[Unix]]===

Assuming that the device is attached to lp0

λ : printer

 

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

 

class C {

}

 

<br>

We now embed this in the following C program, compile and run it.

 

#include <stdio.h>

WrenVM* vm = wrenNewVM(&config);

const char* module = "main";

char *script = readFile(fileName);

WrenInterpretResult result = wrenInterpret(vm, module, script);

free(script);

return 0;

 

=={{header|X86 Assembly}}==

;assume direction bit is clear (so si increments)

.model tiny

 

msg db "Hello World!", 0ch, 0 ;0ch = form feed (for laser printer)

 

=={{header|XPL0}}==

Text(2, "Hello World!

 

The 2 directs the output to the printer (LPT1).