Terminal control/Clear the screen: Difference between revisions
Line 339: | Line 339: | ||
Linux/x86 |
Linux/x86 |
||
<lang blue> |
<lang blue>global _start |
||
global _start |
|||
: syscall ( num:eax -- result:eax ) syscall ; |
: syscall ( num:eax -- result:eax ) syscall ; |
||
Line 354: | Line 353: | ||
: clear-screen ( -- ) s" \033[2J\033[H" print ; |
: clear-screen ( -- ) s" \033[2J\033[H" print ; |
||
: _start ( -- noret ) clear-screen bye ; |
: _start ( -- noret ) clear-screen bye ;</lang> |
||
</lang> |
|||
=={{header|Bracmat}}== |
=={{header|Bracmat}}== |
Revision as of 14:40, 13 April 2022
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Clear the terminal window.
11l
To clear the screen on Windows, replace 'clear' with 'cls' <lang 11l>os:(‘clear’)</lang>
6502 Assembly
This example has been written for the C64 and uses the CHROUT KERNEL routine. Compile with the Turbo Macro Pro cross assembler:
tmpx -i clrscr.s -o bin/clrscr.prg
Run with:
SYS680
<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
</lang>
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). <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
</lang>
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.
<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</lang>
AArch64 Assembly
<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" </lang>
Action!
<lang Action!>proc Main()
Put(125)
return</lang>
Ada
For systems with ANSI terminal handling:
<lang Ada>with Ada.Text_IO; procedure CLS is begin
Ada.Text_IO.Put(ASCII.ESC & "[2J");
end CLS;</lang>
ALGOL 68
Uses the Algol 68G interface to the curses library. <lang algol68>curses start; # needed before any screen clearing, positioning etc. # curses clear # clear the screen #</lang>
ARM Assembly
<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
</lang>
Arturo
<lang rebol>clear</lang>
AutoHotkey
Reference: http://www.autohotkey.com/forum/topic76532.html <lang AHK>RunWait %comspec% /c cls</lang>
AWK
<lang awk>system("clear")</lang>
Axe
<lang axe>ClrHome</lang>
BaCon
<lang freebasic>CLEAR</lang>
BASIC
<lang qbasic>CLS</lang>
Applesoft BASIC
<lang ApplesoftBasic>HOME</lang>
Aquarius BASIC
<lang Aquarius Basic>PRINT CHR$(11);</lang>
Atari BASIC
<lang Atari Basic>PRINT CHR$(125);</lang>
BASIC256
<lang BASIC256> cls
- Borra la ventana de texto</lang>
y <lang BASIC256> clg
- Borra la ventana de gráficos</lang>
BBC BASIC
<lang bbcbasic> CLS</lang> or <lang bbcbasic> VDU 12</lang> or <lang bbcbasic> PRINT CHR$(12);</lang>
Commodore BASIC
<lang Commodore Basic>PRINT CHR$(147);</lang>
(Also works on a VIC-20 with the SuperExpander cartridge)
<lang basic>SCNCLR</lang>
GW-BASIC
<lang qbasic>10 CLS</lang>
IS-BASIC
<lang IS-BASIC>100 CLEAR SCREEN</lang>
PureBasic
Clears the whole console content using the current background color. <lang PureBasic>ClearConsole()</lang>
True BASIC
<lang truebasic>CLEAR END</lang>
Batch File
<lang command>CLS</lang>
beeswax
Using the ANSI escape sequence Esc[2J
.
<lang beeswax>_3F..}`[2J`</lang>
Befunge
Assuming a terminal with support for ANSI escape sequences. <lang befunge>"J2["39*,,,,@</lang>
Blast
<lang blast>clear</lang>
Blue
Linux/x86
<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 ;</lang>
Bracmat
<lang bracmat>sys$cls&</lang>
C / C++
The C version of the Minesweeper game uses curses.
If perhaps clear screen isn't used, call the function cls
to do the trick.
<lang C>void cls(void) {
printf("\33[2J");
}</lang>
Here is the cheaty way no one likes, only works on Windows.
<lang C>#include <stdio.h>
- include <stdlib.h>
void main() {
printf ("clearing screen"); getchar(); system("cls");
}</lang>
For Unix-likes, changing the above system("cls");
to system("clear");
usually works, however the getchar();
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.
C#
<lang csharp>System.Console.Clear();</lang> Works on all .NET Core platforms. Throws an exception if output has been redirected to a file.
COBOL
<lang cobol> PROGRAM-ID. blank-terminal.
DATA DIVISION. SCREEN SECTION. 01 blank-screen BLANK SCREEN. PROCEDURE DIVISION. DISPLAY blank-screen
GOBACK .</lang>
Comal
<lang Comal>PAGE</lang>
Common Lisp
<lang lisp> (format t "~C[2J" #\Esc) </lang> or it could be done passing the 'clear' command to the shell <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") </lang>
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. <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</lang>
D
<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();
}</lang>
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: <lang dc>!clear</lang> Luckily there is a loophole: <lang dc>[ !clear ] x</lang>
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"). <lang dc>16i 1B5B481B5B4A P</lang>
Delphi
Stand alone function
Copy of David Heffrnan on stackoverflow [1]. <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;</lang>
Library System.Console from Jens Borrisholt
The System.Console can be found here[2] <lang Delphi>console.Clear;</lang>
Elena
ELENA 3.4 : <lang elena>public program() {
console.clear()
}</lang>
Erlang
<lang Erlang> clear()->io:format(os:cmd("clear")). </lang>
Euphoria
<lang Euphoria>clear_screen()</lang>
F#
<lang fsharp>open System
Console.Clear()</lang>
Forth
<lang forth>page</lang>
Fortran
Fortran 2008: <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</lang>
Intel Fortran on Windows
Using console functions, one can also clear the screen without using a system command. See also Clearing the Screen on MSDN.
<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</lang>
GNU Fortran on Windows
The preceding program can be compiled with GNU Fortran, with the following interface module for Windows API.
<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 </lang>
FreeBASIC
<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</lang>
Furor
<lang go> cls </lang> Yet another solution: <lang go> ."\z" </lang>
Go
External command
Probably most reliable way to clear the screen. <lang go>package main
import (
"os" "os/exec"
)
func main() {
c := exec.Command("clear") c.Stdout = os.Stdout c.Run()
}</lang>
ANSI escape code
Simplest, if your terminal supports the ANSI code you want. <lang go>package main
import "fmt"
func main() {
fmt.Print("\033[2J")
}</lang>
Ncurses
More complex, but works across multiple terminal types.
<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
}</lang>
GUISS
This will only work if the terminal is sitting at a prompt. <lang guiss>Window:Terminal,Type:clear[enter]</lang>
Haskell
<lang Haskell> import System.Console.ANSI
main = clearScreen </lang>
Icon and 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. <lang Icon>procedure main ()
if &features == "MS Windows" then system("cls") # Windows else if &features == "UNIX" then system("clear") # Unix
end</lang>
J
Note: this is specific the java+gdi based J ide. <lang j>smwrite_jijs_ </lang>
Java
Using the ANSI escape sequence: <lang java>public class Clear {
public static void main (String[] args) { System.out.print("\033[2J"); }
}</lang> An alternative sequence: <lang java>public class Clear {
public static void main (String[] args) { System.out.print("\033\143"); }
}</lang>
jq
<lang jq>"\u001B[2J"</lang> Example: <lang sh>$ jq -n '"\u001B[2J"'</lang>
Jsish
Using ANSI terminal control codes. <lang javascript>/* Terminal Control, clear the screen, in Jsish */ function cls() { printf('\u001b[2J'); }
- cls();
/*
!EXPECTSTART!
cls() ==> ^[[2Jundefined
!EXPECTEND!
- /</lang>
- Output:
prompt$ jsish -u terminalControlClear.jsi [PASS] terminalControlClear.jsi
Julia
<lang julia> println("\33[2J") </lang>
Kotlin
<lang scala>// version 1.1.2
fun main(args: Array<String>) {
println("\u001Bc") // Esc + c
}</lang>
Lasso
<lang Lasso>local( esc = decode_base64('Gw==') )
stdout(#esc + '[2J')</lang>
Logo
<lang logo>cleartext</lang> There is a separate command to reset the turtle graphics window. <lang logo>clearscreen cs ; abbreviation for clearscreen clean ; like cs, but doesn't reset turtle position</lang>
Lua
Unix, Linux
<lang lua>os.execute( "clear" )</lang>
Windows
<lang lua>os.execute( "cls" )</lang>
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.
<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 </lang>
Mathematica/Wolfram Language
Delegating to clear on terminal enabled OS(Mac Os, Linux) <lang Mathematica>Run["clear"];</lang>
Nanoquery
<lang nanoquery>cls</lang>
Nemerle
Exactly as C#. Because of possible (probable) ambiguity, this is one time it may be prudent to use: <lang Nemerle>Console.Clear();</lang> rather than importing the Console class with using System.Console; and calling as: <lang Nemerle>Clear();</lang>
NewLISP
<lang NewLISP> (! "clear") </lang> In the newLISP command shell, this syntax is also proper: <lang NewLISP> !clear </lang>
Nim
<lang nim> import terminal
eraseScreen() #puts cursor at down setCursorPos(0, 0) </lang>
NS-HUBASIC
<lang NS-HUBASIC>10 CLS</lang>
OCaml
Using the library ANSITerminal:
<lang ocaml>#load "unix.cma"
- directory "+ANSITerminal"
- load "ANSITerminal.cma"
open ANSITerminal
let () =
erase Screen</lang>
Octave
<lang Octave> system clear;</lang> <lang Octave> system('clear');</lang>
Pascal
<lang Pascal>clrscr;</lang> <lang Pascal>page(output); { UCSD Pascal }</lang>
Perl
Assuming some ANSI terminal, easiest way is call your system's clear command: <lang perl>system('clear')</lang>
If it's needed often: <lang perl>$clear = `clear`; # clear simply prints some escape sequence, cache it
- ... later:
print $clear;</lang>
We can also obtain the sequence using the Term::Cap module:
<lang perl>use Term::Cap;
$terminal = Term::Cap->Tgetent(); $clear = $terminal->Tputs('cl'); print $clear;</lang>
<lang perl>#on Windows using Powershell or WT.exe system('cls');</lang>
Phix
<lang Phix>clear_screen()</lang>
PicoLisp
<lang PicoLisp>(call 'clear)</lang>
PowerShell
<lang powershell>Clear-Host</lang>
ProDOS
<lang ProDOS>clearscurrentscreentext</lang>
Python
To clear the screen on Windows, replace 'clear' with 'cls'
<lang python>import os os.system("clear")</lang>
Or similar to C example (won't work in Winsows console, since it does not recognize ANSI sequences):
<lang python>print "\33[2J"</lang>
On Windows, using functions from the kernel32 DLL:
<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()</lang>
Quackery
On some platforms the screen will not be cleared until the output buffer is flushed e.g. by a cr/lf.
<lang Quackery> [ $ &print("\33[2J",end=)& python ] is clearscreen</lang>
R
<lang R>cat("\33[2J")</lang> Or with system calls <lang R># Unix system("clear")
- Windows
system("cls")</lang>
Racket
<lang racket>
- lang racket
(require (planet neil/charterm:3:0)) (with-charterm
(void (charterm-clear-screen)))
</lang>
Raku
(formerly Perl 6) <lang perl6>sub clear { print qx[clear] } clear;</lang>
Retro
<lang Retro>clear</lang>
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
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
The following code works for:
- PC/REXX
- Personal REXX
- CMS REXX
- TSO REXX
- R4 REXX
- ROO REXX
- KEXX
- REXX compiler
- Regina REXX
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.
<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))</lang>
Regina
The regina interpreter supports the rexxcurses plugin, which provides a facility to clear the screen (not shown here).
Ring
<lang Ring>system('clear')</lang>
Ruby
<lang Ruby>system 'clear'</lang>
Or, without reliance on the command line:
(equivalent to `clear`
)
<lang Ruby>puts "\e[H\e[2J"</lang>
Rust
<lang rust>print!("\x1B[2J");</lang>
Or using casting:
<lang rust>print!("{}[2J", 27 as char);</lang>
Scala
<lang Scala>object Cls extends App {print("\033[2J")}</lang>
Seed7
The function clear is portable and clears the 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.
<lang seed7>$ include "seed7_05.s7i";
include "console.s7i";
const proc: main is func
local var text: console is STD_NULL; begin console := open(CONSOLE); clear(console); # Terminal windows often restore the previous # content, when a program is terminated. Therefore # the program waits until Return/Enter is pressed. readln; end func;</lang>
Sidef
Using a cached-function: <lang ruby>func clear { print(static x = `clear`) }; clear();</lang>
Directly invoking the `clear` command: <lang ruby>Sys.run('clear');</lang>
Alternatively, without reliance on the command line: <lang ruby>print "\e[3J\e[H\e[2J";</lang>
Smalltalk
<lang smalltalk>Transcript clear.</lang>
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: <lang smilebasic>CLS</lang>
All screens
Clearing all of the screens, and resetting display options can be done with: <lang smilebasic>ACLS</lang>
SPL
<lang spl>#.clear()</lang>
Standard ML
<lang sml>fun clearScreen () =
let val strm = TextIO.openOut (Posix.ProcEnv.ctermid ()) in TextIO.output (strm, "\^[[H\^[[2J"); TextIO.closeOut strm end</lang>
Stata
The cls command clears the Results window, which is the closest to a terminal in Stata.
Tcl
This only works on systems with ANSI terminal handling, i.e., Unix platforms. <lang tcl>puts -nonewline "\033\[2J" flush stdout</lang>
UNIX Shell
The clear command can be used to clear the terminal screen:
<lang bash>clear
- Alternative method using tput
tput clear</lang>
Visual Basic .NET
<lang vbnet>System.Console.Clear()</lang> Works on all .NET Core platforms. Throws an exception if output has been redirected to a file.
Wren
<lang ecmascript>System.print("\e[2J")</lang>
XPL0
<lang XPL0>code Clear=40; Clear;</lang>
Yabasic
<lang Yabasic>clear screen</lang>
zkl
<lang zkl>System.cmd(System.isWindows and "cls" or "clear"); // or, for ANSI terminals: print("\e[2J")</lang>
- Programming Tasks
- Terminal control
- Initialization
- 11l
- 6502 Assembly
- 8080 Assembly
- AArch64 Assembly
- Action!
- Ada
- ALGOL 68
- ARM Assembly
- Arturo
- AutoHotkey
- AWK
- Axe
- BaCon
- BASIC
- Applesoft BASIC
- Aquarius BASIC
- Atari BASIC
- BASIC256
- BBC BASIC
- Commodore BASIC
- GW-BASIC
- IS-BASIC
- PureBasic
- True BASIC
- Batch File
- Beeswax
- Befunge
- Blast
- Blue
- Bracmat
- C
- C++
- C sharp
- COBOL
- Comal
- Common Lisp
- Ncurses
- D
- Dc
- Delphi
- System.SysUtils
- Winapi.Windows
- System.Console
- Elena
- Erlang
- Euphoria
- F Sharp
- Forth
- Fortran
- FreeBASIC
- Furor
- Go
- Curses
- GUISS
- Haskell
- Icon
- Unicon
- J
- Java
- Jq
- Jsish
- Julia
- Kotlin
- Lasso
- Logo
- Lua
- M2000 Interpreter
- Mathematica
- Wolfram Language
- Nanoquery
- Nemerle
- NewLISP
- Nim
- NS-HUBASIC
- OCaml
- Octave
- Pascal
- Perl
- Phix
- PicoLisp
- PowerShell
- ProDOS
- Python
- Quackery
- R
- Racket
- Raku
- Retro
- REXX
- Ring
- Ruby
- Rust
- Scala
- Seed7
- Sidef
- Smalltalk
- SmileBASIC
- SPL
- Standard ML
- Stata
- Tcl
- UNIX Shell
- Visual Basic .NET
- Wren
- XPL0
- Yabasic
- Zkl
- ACL2/Omit
- Maxima/Omit
- PARI/GP/Omit
- Inform 7/Omit