Terminal control/Clear the screen: Difference between revisions

Content added Content deleted

Inline

Revision as of 18:32, 24 August 2017

Clear the terminal window.

6502 Assembly

Works with: [VICE]

This example has been written for the C64 and uses the CHROUT KERNAL 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>

Works with: [6502asm.com] version 1.2

Works with: [6502asm.com] version 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). <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>

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>

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>

BASIC

Works with: QBasic

Works with: Locomotive Basic

Works with: ZX Spectrum Basic

Works with: BBC BASIC

Applesoft BASIC

BBC BASIC

<lang bbcbasic> CLS</lang> or <lang bbcbasic> VDU 12</lang> or <lang bbcbasic> PRINT CHR$(12);</lang>

GW-BASIC

PureBasic

Clears the whole console content using the current background color. <lang PureBasic>ClearConsole()</lang>

Batch File

beeswax

Using the ANSI escape sequence Esc[2J.

Befunge

Assuming a terminal with support for ANSI escape sequences. <lang befunge>"J2["39*,,,,@</lang>

Blast

<lang blast>clear</lang>

Bracmat

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>

C#

<lang csharp>System.Console.Clear();</lang>

COBOL

<lang cobol> PROGRAM-ID. blank-terminal.

      DATA DIVISION.
      SCREEN SECTION.
      01  blank-screen BLANK SCREEN.
      
      PROCEDURE DIVISION.
          DISPLAY blank-screen

          GOBACK
          .</lang>

Comal

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>

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>

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

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>

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.

Library: curses

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

Julia

<lang julia> println("\33[2J") </lang>

Kotlin

Works with: Ubuntu version 14.04

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

Mathematica

Delegating to clear on terminal enabled OS(Mac Os, Linux) <lang Mathematica>Run["clear"];</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 osproc discard execCmd "clear"</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>

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>

Perl 6

<lang perl6>sub clear { print state $ = qx[clear] } clear;</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

Works with: Python version 2.6

Works with: Ubuntu version 10.10

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>

Racket

lang racket

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

(void (charterm-clear-screen)))

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

Scala

Library: Scala

<lang Scala>object Cls extends App {print("\033[2J")}</lang>

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>

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>

<lang bash>clear

Alternative method using tput

tput clear</lang>

XPL0

<lang XPL0>code Clear=40; Clear;</lang>

zkl

<lang zkl>System.cmd(System.isWindows and "cls" or "clear"); // or, for ANSI terminals: print("\e[2J")</lang>

@@ Line 498: / Line 498: @@
 =={{header|Lua}}==
+===Unix, Linux===
 <lang lua>os.execute( "clear" )</lang>
-will not work because "clear" is not a command
+===Windows===
-although you can use
 <lang lua>os.execute( "cls" )</lang>