Terminal control/Clear the screen: Difference between revisions
Terminal control/Clear the screen (view source)
Revision as of 11:44, 13 February 2024
, 3 months ago→{{header|Wren}}: Changed to Wren S/H
(Add Seed7 example) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
| (154 intermediate revisions by more than 100 users not shown) | |||
Line 1:
{{task|Terminal control}}
[[Category:Initialization]]
;Task:
Clear the terminal window.
<br><br>
=={{header|11l}}==
{{trans|Python}}
To clear the screen on Windows, replace 'clear' with 'cls'
<syntaxhighlight lang="11l">os:(‘clear’)</syntaxhighlight>
=={{header|6502 Assembly}}==
===Commodore 64===
{{works with|http://vice-emu.sourceforge.net/ VICE}}
This example has been written for the C64 and uses the CHROUT KERNEL routine.
Compile with the [http://turbo.style64.org/ Turbo Macro Pro cross assembler]:
<pre>
tmpx -i clrscr.s -o bin/clrscr.prg
</pre>
Run with:
<pre>
SYS680
</pre>
<syntaxhighlight lang="6502asm">; C64 - Terminal control: Clear the screen
; *** labels ***
chrout = $ffd2
; *** main ***
*=$02a8 ; sys 680
lda clr ; A = {CLR}
jsr chrout ; Output a character in A to the current
; output device (default: screen).
rts
; *** data ***
clr .byte $93 ; the CLR control code
; see https://en.wikipedia.org/wiki/PETSCII
</syntaxhighlight>
===6502js/6502asm/easy6502===
{{works with|http://www.6502asm.com/ 6502asm.com|1.2}}
{{works with|http://www.6502asm.com/beta/index.html 6502asm.com|1.5 beta}}
The 6502asm.com emulator has a 32x32 pixel screen. First we fill this screen with random colored pixels, wait for a keypress and then "clear" the screen (fill it with black pixels).
<syntaxhighlight lang="6502asm">; 6502asm.com - Clear the screen
lda #$00 ; store the start address of the screen ($200)
sta $00 ; at $00 and $01 (high byte in $01)
lda #$02
sta $01
ldy #$00 ; Y = 0
fillscreen:
lda $fe ; A = random number from $fe
sta ($00),y ; put pixel (random color) to the screen
iny ; Y++
bne fillscreen ; loop if Y!=0
inc $01 ; increase address high byte
lda $01
cmp #$06 ; A==6? (screen ends at $05ff)
bne fillscreen ; no -> loop
waitforkeypress:
lda $ff ; $ff is 0 if no key has been pressed
beq waitforkeypress
ldx #$00
lda #$00 ; black
clearscreen:
sta $0200,x
sta $0300,x
sta $0400,x
sta $0500,x
inx
bne clearscreen
</syntaxhighlight>
===Nintendo Entertainment System===
It's best to do this during forced blank (i.e. display is inactive), as this loop is most likely too slow to finish before vBlank is over. This code assumes that your game's character ROM has a "blank" tile at tile index $00. If it doesn't, use whatever index you consider to be a "blank tile." Also, this only clears the top-left nametable, which is all the user can see if no scrolling has taken place. If the scroll position of the screen isn't (0,0), there will still be graphics left over on screen.
<syntaxhighlight lang="6502asm">clearVRAM:
PHA
LDA #$20 ;load the vram address of the top-left nametable
STA $2006
LDA #$00
STA $2006
PLA
LDX #$04 ;we've got $400 bytes to clear.
LDY #$00
loop:
STA $2007 ;write the tile, vram auto-incs.
DEY
BNE loop
DEX
BNE loop
RTS</syntaxhighlight>
=={{header|68000 Assembly}}==
===Neo Geo MVS===
The following will clear all hardware sprites from video memory as well as the "FIX Layer" (a simple tilemap intended for text). Since all of the NEO GEO's graphics are either FIX layer tiles or hardware sprites, this will clear the screen in its entirety. The only thing left will be the background color.
The registers <code>D0</code>, <code>D1</code>, and <code>A0</code> will be clobbered after returning, so keep that in mind.
<syntaxhighlight lang="68000devpac">JSR $C004C2 ;clear the FIX layer
JSR $C004C8 ;clear hardware sprites</syntaxhighlight>
===Sega Genesis===
The fastest way to do this is with direct memory access. It is assumed that your tile pattern definition has 32 null bytes starting at VRAM offset $0000. (You need to have 32 null bytes in VRAM somewhere for this to work, it doesn't have to be at VRAM address $0000, but this example uses that for convenience.) The code below also assumes the Genesis's VDP (video display processor) has been set up as follows:
* VDP register 2 = %00110000 = foreground tilemap at VRAM address $C000
* VDP register 3 = %00111100 = window tilemap at VRAM address $F000
* VDP register 4 = %00000111 = background tilemap at VRAM address $E000
* VDP register 5 = %01101100 = sprite attribute table at VRAM address $D800
This technique uses DMA fill mode to fill the tilemaps (not the pattern definitions) with transparent tiles. This has the effect of wiping the screen of all graphics, while not disturbing the tile definitions themselves.
<syntaxhighlight lang="68000devpac">dma_fill:
;input:
;D2.L = what address to write to.
;D1.W = DMA LENGTH (measured in words)
;D0 = WHAT DATA TO USE TO FILL VRAM
vdp_data equ $C00000
vdp_ctrl equ $C00004
MOVE.L #$40000003,D2 ;VDP sees this as VRAM address $C000
MOVE.W #$2000,D1 ;fill $2000 words ($4000 bytes)
MOVEQ #0,D0 ;with zeroes.
MOVE SR,-(SP)
MOVEM.L D3-D7,-(SP)
MOVE #$2700,SR ;disable interrupts
MOVEQ.L #-109,D3 ;quickly move #$FFFFFF93 into D3
LSL.W #8,D3
OR.B D1,D3
;d3 contains $93xx where xx is the low byte of dma length
;this is the correct command to give the vdp
LSR.W #8,D1 ;shift high byte of dma length down to low byte
MOVEQ.L #-108,D4 ;quickly move #$FFFFFF94 into d4
LSL.W #8,D4 ;D4 = #$FFFF9400
OR.B D1,D4
;d3 contains $94xx where xx is the high byte of dma length
;this is the correct command to give the vdp
OR.L #$20,D2 ;tells the vdp the next write is a DMA write
.wait:
;waiting until vblank is optional, however DMA is much faster if performed during vblank so might as well.
move.w VDP_ctrl,d7
and.w #%0000000000001000,d7 ;See if vblank is running
bne .wait ;wait until it is
MOVE.W #($8100|%01110100),(VDP_CTRL) ;ENABLE DMA
move.w #$8F01,(vdp_ctrl) ;set auto-inc to 1
MOVE.W #$9780,(vdp_ctrl) ;enable dma vram fill
MOVE.W D3,(vdp_ctrl) ;set dma length low byte
MOVE.W D4,(vdp_ctrl) ;set dma length high byte
MOVE.L D2,(vdp_ctrl) ;set destination address
MOVE.W D0,(vdp_data)
;at this point the 68000 halts until DMA is finished.
move.w #($8100|%01100100),(VDP_CTRL) ;DISABLE DMA
move.w #$8F02,(vdp_ctrl) ;set auto-inc back to 2
MOVEM.L (SP)+,D3-D7
RTR</syntaxhighlight>
=={{header|8080 Assembly}}==
On almost all video terminals, from the earliest ones to today's terminal emulators,
sending an ASCII Form Feed control character (code 12) will clear the screen.
This program uses a CP/M system call to send a Form Feed character to the standard
output, as CP/M was the de facto standard operating system for 8080-based systems.
<syntaxhighlight lang="8080asm">putch: equ 2 ; CP/M 'putchar' syscall
bdos: equ 5 ; CP/M BDOS entry point
FF: equ 12 ; ASCII form feed
org 100h
mvi c,putch ; Print character (syscall goes in C register)
mvi e,FF ; Form feed (argument goes in E register)
jmp bdos ; Call CP/M BDOS and quit</syntaxhighlight>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program clearScreen.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
.equ BUFFERSIZE, 100
/*******************************************/
/* Initialized data */
/*******************************************/
.data
szMessStartPgm: .asciz "Program start \n"
szMessEndPgm: .asciz "Program normal end.\n"
szClear: .asciz "\33[2J" // console clear (id language C)
szClear1: .byte 0x1B
.byte 'c' // other console clear
.byte 0
szCarriageReturn: .asciz "\n"
/*******************************************/
/* UnInitialized data */
/*******************************************/
.bss
/*******************************************/
/* code section */
/*******************************************/
.text
.global main
main:
ldr x0,qAdrszMessStartPgm // display start message
bl affichageMess
//ldr x0,qAdrszClear // clear screen
ldr x0,qAdrszClear1 // change for other clear screen
bl affichageMess
ldr x0,qAdrszMessEndPgm // display end message
bl affichageMess
100: // standard end of the program
mov x0,0 // return code
mov x8,EXIT // request to exit program
svc 0 // perform system call
qAdrszMessStartPgm: .quad szMessStartPgm
qAdrszMessEndPgm: .quad szMessEndPgm
qAdrszClear: .quad szClear
qAdrszClear1: .quad szClear1
qAdrszCarriageReturn: .quad szCarriageReturn
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
=={{header|Action!}}==
<syntaxhighlight lang="action!">proc Main()
Put(125)
return</syntaxhighlight>
=={{header|Ada}}==
For systems with ANSI terminal handling:
<syntaxhighlight lang="ada">with Ada.Text_IO;
procedure CLS is
begin
Ada.Text_IO.Put(ASCII.ESC & "[2J");
end CLS;</syntaxhighlight>
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
Uses the Algol 68G interface to the curses library.
<syntaxhighlight lang="algol68">curses start; # needed before any screen clearing, positioning etc. #
curses clear # clear the screen #</syntaxhighlight>
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program clearScreen.s */
/* Constantes */
.equ STDOUT, 1 @ Linux output console
.equ EXIT, 1 @ Linux syscall
.equ WRITE, 4 @ Linux syscall
.equ BUFFERSIZE, 100
/* Initialized data */
.data
szMessStartPgm: .asciz "Program start \n"
szMessEndPgm: .asciz "Program normal end.\n"
szClear: .asciz "\33[2J" @ console clear (id language C)
szClear1: .byte 0x1B
.byte 'c' @ other console clear
.byte 0
szCarriageReturn: .asciz "\n"
/* UnInitialized data */
.bss
/* code section */
.text
.global main
main:
ldr r0,iAdrszMessStartPgm @ display start message
bl affichageMess
//ldr r0,iAdrszClear @ clear screen
ldr r0,iAdrszClear1 @ change for other clear screen
bl affichageMess
ldr r0,iAdrszMessEndPgm @ display end message
bl affichageMess
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc 0 @ perform system call
iAdrszMessStartPgm: .int szMessStartPgm
iAdrszMessEndPgm: .int szMessEndPgm
iAdrszClear: .int szClear
iAdrszClear1: .int szClear1
iAdrszCarriageReturn: .int szCarriageReturn
/******************************************************************/
/* display text with size calculation */
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
push {r0,r1,r2,r7,lr} @ save registers
mov r2,#0 @ counter length */
1: @ loop length calculation
ldrb r1,[r0,r2] @ read octet start position + index
cmp r1,#0 @ if 0 its over
addne r2,r2,#1 @ else add 1 in the length
bne 1b @ and loop
@ so here r2 contains the length of the message
mov r1,r0 @ address message in r1
mov r0,#STDOUT @ code to write to the standard output Linux
mov r7, #WRITE @ code call system "write"
svc #0 @ call system
pop {r0,r1,r2,r7,lr} @ restaur registers
bx lr @ return
</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">clear</syntaxhighlight>
=={{header|AutoHotkey}}==
Reference: http://www.autohotkey.com/forum/topic76532.html
<syntaxhighlight lang="ahk">RunWait %comspec% /c cls</syntaxhighlight>
=={{header|AWK}}==
<syntaxhighlight lang="awk">system("clear")</syntaxhighlight>
=={{header|Axe}}==
<syntaxhighlight lang="axe">ClrHome</syntaxhighlight>
=={{header|BaCon}}==
<syntaxhighlight lang="freebasic">CLEAR</syntaxhighlight>
=={{header|BASIC}}==
Line 12 ⟶ 366:
{{works with|ZX Spectrum Basic}}
{{works with|BBC BASIC}}
<syntaxhighlight lang
==={{header|Applesoft BASIC}}===
<syntaxhighlight lang="applesoftbasic">HOME</syntaxhighlight>
==={{header|Aquarius BASIC}}===
<syntaxhighlight lang="aquarius basic">PRINT CHR$(11);</syntaxhighlight>
==={{header|Atari BASIC}}===
<syntaxhighlight lang="atari basic">PRINT CHR$(125);</syntaxhighlight>
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256"> cls
#Borra la ventana de texto</syntaxhighlight>
y
<syntaxhighlight lang="basic256"> clg
#Borra la ventana de gráficos</syntaxhighlight>
==={{header|BBC BASIC}}===
<syntaxhighlight lang="bbcbasic"> CLS</syntaxhighlight>
or
<syntaxhighlight lang="bbcbasic"> VDU 12</syntaxhighlight>
or
<syntaxhighlight lang="bbcbasic"> PRINT CHR$(12);</syntaxhighlight>
==={{header|Commodore BASIC}}===
<syntaxhighlight lang="commodore basic">PRINT CHR$(147);</syntaxhighlight>
{{works with|Commodore BASIC|3.5,7.0}}
(Also works on a VIC-20 with the SuperExpander cartridge)
<syntaxhighlight lang="basic">SCNCLR</syntaxhighlight>
==={{header|GW-BASIC}}===
<syntaxhighlight lang="qbasic">10 CLS</syntaxhighlight>
==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">100 CLEAR SCREEN</syntaxhighlight>
==={{header|PureBasic}}===
Clears the whole console content using the current background color.
<syntaxhighlight lang="purebasic">ClearConsole()</syntaxhighlight>
==={{header|True BASIC}}===
<syntaxhighlight lang="truebasic">CLEAR
END</syntaxhighlight>
=={{header|Batch File}}==
<syntaxhighlight lang
=={{header|beeswax}}==
Using the ANSI escape sequence <code>Esc[2J</code>.
<syntaxhighlight lang="beeswax">_3F..}`[2J`</syntaxhighlight>
=={{header|Befunge}}==
Assuming a terminal with support for ANSI escape sequences.
<syntaxhighlight lang="befunge">"J2["39*,,,,@</syntaxhighlight>
=={{header|Blast}}==
<syntaxhighlight lang
=={{header|
Linux/x86
<syntaxhighlight lang="blue">global _start
: syscall ( num:eax -- result:eax ) syscall ;
: exit ( status:edi -- noret ) 60 syscall ;
: bye ( -- noret ) 0 exit ;
1 const stdout
: write ( buf:esi len:edx fd:edi -- ) 1 syscall drop ;
: print ( buf len -- ) stdout write ;
: clear-screen ( -- ) s" \033[2J\033[H" print ;
: _start ( -- noret ) clear-screen bye ;</syntaxhighlight>
=={{header|Bracmat}}==
<syntaxhighlight lang="bracmat">sys$cls&</syntaxhighlight>
=={{header|C}} / {{header|C++}}==
The [[Minesweeper game#C|C version of the Minesweeper game]] uses curses.
If perhaps clear screen isn't used, call the function <code>cls</code> to do the trick.
<
}</syntaxhighlight>
Here is the cheaty way no one likes, only works on Windows.
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
void main() {
printf ("clearing screen");
getchar();
system("cls");
}</syntaxhighlight>
For Unix-likes, changing the above <code>system("cls");</code> to <code>system("clear");</code> usually works, however the <code>getchar();</code> perhaps doesn't always work as expected if you press anything other than return. This is because of the raw vs. cooked terminal mode thing.
=={{header|C sharp|C#}}==
<syntaxhighlight lang
Works on all .NET Core platforms. Throws an exception if output has been redirected to a file.
=={{header|COBOL}}==
<syntaxhighlight lang="cobol"> PROGRAM-ID. blank-terminal.
DATA DIVISION.
SCREEN SECTION.
01 blank-screen BLANK SCREEN.
PROCEDURE DIVISION.
DISPLAY blank-screen
GOBACK
.</syntaxhighlight>
=={{header|Comal}}==
<syntaxhighlight lang="comal">PAGE</syntaxhighlight>
=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">
(format t "~C[2J" #\Esc)
</syntaxhighlight>
or it could be done passing the 'clear' command to the shell
<syntaxhighlight lang="lisp">
(defun sh (cmd)
"A multi-implementation function equivalent for the C function system"
#+clisp (shell cmd)
#+ecl (si:system cmd)
#+sbcl (sb-ext:run-program "/bin/sh" (list "-c" cmd) :input nil :output *standard-output*)
#+clozure (ccl:run-program "/bin/sh" (list "-c" cmd) :input nil :output *standard-output*))
(sh "clear")
</syntaxhighlight>
==={{header|ncurses}}===
When the ncurses terminal library is used, characters are displayed on an alternate screen. Clearing that alternate screen does not clear the main screen of the terminal from which ncurses was started. To interface ncurses from Lisp, the ''croatoan'' library is used.
<syntaxhighlight lang="lisp">(defun clear-test ()
;; starting ncurses enters the alternate screen buffer of the terminal
(with-screen (scr :input-echoing nil :input-blocking t)
(princ "Text to be cleared" scr)
(refresh scr)
;; wait for a keypress
(get-char scr)
(clear scr)
(refresh scr)
(get-char scr)))
;; leaving ncurses returns the terminal to the main screen buffer</syntaxhighlight>
=={{header|D}}==
<syntaxhighlight lang="d">extern (C) nothrow {
void disp_open();
void disp_move(int, int);
void disp_eeop();
void disp_close();
}
void main() {
disp_open();
disp_move(0, 0);
disp_eeop();
disp_close();
}</syntaxhighlight>
=={{header|Dc}}==
===Using external "clear" binary===
Dc's command to execute shell commands can only be the last command of a line. That's no problem with multi line Dc programs but not very helpful in Dc oneliners:
<syntaxhighlight lang="dc">!clear</syntaxhighlight>
Luckily there is a loophole:
<syntaxhighlight lang="dc">[ !clear ] x</syntaxhighlight>
===Using a terminal control sequence===
A common way to clear the screen with a terminal (assuming XTerm here) control sequence
could be to home the cursor ("ESC[H", "1B 5B 48") and then clear to the end of the
screen ("ESC[J", "1B 5B 4A").
<syntaxhighlight lang="dc">16i 1B5B481B5B4A P</syntaxhighlight>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| Winapi.Windows}}
===Stand alone function===
Copy of David Heffrnan on stackoverflow [https://stackoverflow.com/questions/29794559/delphi-console-xe7-clearscreen].
<syntaxhighlight lang="delphi">
uses
System.SysUtils,
Winapi.Windows;
procedure ClearScreen;
var
stdout: THandle;
csbi: TConsoleScreenBufferInfo;
ConsoleSize: DWORD;
NumWritten: DWORD;
Origin: TCoord;
begin
stdout := GetStdHandle(STD_OUTPUT_HANDLE);
Win32Check(stdout<>INVALID_HANDLE_VALUE);
Win32Check(GetConsoleScreenBufferInfo(stdout, csbi));
ConsoleSize := csbi.dwSize.X * csbi.dwSize.Y;
Origin.X := 0;
Origin.Y := 0;
Win32Check(FillConsoleOutputCharacter(stdout, ' ', ConsoleSize, Origin,
NumWritten));
Win32Check(FillConsoleOutputAttribute(stdout, csbi.wAttributes, ConsoleSize, Origin,
NumWritten));
Win32Check(SetConsoleCursorPosition(stdout, Origin));
end;</syntaxhighlight>
===Library System.Console from Jens Borrisholt===
{{libheader| System.Console}}
The System.Console can be found here[https://github.com/JensBorrisholt/DelphiConsole/tree/master/Console]
<syntaxhighlight lang="delphi">console.Clear;</syntaxhighlight>
=={{header|Elena}}==
ELENA 3.4 :
<syntaxhighlight lang="elena">public program()
{
console.clear()
}</syntaxhighlight>
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
clear()->io:format(os:cmd("clear")).
</syntaxhighlight>
=={{header|Euphoria}}==
<syntaxhighlight lang
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">open System
Console.Clear()</syntaxhighlight>
=={{header|Forth}}==
<syntaxhighlight lang
=={{header|Fortran}}==
'''Fortran 2008''':
<syntaxhighlight lang="fortran">program clear
character(len=:), allocatable :: clear_command
clear_command = "clear" !"cls" on Windows, "clear" on Linux and alike
call execute_command_line(clear_command)
end program</syntaxhighlight>
=== Intel Fortran on Windows ===
Using console functions, one can also clear the screen without using a system command. See also ''[https://msdn.microsoft.com/en-us/library/ms682022.aspx Clearing the Screen]'' on MSDN.
<syntaxhighlight lang="fortran">program clear
use kernel32
implicit none
integer(HANDLE) :: hStdout
hStdout = GetStdHandle(STD_OUTPUT_HANDLE)
call clear_console(hStdout)
contains
subroutine clear_console(hConsole)
integer(HANDLE) :: hConsole
type(T_COORD) :: coordScreen = T_COORD(0, 0)
integer(DWORD) :: cCharsWritten
type(T_CONSOLE_SCREEN_BUFFER_INFO) :: csbi
integer(DWORD) :: dwConSize
if (GetConsoleScreenBufferInfo(hConsole, csbi) == 0) return
dwConSize = csbi%dwSize%X * csbi%dwSize%Y
if (FillConsoleOutputCharacter(hConsole, SCHAR_" ", dwConSize, &
coordScreen, loc(cCharsWritten)) == 0) return
if (GetConsoleScreenBufferInfo(hConsole, csbi) == 0) return
if (FillConsoleOutputAttribute(hConsole, csbi%wAttributes, &
dwConSize, coordScreen, loc(cCharsWritten)) == 0) return
if (SetConsoleCursorPosition(hConsole, coordScreen) == 0) return
end subroutine
end program</syntaxhighlight>
=== GNU Fortran on Windows ===
The preceding program can be compiled with GNU Fortran, with the following interface module for Windows API.
<syntaxhighlight lang="fortran">module kernel32
use iso_c_binding
implicit none
integer, parameter :: HANDLE = C_INTPTR_T
integer, parameter :: PVOID = C_INTPTR_T
integer, parameter :: LPDWORD = C_INTPTR_T
integer, parameter :: BOOL = C_INT
integer, parameter :: SHORT = C_INT16_T
integer, parameter :: WORD = C_INT16_T
integer, parameter :: DWORD = C_INT32_T
integer, parameter :: SCHAR = C_CHAR
integer(DWORD), parameter :: STD_INPUT_HANDLE = -10
integer(DWORD), parameter :: STD_OUTPUT_HANDLE = -11
integer(DWORD), parameter :: STD_ERROR_HANDLE = -12
type, bind(C) :: T_COORD
integer(SHORT) :: X, Y
end type
type, bind(C) :: T_SMALL_RECT
integer(SHORT) :: Left
integer(SHORT) :: Top
integer(SHORT) :: Right
integer(SHORT) :: Bottom
end type
type, bind(C) :: T_CONSOLE_SCREEN_BUFFER_INFO
type(T_COORD) :: dwSize
type(T_COORD) :: dwCursorPosition
integer(WORD) :: wAttributes
type(T_SMALL_RECT) :: srWindow
type(T_COORD) :: dwMaximumWindowSize
end type
interface
function FillConsoleOutputCharacter(hConsoleOutput, cCharacter, &
nLength, dwWriteCoord, lpNumberOfCharsWritten) &
bind(C, name="FillConsoleOutputCharacterA")
import BOOL, C_CHAR, SCHAR, HANDLE, DWORD, T_COORD, LPDWORD
!GCC$ ATTRIBUTES STDCALL :: FillConsoleOutputCharacter
integer(BOOL) :: FillConsoleOutputCharacter
integer(HANDLE), value :: hConsoleOutput
character(kind=SCHAR), value :: cCharacter
integer(DWORD), value :: nLength
type(T_COORD), value :: dwWriteCoord
integer(LPDWORD), value :: lpNumberOfCharsWritten
end function
end interface
interface
function FillConsoleOutputAttribute(hConsoleOutput, wAttribute, &
nLength, dwWriteCoord, lpNumberOfAttrsWritten) &
bind(C, name="FillConsoleOutputAttribute")
import BOOL, HANDLE, WORD, DWORD, T_COORD, LPDWORD
!GCC$ ATTRIBUTES STDCALL :: FillConsoleOutputAttribute
integer(BOOL) :: FillConsoleOutputAttribute
integer(HANDLE), value :: hConsoleOutput
integer(WORD), value :: wAttribute
integer(DWORD), value :: nLength
type(T_COORD), value :: dwWriteCoord
integer(LPDWORD), value :: lpNumberOfAttrsWritten
end function
end interface
interface
function GetConsoleScreenBufferInfo(hConsoleOutput, &
lpConsoleScreenBufferInfo) &
bind(C, name="GetConsoleScreenBufferInfo")
import BOOL, HANDLE, T_CONSOLE_SCREEN_BUFFER_INFO
!GCC$ ATTRIBUTES STDCALL :: GetConsoleScreenBufferInfo
integer(BOOL) :: GetConsoleScreenBufferInfo
integer(HANDLE), value :: hConsoleOutput
type(T_CONSOLE_SCREEN_BUFFER_INFO) :: lpConsoleScreenBufferInfo
end function
end interface
interface
function SetConsoleCursorPosition(hConsoleOutput, dwCursorPosition) &
bind(C, name="SetConsoleCursorPosition")
import BOOL, HANDLE, T_COORD
!GCC$ ATTRIBUTES STDCALL :: SetConsoleCursorPosition
integer(BOOL) :: SetConsoleCursorPosition
integer(HANDLE), value :: hConsoleOutput
type(T_COORD), value :: dwCursorPosition
end function
end interface
interface
function GetStdHandle(nStdHandle) bind(C, name="GetStdHandle")
import HANDLE, DWORD
!GCC$ ATTRIBUTES STDCALL :: GetStdHandle
integer(HANDLE) :: GetStdHandle
integer(DWORD), value :: nStdHandle
end function
end interface
end module
</syntaxhighlight>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64
' FreeBASIC has a built in Cls command which clears the console on Windows
' but it may still be possible to scroll the console to view its
' previous contents. The following command prevents this.
Shell("Cls")
Sleep</syntaxhighlight>
=={{header|Furor}}==
<syntaxhighlight lang="furor">
cls
</syntaxhighlight>
Yet another solution:
<syntaxhighlight lang="furor">
."\z"
</syntaxhighlight>
=={{header|Peri}}==
<syntaxhighlight lang="peri">
###sysinclude system.uh
cls
</syntaxhighlight>
Yet another solution:
<syntaxhighlight lang="peri">
."\z"
</syntaxhighlight>
=={{header|Go}}==
===External command===
Probably most reliable way to clear the screen.
<syntaxhighlight lang="go">package main
import (
"os"
"os/exec"
)
Line 52 ⟶ 793:
c.Stdout = os.Stdout
c.Run()
}</
===ANSI escape code===
Simplest, if your terminal supports the ANSI code you want.
<syntaxhighlight lang="go">package main
import "fmt"
func main() {
fmt.Print("\033[2J")
}</syntaxhighlight>
===Ncurses===
More complex, but works across multiple terminal types.
{{libheader|curses}}
<syntaxhighlight lang="go">package main
import (
"log"
"time"
"code.google.com/p/goncurses"
)
func main() {
s, err := goncurses.Init()
if err != nil {
log.Fatal("goncurses:", err)
}
defer goncurses.End()
s.Println("Clearing screen...")
s.Refresh()
time.Sleep(1 * time.Second)
s.Clear() // clear screen
// Goncurses saves the screen on Init and restores it on End. This
// GetChar() allows you to see the effect of the program before it exits.
s.GetChar() // press any key to continue
}</syntaxhighlight>
=={{header|GUISS}}==
This will only work if the terminal is sitting at a prompt.
<syntaxhighlight lang="guiss">Window:Terminal,Type:clear[enter]</syntaxhighlight>
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">
import System.Console.ANSI
main = clearScreen
</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
Example works for both Icon and Unicon. Determine which system command to call by querying &features at run time. Alternately, the related preprocessor symbols can be used to select the operating system.
<syntaxhighlight lang="icon">procedure main ()
if &features == "MS Windows" then system("cls") # Windows
else if &features == "UNIX" then system("clear") # Unix
end</
=={{header|J}}==
Note: this is specific the java+gdi based J ide.
<syntaxhighlight lang="j">smwrite_jijs_ ''</syntaxhighlight>
=={{header|Java}}==
Using the ANSI escape sequence:
<syntaxhighlight lang="java">public class Clear
{
public static void main (String[] args)
{
System.out.print("\033[2J");
}
}</syntaxhighlight>
An alternative sequence:
<syntaxhighlight lang="java">public class Clear
{
public static void main (String[] args)
{
System.out.print("\033\143");
}
}</syntaxhighlight>
=={{header|jq}}==
<syntaxhighlight lang="jq">"\u001B[2J"</syntaxhighlight>
'''Example''':
<syntaxhighlight lang="sh">$ jq -nr '"\u001B[2J"'</syntaxhighlight>
=={{header|Jsish}}==
Using ANSI terminal control codes.
<syntaxhighlight lang="javascript">/* Terminal Control, clear the screen, in Jsish */
function cls() { printf('\u001b[2J'); }
;cls();
/*
=!EXPECTSTART!=
cls() ==> ^[[2Jundefined
=!EXPECTEND!=
*/</syntaxhighlight>
{{out}}
<pre>prompt$ jsish -u terminalControlClear.jsi
[PASS] terminalControlClear.jsi</pre>
=={{header|Julia}}==
<syntaxhighlight lang="julia">
println("\33[2J")
</syntaxhighlight>
=={{header|Kotlin}}==
{{works with|Ubuntu|14.04}}
<syntaxhighlight lang="scala">// version 1.1.2
fun main(args: Array<String>) {
println("\u001Bc") // Esc + c
}</syntaxhighlight>
=={{header|Lang}}==
<syntaxhighlight lang="lang">
# \E is an escape sequence for the ESC ascii code
fn.println(\E[2J)
</syntaxhighlight>
=={{header|Lasso}}==
<syntaxhighlight lang="lasso">local(
esc = decode_base64('Gw==')
)
stdout(#esc + '[2J')</syntaxhighlight>
=={{header|Logo}}==
<syntaxhighlight lang
There is a separate command to reset the turtle graphics window.
<
cs ; abbreviation for clearscreen
clean ; like cs, but doesn't reset turtle position</
=={{header|Lua}}==
===Unix, Linux===
<syntaxhighlight lang="lua">os.execute( "clear" )</syntaxhighlight>
===Windows===
<syntaxhighlight lang="lua">os.execute( "cls" )</syntaxhighlight>
=={{header|M2000 Interpreter}}==
We can clear the screen with Form, Cls, Window statements. Each one perform something on the console form except clear it. Form change the size of letters using the size of window. Window change all. Cls change the background color, or use the same (is optional) and optional can set the line for the split screen (from that line we have scrolling). Also we can use Linespace statement (in twips) to set the line space. Statement Form set linespace automatic to give space between lines to full use of the window.
<syntaxhighlight lang="m2000 interpreter">
Module Checkit {
Pen 14 ' yellow
\\ using form we set characters by rows
\\ this clear the screen
Form 80, 40
\\ magenta for background, all form for vertical scrolling
Cls 5, 0
Print "wait... half second"
Wait 500
\\ clear using background color
Cls
\\ set the background (using html number for color), and set 4th line as top
\\ for scrolling
Cls #11bb22, 3
Print "This is in 4th line"
Wait 1000
\\ now we center the form, using 12000 twips by 8000twips as border
\\ form inside maybe smaller
\\ font size is 16pt of current font
Font "Courier New"
Window 16, 12000, 8000;
Print "This is first line"
Wait 1000
Font "Arial"
\\ set the console form to screen 0, maximized
Window 16, 0
Cls 5 ' magenta
Back {
Cls 15 ' white border
}
}
checkit
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Delegating to clear on terminal enabled OS(Mac Os, Linux)
<syntaxhighlight lang="mathematica">Run["clear"];</syntaxhighlight>
=={{header|min}}==
<syntaxhighlight lang="min">clear</syntaxhighlight>
=={{header|Nanoquery}}==
<syntaxhighlight lang="nanoquery">cls</syntaxhighlight>
=={{header|Nemerle}}==
Exactly as [[Terminal_control/Clear_the_screen#C.23|C#]]. Because of possible (probable) ambiguity, this is one time it may be prudent to use:
<syntaxhighlight lang="nemerle">Console.Clear();</syntaxhighlight>
rather than importing the <tt>Console</tt> class with <tt>using System.Console;</tt> and calling as:
<syntaxhighlight lang="nemerle">Clear();</syntaxhighlight>
=={{header|NewLISP}}==
<syntaxhighlight lang="newlisp">
(! "clear")
</syntaxhighlight>
In the newLISP command shell, this syntax is also proper:
<syntaxhighlight lang="newlisp">
!clear
</syntaxhighlight>
=={{header|Nim}}==
<syntaxhighlight lang="nim">
import terminal
eraseScreen() #puts cursor at down
setCursorPos(0, 0)
</syntaxhighlight>
=={{header|NS-HUBASIC}}==
<syntaxhighlight lang="ns-hubasic">10 CLS</syntaxhighlight>
=={{header|OCaml}}==
Using the library [http://forge.ocamlcore.org/projects/ansiterminal/ ANSITerminal]:
<syntaxhighlight lang="ocaml">#load "unix.cma"
#directory "+ANSITerminal"
#load "ANSITerminal.cma"
open ANSITerminal
let () =
erase Screen</syntaxhighlight>
=={{header|Octave}}==
<syntaxhighlight lang="octave"> system clear;</syntaxhighlight>
<syntaxhighlight lang="octave"> system('clear');</syntaxhighlight>
=={{header|Pascal}}==
<syntaxhighlight lang="pascal">clrscr;</syntaxhighlight>
<syntaxhighlight lang="pascal">page(output); { UCSD Pascal }</syntaxhighlight>
=={{header|Perl}}==
Assuming some ANSI terminal, easiest way is call your system's clear command:
<syntaxhighlight lang
If it's needed often:
<
#... later:
print $clear;</
We can also obtain the sequence using the Term::Cap module:
<syntaxhighlight lang="perl">use Term::Cap;
$terminal = Term::Cap->Tgetent();
$clear = $terminal->Tputs('cl');
print $clear;</syntaxhighlight>
<syntaxhighlight lang="perl">#on Windows using Powershell or WT.exe
system('cls');</syntaxhighlight>
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #7060A8;">clear_screen</span><span style="color: #0000FF;">()</span>
<!--</syntaxhighlight>-->
=={{header|PicoLisp}}==
<syntaxhighlight lang
=={{header|Pike}}==
<syntaxhighlight lang="pike">int main() {
Process.system("clear");
return 0;
}</syntaxhighlight>
Use "cls" instead of "clear" for Windows
=={{header|PowerShell}}==
<syntaxhighlight lang
=={{header|
<syntaxhighlight lang="prodos">clearscurrentscreentext</syntaxhighlight>
=={{header|Python}}==
Line 109 ⟶ 1,078:
{{works with|Ubuntu|10.10}}
To clear the screen on
<
os.system("clear")</syntaxhighlight>
Or similar to C example (won't work in Winsows console, since it does not recognize ANSI sequences):
<syntaxhighlight lang="python">print "\33[2J"</syntaxhighlight>
On Windows, using functions from the kernel32 DLL:
<syntaxhighlight lang="python">from ctypes import *
STD_OUTPUT_HANDLE = -11
class COORD(Structure):
pass
COORD._fields_ = [("X", c_short), ("Y", c_short)]
class SMALL_RECT(Structure):
pass
SMALL_RECT._fields_ = [("Left", c_short), ("Top", c_short), ("Right", c_short), ("Bottom", c_short)]
class CONSOLE_SCREEN_BUFFER_INFO(Structure):
pass
CONSOLE_SCREEN_BUFFER_INFO._fields_ = [
("dwSize", COORD),
("dwCursorPosition", COORD),
("wAttributes", c_ushort),
("srWindow", SMALL_RECT),
("dwMaximumWindowSize", COORD)
]
def clear_console():
h = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
csbi = CONSOLE_SCREEN_BUFFER_INFO()
windll.kernel32.GetConsoleScreenBufferInfo(h, pointer(csbi))
dwConSize = csbi.dwSize.X * csbi.dwSize.Y
scr = COORD(0, 0)
windll.kernel32.FillConsoleOutputCharacterA(h, c_char(b" "), dwConSize, scr, pointer(c_ulong()))
windll.kernel32.FillConsoleOutputAttribute(h, csbi.wAttributes, dwConSize, scr, pointer(c_ulong()))
windll.kernel32.SetConsoleCursorPosition(h, scr)
clear_console()</syntaxhighlight>
=={{header|Quackery}}==
{{trans|Python}}
On some platforms the screen will not be cleared until the output buffer is flushed e.g. by a cr/lf.
<syntaxhighlight lang="quackery"> [ $ &print("\33[2J",end='')& python ] is clearscreen</syntaxhighlight>
=={{header|R}}==
<syntaxhighlight lang="r">cat("\33[2J")</syntaxhighlight>
Or with system calls
<syntaxhighlight lang="r"># Unix
system("clear")
# Windows
system("cls")</syntaxhighlight>
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
(require (planet neil/charterm:3:0))
(with-charterm
(void (charterm-clear-screen)))
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>sub clear { print qx[clear] }
clear;</syntaxhighlight>
=={{header|Retro}}==
<syntaxhighlight lang
=={{header|REXX}}==
===generic===
The [[REXX]] programming language does not include a facility to clear the screen natively.
However, it is possile to execute an external [[system command]] to achieve this task.
Below is some generic-type boilerplate (REXX) code which (possibly) determines:
::::* which REXX is being used
::::* which operating system is being used
::::* which (external) program to clear the screen
<br>Also, not germane to this Rosetta Code task, the boilerplate code also possibly determines (among other things):
::::* if a particular documentation is to be shown
::::* which system pool name is to be used for system environmental variables
::::* which version of REXX is being used
::::* if the program is being invoked as a function, command, or subroutine
<br>The following code works for:
::::* PC/REXX
::::* Personal REXX
::::* CMS REXX
::::* TSO REXX
::::* R4 REXX
::::* ROO REXX
::::* KEXX
::::* REXX compiler
::::* Regina REXX
<br>The intent of the program's boilerplate code is to be able to be executed under most REXXes under most operating systems without changing the boilerplate REXX code.
<syntaxhighlight lang="rexx">/*REXX boilerplate determines how to clear screen (under various REXXes)*/
trace off; parse arg ! /*turn off tracing; get C.L. args*/
if !all(arg()) then exit /*Doc request? Show, then exit.*/
if !cms then address '' /*Is this CMS? Use this address.*/
!cls /*clear the (terminal) screen. */ /* ◄═══ this is where "it" happens.*/
exit /*stick a fork in it, we're done.*/
/*═════════════════════════════general 1-line subs══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════*/
!all: !!=!;!=space(!);upper !;call !fid;!nt=right(!var('OS'),2)=='NT';!cls=word('CLS VMFCLEAR CLRSCREEN',1+!cms+!tso*2);if arg(1)\==1 then return 0;if wordpos(!,'? ?SAMPLES ?AUTHOR ?FLOW')==0 then return 0;!call=']$H';call '$H' !fn !;!call=;return 1
!cal: if symbol('!CALL')\=="VAR" then !call=; return !call
!env: !env='ENVIRONMENT'; if !sys=='MSDOS'|!brexx|!r4|!roo then !env='SYSTEM'; if !os2 then !env='OS2'!env; !ebcdic=1=='f0'x; if !crx then !env='DOS'; return
!fid: parse upper source !sys !fun !fid . 1 . . !fn !ft !fm .; call !sys; if !dos then do; _=lastpos('\',!fn); !fm=left(!fn,_); !fn=substr(!fn,_+1); parse var !fn !fn '.' !ft; end; return word(0 !fn !ft !fm,1+('0'arg(1)))
!rex: parse upper version !ver !vernum !verdate .; !brexx='BY'==!vernum; !kexx='KEXX'==!ver; !pcrexx='REXX/PERSONAL'==!ver|'REXX/PC'==!ver; !r4='REXX-R4'==!ver; !regina='REXX-REGINA'==left(!ver,11); !roo='REXX-ROO'==!ver; call !env; return
!sys: !cms=!sys=='CMS'; !os2=!sys=='OS2'; !tso=!sys=='TSO'|!sys=='MVS'; !vse=!sys=='VSE'; !dos=pos('DOS',!sys)\==0|pos('WIN',!sys)\==0|!sys=='CMD'; !crx=left(!sys,6)=='DOSCRX'; call !rex; return
!var: call !fid; if !kexx then return space(dosenv(arg(1))); return space(value(arg(1),,!env))</syntaxhighlight>
===Regina===
The [[regina]] interpreter supports the [[rexxcurses]] plugin, which provides a facility to clear the screen
(not shown here).
=={{header|Ring}}==
<syntaxhighlight lang="ring">system('clear')</syntaxhighlight>
=={{header|RPL}}==
CLLCD
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">system 'clear'</syntaxhighlight>
Or, without reliance on the command line:
(equivalent to <code>`clear`</code>)
<syntaxhighlight lang="ruby">puts "\e[H\e[2J"</syntaxhighlight>
Probably more platform-independent:
<syntaxhighlight lang="ruby">require 'io/console'
STDOUT.clear_screen
</syntaxhighlight>
=={{header|Rust}}==
<syntaxhighlight lang="rust">print!("\x1B[2J");</syntaxhighlight>
Or using casting:
<syntaxhighlight lang="rust">print!("{}[2J", 27 as char);</syntaxhighlight>
=={{header|Scala}}==
{{libheader|Scala}}
<syntaxhighlight lang="scala">object Cls extends App {print("\033[2J")}</syntaxhighlight>
=={{header|Seed7}}==
The function [http://seed7.sourceforge.net/libraries/console.htm#clear(in_console_file) clear] is portable and
clears the [http://seed7.sourceforge.net/libraries/console.htm console window].
''Clear'' is based on terminfo respectively the Windows console API.
A portable function to clear cannot rely on shell respectively cmd.exe commands,
because Windows uses ''CLS'' and Unix shells use ''CLEAR'', to clear a screen.
ANSI terminal escape sequences are also not 100% portable,
since not all terminals accept them.
<
include "console.s7i";
Line 147 ⟶ 1,261:
# the program waits until Return/Enter is pressed.
readln;
end func;</
=={{header|Sidef}}==
Using a cached-function:
<syntaxhighlight lang="ruby">func clear { print(static x = `clear`) };
clear();</syntaxhighlight>
Directly invoking the `clear` command:
<syntaxhighlight lang="ruby">Sys.run('clear');</syntaxhighlight>
Alternatively, without reliance on the command line:
<syntaxhighlight lang="ruby">print "\e[3J\e[H\e[2J";</syntaxhighlight>
=={{header|Smalltalk}}==
<syntaxhighlight lang="smalltalk">Transcript clear.</syntaxhighlight>
=={{header|SmileBASIC}}==
SmileBASIC's text screen is mixed in with its graphics screen, background screen, and sprites screen.
===Text screen only===
To clear just the text screen:
<syntaxhighlight lang="smilebasic">CLS</syntaxhighlight>
===All screens===
Clearing all of the screens, and resetting display options can be done with:
<syntaxhighlight lang="smilebasic">ACLS</syntaxhighlight>
=={{header|SPL}}==
<syntaxhighlight lang="spl">#.clear()</syntaxhighlight>
=={{header|Standard ML}}==
{{works with|Unix}}
<syntaxhighlight lang="sml">fun clearScreen () =
let
val strm = TextIO.openOut (Posix.ProcEnv.ctermid ())
in
TextIO.output (strm, "\^[[H\^[[2J");
TextIO.closeOut strm
end</syntaxhighlight>
=={{header|Stata}}==
The '''[https://www.stata.com/help.cgi?cls cls]''' command clears the Results window, which is the closest to a ''terminal'' in Stata.
=={{header|Tcl}}==
This only works on systems with ANSI terminal handling, i.e., Unix platforms.
<
flush stdout</
=={{header|UNIX Shell}}==
Line 158 ⟶ 1,312:
The clear command can be used to clear the terminal screen:
{{works with|Bourne Shell
<
# Alternative method using tput
tput clear</
=={{header|Visual Basic .NET}}==
<syntaxhighlight lang="vbnet">System.Console.Clear()</syntaxhighlight>
Works on all .NET Core platforms. Throws an exception if output has been redirected to a file.
=={{header|Wren}}==
<syntaxhighlight lang="wren">System.print("\e[2J")</syntaxhighlight>
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">code Clear=40;
Clear;</syntaxhighlight>
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">clear screen</syntaxhighlight>
=={{header|zkl}}==
<syntaxhighlight lang="zkl">System.cmd(System.isWindows and "cls" or "clear");
// or, for ANSI terminals: print("\e[2J")</syntaxhighlight>
{{omit from|ACL2}}
{{omit from|Maxima}}
{{omit from|PARI/GP}}
{{omit from|Inform 7}}
| |||