Terminal control/Clear the screen: Difference between revisions

{{trans|Python}}

To clear the screen on Windows, replace 'clear' with 'cls'

=={{header|6502 Assembly}}==

SYS680

</pre>

; *** labels ***

clr .byte $93 ; the CLR control code

; see https://en.wikipedia.org/wiki/PETSCII

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

lda #$00 ; store the start address of the screen ($200)

inx

bne clearscreen

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

PHA

LDA #$20 ;load the vram address of the top-left nametable

DEX

BNE loop

=={{header|68000 Assembly}}==

The registers <code>D0</code>, <code>D1</code>, and <code>A0</code> will be clobbered after returning, so keep that in mind.

===Sega Genesis===

;input:

;D2.L = what address to write to.

move.w #$8F02,(vdp_ctrl) ;set auto-inc back to 2

MOVEM.L (SP)+,D3-D7

=={{header|8080 Assembly}}==

output, as CP/M was the de facto standard operating system for 8080-based systems.

bdos: equ 5 ; CP/M BDOS entry point

FF: equ 12 ; ASCII form feed

mvi c,putch ; Print character (syscall goes in C register)

mvi e,FF ; Form feed (argument goes in E register)

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program clearScreen.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

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

Put(125)

For systems with ANSI terminal handling:

procedure CLS is

begin

Ada.Text_IO.Put(ASCII.ESC & "[2J");

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

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

Uses the Algol 68G interface to the curses library.

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

bx lr @ return

=={{header|Arturo}}==

=={{header|AutoHotkey}}==

Reference: http://www.autohotkey.com/forum/topic76532.html

=={{header|AWK}}==

=={{header|Axe}}==

=={{header|BaCon}}==

=={{header|BASIC}}==

{{works with|ZX Spectrum Basic}}

{{works with|BBC BASIC}}

==={{header|Applesoft BASIC}}===

==={{header|Aquarius BASIC}}===

==={{header|Atari BASIC}}===

==={{header|BASIC256}}===

y

==={{header|BBC BASIC}}===

or

or

==={{header|Commodore BASIC}}===

{{works with|Commodore BASIC|3.5,7.0}}

(Also works on a VIC-20 with the SuperExpander cartridge)

==={{header|GW-BASIC}}===

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

==={{header|PureBasic}}===

Clears the whole console content using the current background color.

==={{header|True BASIC}}===

=={{header|Batch File}}==

=={{header|beeswax}}==

Using the ANSI escape sequence <code>Esc[2J</code>.

=={{header|Befunge}}==

Assuming a terminal with support for ANSI escape sequences.

=={{header|Blast}}==

=={{header|Blue}}==

Linux/x86

: syscall ( num:eax -- result:eax ) syscall ;

: clear-screen ( -- ) s" \033[2J\033[H" print ;

=={{header|Bracmat}}==

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

If perhaps clear screen isn't used, call the function <code>cls</code> to do the trick.

printf("\33[2J");

Here is the cheaty way no one likes, only works on Windows.

#include <stdlib.h>

getchar();

system("cls");

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#}}==

Works on all .NET Core platforms. Throws an exception if output has been redirected to a file.

=={{header|COBOL}}==

DATA DIVISION.

GOBACK

=={{header|Comal}}==

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

(format t "~C[2J" #\Esc)

or it could be done passing the 'clear' command to the shell

(defun sh (cmd)

"A multi-implementation function equivalent for the C function system"

#+clozure (ccl:run-program "/bin/sh" (list "-c" cmd) :input nil :output *standard-output*))

(sh "clear")

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

;; starting ncurses enters the alternate screen buffer of the terminal

(with-screen (scr :input-echoing nil :input-blocking t)

(refresh scr)

(get-char scr)))

=={{header|D}}==

void disp_open();

void disp_move(int, int);

disp_eeop();

disp_close();

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

Luckily there is a loophole:

===Using a terminal 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").

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

===Stand alone function===

Copy of David Heffrnan on stackoverflow [https://stackoverflow.com/questions/29794559/delphi-console-xe7-clearscreen].

uses

System.SysUtils,

NumWritten));

Win32Check(SetConsoleCursorPosition(stdout, Origin));

===Library System.Console from Jens Borrisholt===

{{libheader| System.Console}}

The System.Console can be found here[https://github.com/JensBorrisholt/DelphiConsole/tree/master/Console]

=={{header|Elena}}==

ELENA 3.4 :

{

console.clear()

=={{header|Erlang}}==

clear()->io:format(os:cmd("clear")).

=={{header|Euphoria}}==

=={{header|F_Sharp|F#}}==

=={{header|Forth}}==

=={{header|Fortran}}==

'''Fortran 2008''':

character(len=:), allocatable :: clear_command

clear_command = "clear" !"cls" on Windows, "clear" on Linux and alike

call execute_command_line(clear_command)

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

use kernel32

implicit none

if (SetConsoleCursorPosition(hConsole, coordScreen) == 0) return

end subroutine

=== GNU Fortran on Windows ===

The preceding program can be compiled with GNU Fortran, with the following interface module for Windows API.

use iso_c_binding

implicit none

end interface

end module

=={{header|FreeBASIC}}==

' FreeBASIC has a built in Cls command which clears the console on Windows

Shell("Cls")

=={{header|Furor}}==

cls

Yet another solution:

."\z"

===External command===

Probably most reliable way to clear the screen.

import (

c.Stdout = os.Stdout

c.Run()

===ANSI escape code===

Simplest, if your terminal supports the ANSI code you want.

import "fmt"

func main() {

fmt.Print("\033[2J")

===Ncurses===

More complex, but works across multiple terminal types.

{{libheader|curses}}

import (

// GetChar() allows you to see the effect of the program before it exits.

s.GetChar() // press any key to continue

=={{header|GUISS}}==

This will only work if the terminal is sitting at a prompt.

=={{header|Haskell}}==

import System.Console.ANSI

main = clearScreen

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

if &features == "MS Windows" then system("cls") # Windows

else if &features == "UNIX" then system("clear") # Unix

=={{header|J}}==

Note: this is specific the java+gdi based J ide.

=={{header|Java}}==

Using the ANSI escape sequence:

{

public static void main (String[] args)

System.out.print("\033[2J");

}

An alternative sequence:

{

public static void main (String[] args)

System.out.print("\033\143");

}

=={{header|jq}}==

'''Example''':

=={{header|Jsish}}==

Using ANSI terminal control codes.

function cls() { printf('\u001b[2J'); }

cls() ==> ^[[2Jundefined

=!EXPECTEND!=

{{out}}

=={{header|Julia}}==

println("\33[2J")

=={{header|Kotlin}}==

{{works with|Ubuntu|14.04}}

fun main(args: Array<String>) {

println("\u001Bc") // Esc + c

=={{header|Lasso}}==

esc = decode_base64('Gw==')

)

=={{header|Logo}}==

There is a separate command to reset the turtle graphics window.

cs ; abbreviation for clearscreen

=={{header|Lua}}==

===Unix, Linux===

===Windows===

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

Module Checkit {

Pen 14 ' yellow

}

checkit

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

Delegating to clear on terminal enabled OS(Mac Os, Linux)

=={{header|Nanoquery}}==

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

rather than importing the <tt>Console</tt> class with <tt>using System.Console;</tt> and calling as:

=={{header|NewLISP}}==

(! "clear")

In the newLISP command shell, this syntax is also proper:

!clear

=={{header|Nim}}==

import terminal

eraseScreen() #puts cursor at down

setCursorPos(0, 0)

=={{header|NS-HUBASIC}}==

=={{header|OCaml}}==

Using the library [http://forge.ocamlcore.org/projects/ansiterminal/ ANSITerminal]:

#directory "+ANSITerminal"

#load "ANSITerminal.cma"

let () =

=={{header|Octave}}==

=={{header|Pascal}}==

=={{header|Perl}}==

Assuming some ANSI terminal, easiest way is call your system's clear command:

If it's needed often:

#... later:

We can also obtain the sequence using the Term::Cap module:

$terminal = Term::Cap->Tgetent();

$clear = $terminal->Tputs('cl');

=={{header|Phix}}==

<span style="color: #7060A8;">clear_screen</span><span style="color: #0000FF;">()</span>

=={{header|PicoLisp}}==

=={{header|Pike}}==

Process.system("clear");

return 0;

Use "cls" instead of "clear" for Windows

=={{header|PowerShell}}==

=={{header|ProDOS}}==

=={{header|Python}}==

To clear the screen on Windows, replace 'clear' with 'cls'

Or similar to C example (won't work in Winsows console, since it does not recognize ANSI sequences):

On Windows, using functions from the kernel32 DLL:

STD_OUTPUT_HANDLE = -11

windll.kernel32.SetConsoleCursorPosition(h, scr)

=={{header|Quackery}}==

On some platforms the screen will not be cleared until the output buffer is flushed e.g. by a cr/lf.

=={{header|R}}==

Or with system calls

system("clear")

# Windows

=={{header|Racket}}==

#lang racket

(require (planet neil/charterm:3:0))

(with-charterm

(void (charterm-clear-screen)))

=={{header|Raku}}==

(formerly Perl 6)

=={{header|Retro}}==

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

trace off; parse arg ! /*turn off tracing; get C.L. args*/

if !all(arg()) then exit /*Doc request? Show, then exit.*/

!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

===Regina===

=={{header|Ring}}==

=={{header|Ruby}}==

Or, without reliance on the command line:

(equivalent to <code>`clear`</code>)

=={{header|Rust}}==

Or using casting:

=={{header|Scala}}==

{{libheader|Scala}}

=={{header|Seed7}}==

since not all terminals accept them.

include "console.s7i";

# the program waits until Return/Enter is pressed.

readln;

=={{header|Sidef}}==

Using a cached-function:

Directly invoking the `clear` command:

Alternatively, without reliance on the command line:

=={{header|Smalltalk}}==

=={{header|SmileBASIC}}==

===Text screen only===

To clear just the text screen:

===All screens===

Clearing all of the screens, and resetting display options can be done with:

=={{header|SPL}}==

=={{header|Standard ML}}==

{{works with|Unix}}

let

val strm = TextIO.openOut (Posix.ProcEnv.ctermid ())

TextIO.output (strm, "\^[[H\^[[2J");

TextIO.closeOut strm

=={{header|Stata}}==

=={{header|Tcl}}==

This only works on systems with ANSI terminal handling, i.e., Unix platforms.

=={{header|UNIX Shell}}==

{{works with|Bourne Shell}}

# Alternative method using tput

=={{header|Visual Basic .NET}}==

Works on all .NET Core platforms. Throws an exception if output has been redirected to a file.

=={{header|Wren}}==

=={{header|XPL0}}==

=={{header|Yabasic}}==

=={{header|zkl}}==

{{omit from|ACL2}}