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
Puppydrum64 (talk | contribs) m (→Sega Genesis) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
(7 intermediate revisions by 7 users not shown) | |||
Line 9:
{{trans|Python}}
To clear the screen on Windows, replace 'clear' with 'cls'
<syntaxhighlight lang
=={{header|6502 Assembly}}==
Line 23:
SYS680
</pre>
<
; *** labels ***
Line 42:
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).
<
lda #$00 ; store the start address of the screen ($200)
Line 78:
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.
<
PHA
LDA #$20 ;load the vram address of the top-left nametable
Line 97:
DEX
BNE loop
RTS</
=={{header|68000 Assembly}}==
Line 104:
The registers <code>D0</code>, <code>D1</code>, and <code>A0</code> will be clobbered after returning, so keep that in mind.
<
JSR $C004C8 ;clear hardware sprites</
===Sega Genesis===
Line 119:
<
;input:
;D2.L = what address to write to.
Line 173:
move.w #$8F02,(vdp_ctrl) ;set auto-inc back to 2
MOVEM.L (SP)+,D3-D7
RTR</
=={{header|8080 Assembly}}==
Line 183:
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
Line 189:
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</
=={{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 */
Line 248:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
=={{header|Action!}}==
<
Put(125)
return</
Line 260:
For systems with ANSI terminal handling:
<
procedure CLS is
begin
Ada.Text_IO.Put(ASCII.ESC & "[2J");
end CLS;</
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
Uses the Algol 68G interface to the curses library.
<
curses clear # clear the screen #</
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
Line 342:
bx lr @ return
</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang
=={{header|AutoHotkey}}==
Reference: http://www.autohotkey.com/forum/topic76532.html
<syntaxhighlight lang
=={{header|AWK}}==
<
=={{header|Axe}}==
<syntaxhighlight lang
=={{header|BaCon}}==
<syntaxhighlight lang
=={{header|BASIC}}==
Line 366:
{{works with|ZX Spectrum Basic}}
{{works with|BBC BASIC}}
<syntaxhighlight lang
==={{header|Applesoft BASIC}}===
<syntaxhighlight lang
==={{header|Aquarius BASIC}}===
<syntaxhighlight lang="aquarius
==={{header|Atari BASIC}}===
<syntaxhighlight lang="atari
==={{header|BASIC256}}===
<
#Borra la ventana de texto</
y
<
#Borra la ventana de gráficos</
==={{header|BBC BASIC}}===
<syntaxhighlight lang
or
<syntaxhighlight lang
or
<
==={{header|Commodore BASIC}}===
<syntaxhighlight lang="commodore
{{works with|Commodore BASIC|3.5,7.0}}
(Also works on a VIC-20 with the SuperExpander cartridge)
<syntaxhighlight lang
==={{header|GW-BASIC}}===
<syntaxhighlight lang
==={{header|IS-BASIC}}===
<syntaxhighlight lang
==={{header|PureBasic}}===
Clears the whole console content using the current background color.
<syntaxhighlight lang
==={{header|True BASIC}}===
<
END</
=={{header|Batch File}}==
<syntaxhighlight lang
=={{header|beeswax}}==
Line 421:
Using the ANSI escape sequence <code>Esc[2J</code>.
<syntaxhighlight lang
=={{header|Befunge}}==
Assuming a terminal with support for ANSI escape sequences.
<
=={{header|Blast}}==
<syntaxhighlight lang
=={{header|Blue}}==
Line 435:
Linux/x86
<
: syscall ( num:eax -- result:eax ) syscall ;
Line 449:
: clear-screen ( -- ) s" \033[2J\033[H" print ;
: _start ( -- noret ) clear-screen bye ;</
=={{header|Bracmat}}==
<syntaxhighlight lang
=={{header|C}} / {{header|C++}}==
Line 459:
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>
Line 472:
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#}}==
<syntaxhighlight lang
Works on all .NET Core platforms. Throws an exception if output has been redirected to a file.
=={{header|COBOL}}==
<
DATA DIVISION.
Line 491:
GOBACK
.</
=={{header|Comal}}==
<syntaxhighlight lang
=={{header|Common Lisp}}==
<
(format t "~C[2J" #\Esc)
</syntaxhighlight>
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"
Line 509:
#+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.
<
;; starting ncurses enters the alternate screen buffer of the terminal
(with-screen (scr :input-echoing nil :input-blocking t)
Line 523:
(refresh scr)
(get-char scr)))
;; leaving ncurses returns the terminal to the main screen buffer</
=={{header|D}}==
<
void disp_open();
void disp_move(int, int);
Line 538:
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:
<syntaxhighlight lang
Luckily there is a loophole:
<syntaxhighlight lang
===Using a terminal control sequence===
Line 551:
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
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
Line 557:
===Stand alone function===
Copy of David Heffrnan on stackoverflow [https://stackoverflow.com/questions/29794559/delphi-console-xe7-clearscreen].
<syntaxhighlight lang="delphi">
uses
System.SysUtils,
Line 581:
NumWritten));
Win32Check(SetConsoleCursorPosition(stdout, Origin));
end;</
===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
=={{header|Elena}}==
ELENA 3.4 :
<
{
console.clear()
}</
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
clear()->io:format(os:cmd("clear")).
</syntaxhighlight>
=={{header|Euphoria}}==
<syntaxhighlight lang
=={{header|F_Sharp|F#}}==
<
Console.Clear()</
=={{header|Forth}}==
<syntaxhighlight lang
=={{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)
end program</
=== 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
Line 647:
if (SetConsoleCursorPosition(hConsole, coordScreen) == 0) return
end subroutine
end program</
=== 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
Line 748:
end interface
end module
</syntaxhighlight>
=={{header|FreeBASIC}}==
<
' FreeBASIC has a built in Cls command which clears the console on Windows
Line 758:
Shell("Cls")
Sleep</
=={{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.
<
import (
Line 785 ⟶ 793:
c.Stdout = os.Stdout
c.Run()
}</
===ANSI escape code===
Simplest, if your terminal supports the ANSI code you want.
<
import "fmt"
Line 795 ⟶ 803:
func main() {
fmt.Print("\033[2J")
}</
===Ncurses===
More complex, but works across multiple terminal types.
{{libheader|curses}}
<
import (
Line 823 ⟶ 831:
// 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.
<syntaxhighlight lang
=={{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.
<
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
=={{header|Java}}==
Using the ANSI escape sequence:
<
{
public static void main (String[] args)
Line 856 ⟶ 864:
System.out.print("\033[2J");
}
}</
An alternative sequence:
<
{
public static void main (String[] args)
Line 864 ⟶ 872:
System.out.print("\033\143");
}
}</
=={{header|jq}}==
<
'''Example''':
<
=={{header|Jsish}}==
Using ANSI terminal control codes.
<
function cls() { printf('\u001b[2J'); }
Line 882 ⟶ 890:
cls() ==> ^[[2Jundefined
=!EXPECTEND!=
*/</
{{out}}
Line 889 ⟶ 897:
=={{header|Julia}}==
<
println("\33[2J")
</syntaxhighlight>
=={{header|Kotlin}}==
{{works with|Ubuntu|14.04}}
<
fun main(args: Array<String>) {
println("\u001Bc") // Esc + c
}</
=={{header|Lang}}==
<syntaxhighlight lang="lang">
# \E is an escape sequence for the ESC ascii code
fn.println(\E[2J)
</syntaxhighlight>
=={{header|Lasso}}==
<
esc = decode_base64('Gw==')
)
stdout(#esc + '[2J')</
=={{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===
<
===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.
<syntaxhighlight lang="m2000 interpreter">
Module Checkit {
Pen 14 ' yellow
Line 959 ⟶ 973:
}
checkit
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Delegating to clear on terminal enabled OS(Mac Os, Linux)
<
=={{header|min}}==
<syntaxhighlight lang="min">clear</syntaxhighlight>
=={{header|Nanoquery}}==
<syntaxhighlight lang
=={{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
rather than importing the <tt>Console</tt> class with <tt>using System.Console;</tt> and calling as:
<syntaxhighlight lang
=={{header|NewLISP}}==
<syntaxhighlight lang="newlisp">
(! "clear")
</syntaxhighlight>
In the newLISP command shell, this syntax is also proper:
<syntaxhighlight lang="newlisp">
!clear
</syntaxhighlight>
=={{header|Nim}}==
<
import terminal
eraseScreen() #puts cursor at down
setCursorPos(0, 0)
</syntaxhighlight>
=={{header|NS-HUBASIC}}==
<syntaxhighlight lang
=={{header|OCaml}}==
Line 998 ⟶ 1,015:
Using the library [http://forge.ocamlcore.org/projects/ansiterminal/ ANSITerminal]:
<
#directory "+ANSITerminal"
#load "ANSITerminal.cma"
Line 1,004 ⟶ 1,021:
let () =
erase Screen</
=={{header|Octave}}==
<syntaxhighlight lang
<syntaxhighlight lang
=={{header|Pascal}}==
<syntaxhighlight lang
<syntaxhighlight lang
=={{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:
<
$terminal = Term::Cap->Tgetent();
$clear = $terminal->Tputs('cl');
print $clear;</
<
system('cls');</
=={{header|Phix}}==
<!--<
<span style="color: #7060A8;">clear_screen</span><span style="color: #0000FF;">()</span>
<!--</
=={{header|PicoLisp}}==
<syntaxhighlight lang
=={{header|Pike}}==
<
Process.system("clear");
return 0;
}</
Use "cls" instead of "clear" for Windows
=={{header|PowerShell}}==
<syntaxhighlight lang
=={{header|ProDOS}}==
<syntaxhighlight lang
=={{header|Python}}==
Line 1,063 ⟶ 1,080:
To clear the screen on Windows, replace 'clear' with 'cls'
<
os.system("clear")</
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
Line 1,109 ⟶ 1,126:
windll.kernel32.SetConsoleCursorPosition(h, scr)
clear_console()</
=={{header|Quackery}}==
Line 1,118 ⟶ 1,135:
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
system("cls")</
=={{header|Racket}}==
<
#lang racket
(require (planet neil/charterm:3:0))
(with-charterm
(void (charterm-clear-screen)))
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku"
clear;</
=={{header|Retro}}==
<syntaxhighlight lang
=={{header|REXX}}==
Line 1,173 ⟶ 1,190:
<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.*/
Line 1,188 ⟶ 1,205:
!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))</
===Regina===
Line 1,195 ⟶ 1,212:
=={{header|Ring}}==
<syntaxhighlight lang
=={{header|RPL}}==
CLLCD
=={{header|Ruby}}==
<syntaxhighlight lang
Or, without reliance on the command line:
(equivalent to <code>`clear`</code>)
<
Probably more platform-independent:
<syntaxhighlight lang="ruby">require 'io/console'
STDOUT.clear_screen
</syntaxhighlight>
=={{header|Rust}}==
<
Or using casting:
<
=={{header|Scala}}==
{{libheader|Scala}}
<
=={{header|Seed7}}==
Line 1,224 ⟶ 1,248:
since not all terminals accept them.
<
include "console.s7i";
Line 1,237 ⟶ 1,261:
# the program waits until Return/Enter is pressed.
readln;
end func;</
=={{header|Sidef}}==
Using a cached-function:
<
clear();</
Directly invoking the `clear` command:
<syntaxhighlight lang
Alternatively, without reliance on the command line:
<
=={{header|Smalltalk}}==
<syntaxhighlight lang
=={{header|SmileBASIC}}==
Line 1,257 ⟶ 1,281:
===Text screen only===
To clear just the text screen:
<syntaxhighlight lang
===All screens===
Clearing all of the screens, and resetting display options can be done with:
<syntaxhighlight lang
=={{header|SPL}}==
<syntaxhighlight lang
=={{header|Standard ML}}==
{{works with|Unix}}
<
let
val strm = TextIO.openOut (Posix.ProcEnv.ctermid ())
Line 1,273 ⟶ 1,297:
TextIO.output (strm, "\^[[H\^[[2J");
TextIO.closeOut strm
end</
=={{header|Stata}}==
Line 1,281 ⟶ 1,305:
=={{header|Tcl}}==
This only works on systems with ANSI terminal handling, i.e., Unix platforms.
<
flush stdout</
=={{header|UNIX Shell}}==
Line 1,290 ⟶ 1,314:
{{works with|Bourne Shell}}
<
# Alternative method using tput
tput clear</
=={{header|Visual Basic .NET}}==
<syntaxhighlight lang
Works on all .NET Core platforms. Throws an exception if output has been redirected to a file.
=={{header|Wren}}==
<
=={{header|XPL0}}==
<
Clear;</
=={{header|Yabasic}}==
<syntaxhighlight lang
=={{header|zkl}}==
<
// or, for ANSI terminals: print("\e[2J")</
{{omit from|ACL2}}
|