Terminal control/Cursor positioning: Difference between revisions
(Added Axe) |
(PascalABC.NET) |
||
(59 intermediate revisions by 29 users not shown) | |||
Line 1: | Line 1: | ||
{{task|Terminal control}} |
{{task|Terminal control}} |
||
Move the cursor to column 3, row 6 and display the word "Hello", so that the letter H is in column 3 on row 6. |
|||
[[Terminal Control::task| ]] |
[[Terminal Control::task| ]] |
||
;Task: |
|||
Move the cursor to column '''3''', row '''6''', and display the word "Hello" (without the quotes), so that the letter '''H''' is in column '''3''' on row '''6'''. |
|||
<br><br> |
|||
=={{header|AArch64 Assembly}}== |
|||
{{works with|as|Raspberry Pi 3B version Buster 64 bits}} |
|||
<syntaxhighlight lang="aarch64 assembly"> |
|||
/* ARM assembly AARCH64 Raspberry PI 3B */ |
|||
/* program cursorPos64.s */ |
|||
/*******************************************/ |
|||
/* Constantes file */ |
|||
/*******************************************/ |
|||
/* for this file see task include a file in language AArch64 assembly*/ |
|||
.include "../includeConstantesARM64.inc" |
|||
/*******************************************/ |
|||
/* Initialized data */ |
|||
/*******************************************/ |
|||
.data |
|||
szMessStartPgm: .asciz "Program start \n" |
|||
szMessEndPgm: .asciz "Program normal end.\n" |
|||
szMessMovePos: .asciz "\033[6;3HHello\n" |
|||
szCarriageReturn: .asciz "\n" |
|||
szCleax1: .byte 0x1B |
|||
.byte 'c' // other console clear |
|||
.byte 0 |
|||
/*******************************************/ |
|||
/* UnInitialized data */ |
|||
/*******************************************/ |
|||
.bss |
|||
/*******************************************/ |
|||
/* code section */ |
|||
/*******************************************/ |
|||
.text |
|||
.global main |
|||
main: |
|||
ldr x0,qAdrszMessStartPgm // display start message |
|||
bl affichageMess |
|||
ldr x0,qAdrszCleax1 |
|||
bl affichageMess |
|||
ldr x0,qAdrszMessMovePos |
|||
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 |
|||
qAdrszCarriageReturn: .quad szCarriageReturn |
|||
qAdrszCleax1: .quad szCleax1 |
|||
qAdrszMessMovePos: .quad szMessMovePos |
|||
/********************************************************/ |
|||
/* 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() |
|||
Position(3,6) |
|||
Print("Hello") |
|||
RETURN</syntaxhighlight> |
|||
{{out}} |
|||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Cursor_positioning.png Screenshot from Atari 8-bit computer] |
|||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
< |
<syntaxhighlight lang="ada">with Ada.Text_IO; |
||
procedure Cursor_Pos is |
procedure Cursor_Pos is |
||
Line 13: | Line 83: | ||
Ada.Text_IO.Set_Col(3); |
Ada.Text_IO.Set_Col(3); |
||
Ada.Text_IO.Put("Hello"); |
Ada.Text_IO.Put("Hello"); |
||
end Cursor_Pos;</ |
end Cursor_Pos;</syntaxhighlight> |
||
=={{header|ARM Assembly}}== |
|||
{{works with|as|Raspberry Pi}} |
|||
<syntaxhighlight lang="arm assembly"> |
|||
/* ARM assembly Raspberry PI */ |
|||
/* program cursorPos.s */ |
|||
/* Constantes */ |
|||
.equ STDOUT, 1 @ Linux output console |
|||
.equ EXIT, 1 @ Linux syscall |
|||
.equ WRITE, 4 @ Linux syscall |
|||
/* Initialized data */ |
|||
.data |
|||
szMessStartPgm: .asciz "Program start \n" |
|||
szMessEndPgm: .asciz "Program normal end.\n" |
|||
szMessMovePos: .asciz "\033[6;3HHello\n" |
|||
szCarriageReturn: .asciz "\n" |
|||
szClear1: .byte 0x1B |
|||
.byte 'c' @ other console clear |
|||
.byte 0 |
|||
/* UnInitialized data */ |
|||
.bss |
|||
/* code section */ |
|||
.text |
|||
.global main |
|||
main: |
|||
ldr r0,iAdrszMessStartPgm @ display start message |
|||
bl affichageMess |
|||
ldr r0,iAdrszClear1 |
|||
bl affichageMess |
|||
ldr r0,iAdrszMessMovePos |
|||
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 |
|||
iAdrszCarriageReturn: .int szCarriageReturn |
|||
iAdrszClear1: .int szClear1 |
|||
iAdrszMessMovePos: .int szMessMovePos |
|||
/******************************************************************/ |
|||
/* 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">goto 3 6 |
|||
print "Hello"</syntaxhighlight> |
|||
=={{header|AutoHotkey}}== |
=={{header|AutoHotkey}}== |
||
{{works with|AutoHotkey_L}} |
{{works with|AutoHotkey_L}} |
||
Remember that AHK is not built for the console, so we must call the WinAPI directly. |
Remember that AHK is not built for the console, so we must call the WinAPI directly. |
||
< |
<syntaxhighlight lang="ahk">DllCall( "AllocConsole" ) ; create a console if not launched from one |
||
hConsole := DllCall( "GetStdHandle", int, STDOUT := -11 ) |
hConsole := DllCall( "GetStdHandle", int, STDOUT := -11 ) |
||
Line 32: | Line 179: | ||
return out |
return out |
||
return 0 |
return 0 |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Axe}}== |
=={{header|Axe}}== |
||
Since the rows and columns are zero-indexed, we must subtract 1 from both. |
|||
<lang axe>Output(6,3,"HELLO")</lang> |
|||
<syntaxhighlight lang="axe">Output(2,5,"HELLO")</syntaxhighlight> |
|||
=={{header|BASIC}}== |
=={{header|BASIC}}== |
||
==={{header|Applesoft BASIC}}=== |
|||
<syntaxhighlight lang="applesoft basic"> 10 VTAB 6: HTAB 3 |
|||
20 PRINT "HELLO"</syntaxhighlight> |
|||
==={{header|ASIC}}=== |
|||
Rows have the range 0-24, columns have the range 0-79. |
|||
<syntaxhighlight lang="basic"> |
|||
LOCATE 5, 2 |
|||
PRINT "Hello" |
|||
</syntaxhighlight> |
|||
==={{header|BaCon}}=== |
|||
<syntaxhighlight lang="freebasic">' Cursor positioning, requires ANSI compliant terminal |
|||
GOTOXY 3,6 |
|||
PRINT "Hello"</syntaxhighlight> |
|||
The X Y in <code>GOTOXY</code> is Column Row order. |
|||
==={{header|BBC BASIC}}=== |
|||
<syntaxhighlight lang="bbcbasic">PRINT TAB(2,5);"Hello"</syntaxhighlight> |
|||
==={{header|Commodore BASIC}}=== |
|||
{{works with|Commodore BASIC|3.5}} |
|||
<syntaxhighlight lang="basic"> |
|||
10 CHAR ,2,5,"HELLO" |
|||
</syntaxhighlight> |
|||
{{works with|Commodore BASIC|2.0}} |
|||
<syntaxhighlight lang="basic"> 100 print chr$(19) :rem change to lowercase set |
|||
110 print chr$(14) :rem go to position 1,1 |
|||
120 print:print:print:print |
|||
130 print tab(2) "Hello" </syntaxhighlight> |
|||
==={{header|FreeBASIC}}=== |
|||
<syntaxhighlight lang="freebasic">Locate 6, 3 : Print "Hello" |
|||
Sleep</syntaxhighlight> |
|||
==={{header|GW-BASIC}}=== |
|||
{{works with|BASICA}} |
|||
<syntaxhighlight lang="gwbasic"> |
|||
10 LOCATE 6, 3 |
|||
20 PRINT "Hello" |
|||
</syntaxhighlight> |
|||
==={{header|IS-BASIC}}=== |
|||
<syntaxhighlight lang="is-basic">100 PRINT AT 6,3:"Hello"</syntaxhighlight> |
|||
==={{header|Liberty BASIC}}=== |
|||
<syntaxhighlight lang="lb">locate 3, 6 |
|||
print "Hello" |
|||
</syntaxhighlight> |
|||
==={{header|Locomotive Basic}}=== |
|||
<syntaxhighlight lang="locobasic"> 10 LOCATE 3,6 |
|||
20 PRINT "Hello"</syntaxhighlight> |
|||
==={{header|MSX Basic}}=== |
|||
<syntaxhighlight lang="basic"> 10 LOCATE 2,5 |
|||
20 PRINT "Hello"</syntaxhighlight> |
|||
==={{header|Nascom BASIC}}=== |
|||
Line 16 is at the top of the screen and is not scrolled. Line 1 is the next line down, and line 15 is at the bottom. |
|||
{{works with|Nascom ROM BASIC|4.7}} |
|||
<syntaxhighlight lang="basic"> |
|||
10 SCREEN 3,5:PRINT "Hello" |
|||
</syntaxhighlight> |
|||
==={{header|NS-HUBASIC}}=== |
|||
<syntaxhighlight lang="basic">10 LOCATE 3,6 |
|||
20 PRINT "HELLO"</syntaxhighlight> |
|||
==={{header|PureBasic}}=== |
|||
<syntaxhighlight lang="purebasic">EnableGraphicalConsole(#True) |
|||
ConsoleLocate(3,6) |
|||
Print("Hello")</syntaxhighlight> |
|||
=== |
==={{header|QuickBASIC}}=== |
||
{{works with|QBasic}} |
|||
<lang Applesoft BASIC> 10 VTAB 6: HTAB 3 |
|||
{{works with|RapidQ}} |
|||
20 PRINT "HELLO"</lang> |
|||
<syntaxhighlight lang="qbasic"> |
|||
LOCATE 6, 3 |
|||
PRINT "Hello" |
|||
</syntaxhighlight> |
|||
=== |
==={{header|RapidQ}}=== |
||
See [[#QuickBASIC|QuickBASIC]]. |
|||
<lang locobasic> 10 LOCATE 3,6 |
|||
20 PRINT "Hello"</lang> |
|||
=== |
==={{header|ZX Spectrum Basic}}=== |
||
< |
<syntaxhighlight lang="zxbasic"> 10 REM The top left corner is at position 0,0 |
||
20 REM So we subtract one from the coordinates |
20 REM So we subtract one from the coordinates |
||
30 PRINT AT 5,2 "Hello"</ |
30 PRINT AT 5,2 "Hello"</syntaxhighlight> |
||
=={{header| |
=={{header|Befunge}}== |
||
Assuming a terminal with support for ANSI escape sequences. |
|||
<lang bbcbasic>PRINT TAB(2,5);"Hello"</lang> |
|||
<syntaxhighlight lang="befunge">0"olleHH3;6["39*>:#,_$@</syntaxhighlight> |
|||
=={{header|Blast}}== |
=={{header|Blast}}== |
||
< |
<syntaxhighlight lang="blast"># This will display a message at a specific position on the terminal screen |
||
.begin |
.begin |
||
cursor 6,3 |
cursor 6,3 |
||
display "Hello!" |
display "Hello!" |
||
return |
return |
||
# This is the end of the script</ |
# This is the end of the script</syntaxhighlight> |
||
=={{header|C/C++}}== |
=={{header|C}}/{{header|C++}}== |
||
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x:< |
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x:<syntaxhighlight lang="c">#include <stdio.h> |
||
int main() |
int main() |
||
{ |
{ |
||
printf("\033[6;3HHello\n"); |
printf("\033[6;3HHello\n"); |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
The C version of the minesweeper game uses curses. |
The C version of the minesweeper game uses curses. |
||
[[Minesweeper_game#C]] |
[[Minesweeper_game#C]] |
||
On Windows, using console API: |
|||
<syntaxhighlight lang="c">#include <windows.h> |
|||
int main() { |
|||
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); |
|||
COORD pos = {3, 6}; |
|||
SetConsoleCursorPosition(hConsole, pos); |
|||
WriteConsole(hConsole, "Hello", 5, NULL, NULL); |
|||
return 0; |
|||
}</syntaxhighlight> |
|||
=={{header|C sharp|C#}}== |
=={{header|C sharp|C#}}== |
||
{{works with|Mono|1.2}} |
{{works with|Mono|1.2}} |
||
{{works with|Visual C sharp|Visual C#|2003}} |
{{works with|Visual C sharp|Visual C#|2003}} |
||
< |
<syntaxhighlight lang="csharp">static void Main(string[] args) |
||
{ |
{ |
||
Console.SetCursorPosition(3, 6); |
Console.SetCursorPosition(3, 6); |
||
Console.Write("Hello"); |
Console.Write("Hello"); |
||
}</ |
}</syntaxhighlight> |
||
=={{header|COBOL}}== |
=={{header|COBOL}}== |
||
< |
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION. |
||
PROGRAM-ID. cursor-positioning. |
PROGRAM-ID. cursor-positioning. |
||
Line 91: | Line 328: | ||
GOBACK |
GOBACK |
||
.</ |
.</syntaxhighlight> |
||
=={{header|Common Lisp}}== |
|||
==={{header|ncurses}}=== |
|||
To interface the ncurses C library from Lisp, the ''croatoan'' library is used. |
|||
<syntaxhighlight lang="lisp">(defun cursor-positioning () |
|||
(with-screen (scr :input-blocking t :input-echoing nil :cursor-visible nil) |
|||
(move scr 5 2) |
|||
(princ "Hello" scr) |
|||
(refresh scr) |
|||
;; wait for keypress |
|||
(get-char scr)))</syntaxhighlight> |
|||
=={{header|D}}== |
|||
ANSI escape sequences allow you to move the cursor anywhere on the screen. See more at: [http://www.tldp.org/HOWTO/Bash-Prompt-HOWTO/x361.html Bash Prompt HowTo - Chapter 6. ANSI Escape Sequences: Colours and Cursor Movement] |
|||
Position the Cursor: |
|||
\033[<L>;<C>H |
|||
or |
|||
\033[<L>;<C>f |
|||
puts the cursor at line L and column C. |
|||
<syntaxhighlight lang="d"> |
|||
import std.stdio; |
|||
void main() |
|||
{ |
|||
writef("\033[6;3fHello"); |
|||
} |
|||
</syntaxhighlight> |
|||
'''Output:''' |
|||
0123456789 |
|||
1 |
|||
2 |
|||
3 |
|||
4 |
|||
5 |
|||
6 Hello |
|||
9 |
|||
8 |
|||
9 |
|||
=={{header|Elena}}== |
|||
ELENA 4.x : |
|||
<syntaxhighlight lang="elena">public program() |
|||
{ |
|||
console.setCursorPosition(3,6).write("Hello") |
|||
}</syntaxhighlight> |
|||
=={{header|Euphoria}}== |
=={{header|Euphoria}}== |
||
< |
<syntaxhighlight lang="euphoria">position(6,3) |
||
puts(1,"Hello")</ |
puts(1,"Hello")</syntaxhighlight> |
||
=={{header|F_Sharp|F#}}== |
=={{header|F_Sharp|F#}}== |
||
< |
<syntaxhighlight lang="fsharp">open System |
||
Console.SetCursorPosition(3, 6) |
Console.SetCursorPosition(3, 6) |
||
Console.Write("Hello")</ |
Console.Write("Hello")</syntaxhighlight> |
||
=={{header|Forth}}== |
=={{header|Forth}}== |
||
< |
<syntaxhighlight lang="forth">2 5 at-xy ." Hello"</syntaxhighlight> |
||
=={{header|Fortran}}== |
|||
===Intel Fortran on Windows=== |
|||
<syntaxhighlight lang="fortran">program textposition |
|||
use kernel32 |
|||
implicit none |
|||
integer(HANDLE) :: hConsole |
|||
integer(BOOL) :: q |
|||
hConsole = GetStdHandle(STD_OUTPUT_HANDLE) |
|||
q = SetConsoleCursorPosition(hConsole, T_COORD(3, 6)) |
|||
q = WriteConsole(hConsole, loc("Hello"), 5, NULL, NULL) |
|||
end program</syntaxhighlight> |
|||
=={{header|Go}}== |
=={{header|Go}}== |
||
===External command=== |
===External command=== |
||
< |
<syntaxhighlight lang="go">package main |
||
import ( |
import ( |
||
Line 123: | Line 421: | ||
cmd.Run() |
cmd.Run() |
||
fmt.Println("Hello") |
fmt.Println("Hello") |
||
}</ |
}</syntaxhighlight> |
||
===ANSI escape codes=== |
===ANSI escape codes=== |
||
< |
<syntaxhighlight lang="go">package main |
||
import "fmt" |
import "fmt" |
||
Line 131: | Line 429: | ||
func main() { |
func main() { |
||
fmt.Println("\033[2J\033[6;3HHello") |
fmt.Println("\033[2J\033[6;3HHello") |
||
}</ |
}</syntaxhighlight> |
||
===Ncurses=== |
===Ncurses=== |
||
{{libheader|curses}} |
{{libheader|curses}} |
||
< |
<syntaxhighlight lang="go">package main |
||
import ( |
import ( |
||
Line 151: | Line 449: | ||
s.Println("Hello") |
s.Println("Hello") |
||
s.GetChar() |
s.GetChar() |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Icon}} and {{header|Unicon}}== |
|||
If the OS has older termcap files, CUP is included with <tt>link ansi</tt> |
|||
<syntaxhighlight lang="unicon">procedure main() |
|||
writes(CUP(6,3), "Hello") |
|||
end |
|||
procedure CUP(i,j) |
|||
writes("\^[[",i,";",j,"H") |
|||
return |
|||
end</syntaxhighlight> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
Using terminal positioning verbs of [[Terminal_control/Coloured_text#J]] |
Using terminal positioning verbs of [[Terminal_control/Coloured_text#J]] |
||
<lang |
<syntaxhighlight lang="j">'Hello',~move 6 3</syntaxhighlight> |
||
=={{header| |
=={{header|jq}}== |
||
{{works with|jq}} |
|||
<lang Lasso>local(esc = decode_base64('Gw==')) |
|||
''Also works with gojq and jaq. |
|||
<syntaxhighlight lang="bash"> |
|||
jq -nr '"\u001b[2J", # clear the terminal |
|||
"\u001b[6;3HHello" # move to (6,3) and print Hello |
|||
' |
|||
</syntaxhighlight> |
|||
=={{header|Julia}}== |
|||
stdout( #esc + '[6;3HHello')</lang> |
|||
<syntaxhighlight lang="julia">const ESC = "\u001B" |
|||
gotoANSI(x, y) = print("$ESC[$(y);$(x)H") |
|||
=={{header|Liberty BASIC}}== |
|||
<lang lb>locate 3, 6 |
|||
gotoANSI(3, 6) |
|||
print "Hello" |
|||
println("Hello") |
|||
</lang> |
|||
</syntaxhighlight> |
|||
=={{header|Kotlin}}== |
|||
{{Works with|Ubuntu|14.04}} |
|||
<syntaxhighlight lang="scala">// version 1.1.2 |
|||
fun main(args: Array<String>) { |
|||
print("\u001Bc") // clear screen first |
|||
println("\u001B[6;3HHello") |
|||
}</syntaxhighlight> |
|||
=={{header|Lasso}}== |
|||
<syntaxhighlight lang="lasso">local(esc = decode_base64('Gw==')) |
|||
stdout( #esc + '[6;3HHello')</syntaxhighlight> |
|||
=={{header|Logo}}== |
=={{header|Logo}}== |
||
< |
<syntaxhighlight lang="logo">setcursor [2 5] |
||
type "Hello</ |
type "Hello</syntaxhighlight> |
||
You can also draw positioned text on the turtle graphics window. |
You can also draw positioned text on the turtle graphics window. |
||
< |
<syntaxhighlight lang="logo">setpos [20 50] |
||
setxy 20 30 ; alternate way to set position |
setxy 20 30 ; alternate way to set position |
||
label "Hello</ |
label "Hello</syntaxhighlight> |
||
=={{header|M2000 Interpreter}}== |
|||
M2000 has own console from M2000 Environment. Here we use a windows console, using Win32 Api. |
|||
[[File:Consol63.png|thumb|alt=Console Example]] |
|||
=={{header|Mathematica}}== |
|||
<lang Mathematica>Run["tput cup 6 3"] |
|||
Print["Hello"]</lang> |
|||
=={{header|OCaml}}== |
|||
Using the library [http://forge.ocamlcore.org/projects/ansiterminal/ ANSITerminal]: |
|||
<lang ocaml>#load "unix.cma" |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
Module Fix_Console_Window { |
|||
// This Module: |
|||
// a) move console window |
|||
// b) disable console close window. Without it, a close console terminates the M2000 environment |
|||
declare GetConsoleWindow Lib "Kernel32.GetConsoleWindow" |
|||
declare SetWindowPos Lib "User32.SetWindowPos" {Long hwnd, Long hWnd, Long x, Long y , Long nWidth, Long nHeight, Long uFlags} |
|||
declare GetSystemMenu Lib "User32.GetSystemMenu" {Long hWnd, Long bRevert} |
|||
const SC_CLOSE = 0xF060 |
|||
const MF_BYCOMMAND = 0 |
|||
declare DeleteMenu Lib "User32.DeleteMenu" {Long hMenu, Long uPosition, Long uFlags} |
|||
call Void DeleteMenu(GetSystemMenu(GetConsoleWindow(), 0), SC_CLOSE, MF_BYCOMMAND) |
|||
// if we dont move the M2000 console window (which is full screen), |
|||
// we can get the position and dimension of the current monitor |
|||
// current monitor return the read only variable Window |
|||
back { |
|||
gradient 0 ' set black preserving cursors |
|||
x=motion.x div twipsx ' make x,y,w, h PIXELS |
|||
y=motion.y div twipsy |
|||
w=scale.x div twipsx |
|||
h=scale.y div twipsy |
|||
} |
|||
// set console window 50px smaller form all sides from full screen |
|||
call void SetWindowPos(GetConsoleWindow(), -1, x+50, y+50, w-100, h-100, 0x0040) |
|||
} |
|||
declare SetCosnoleDispMode lib "Kernel32.SetConsoleDisplayMode" { Long cons, Long b, Long &opt} |
|||
declare GetMode lib "Kernel32.GetConsoleMode" {Long cons, long &a} |
|||
declare SetMode lib "kernel32.SetConsoleMode" {Long cons, long a} |
|||
declare GetConsole lib "Kernel32.AllocConsole" |
|||
declare FreeConsole lib "Kernel32.FreeConsole" |
|||
declare ConsoleCaption lib "Kernel32.SetConsoleTitleW" {a$} |
|||
declare GetHandle lib "Kernel32.GetStdHandle" {Long a} |
|||
declare CloseHandle lib "Kernel32.CloseHandle" {Long a} |
|||
// we use the W version (always M2000 need the W version for strings) |
|||
declare global WriteCons Lib "Kernel32.WriteConsoleW" {Long cons, a$, Long n, Long &p, Long u} |
|||
const CONSOLE_FULLSCREEN_MODE=1&, CONSOLE_WINDOWED_MODE=0& |
|||
const ENABLE_VIRTUAL_TERMINAL_PROCESSING=0x0004 |
|||
// These are special sequences |
|||
const StopBlinking$=chr$(27)+"[?25l" |
|||
Def EscXY$(x,y)=chr$(27)+"["+str$(y,0)+";"+str$(x,0)+"H" |
|||
// Using Windows Console |
|||
// void make the call to drop return value, without this the call use non zero values as error number |
|||
// using R=GetConsole() we can get the return value. |
|||
call void GetConsole() |
|||
call void ConsoleCaption("M2000 Windows Console") |
|||
// -11 for output |
|||
Long m=-11, RetLong |
|||
m=GetHandle(m) |
|||
Call Fix_Console_Window |
|||
// you can skip SetCosnoleDispModet, |
|||
// it seems this mode CONSOLE_WINDOWED_MODE is by default. |
|||
// call void SetCosnoleDispMode(m, CONSOLE_WINDOWED_MODE, &RetLong) ' 1 for fullscreen |
|||
wait 10 ' give 10ms time to OS |
|||
// Now we set the Virtual Terminal Processing (so we can send ESC codes) |
|||
Call Void GetMode(m, &RetLong) |
|||
Call Void SetMode(M,binary.or(Retlong, ENABLE_VIRTUAL_TERMINAL_PROCESSING)) |
|||
// Stop Blinking and set cursor (we can't see) to 3rd column and 6th row |
|||
// window's console origin is at 1,1 |
|||
PrintConsole(StopBlinking$+EscXY$(3, 6)) |
|||
// Print RetLong |
|||
wait 1000 |
|||
PrintConsole("Hello") |
|||
// Print RetLong |
|||
wait 12000 |
|||
call void CloseHandle(m) |
|||
call void FreeConsole() |
|||
// Using M2000 console (not the window one) |
|||
cls 0, 0 |
|||
// M2000 layer origin is 0,0 |
|||
// Cursor 3-1, 6-1 ' statement to set cursor |
|||
Print @(3-1, 6-1), "Hello" |
|||
Sub PrintConsole(a$) |
|||
RetLong=0& |
|||
call Void WriteCons(m, a$, Len(a$), &RetLong, 0) |
|||
End Sub |
|||
</syntaxhighlight> |
|||
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
|||
<syntaxhighlight lang="mathematica">Run["tput cup 6 3"] |
|||
Print["Hello"]</syntaxhighlight> |
|||
=={{header|Nim}}== |
|||
<syntaxhighlight lang="nim">import terminal |
|||
setCursorPos(3, 6) |
|||
echo "Hello"</syntaxhighlight> |
|||
=={{header|OCaml}}== |
|||
Using the library [http://forge.ocamlcore.org/projects/ansiterminal/ ANSITerminal]: |
|||
<syntaxhighlight lang="ocaml">#load "unix.cma" |
|||
#directory "+ANSITerminal" |
#directory "+ANSITerminal" |
||
#load "ANSITerminal.cma" |
#load "ANSITerminal.cma" |
||
Line 193: | Line 620: | ||
Trm.set_cursor 3 6; |
Trm.set_cursor 3 6; |
||
Trm.print_string [] "Hello"; |
Trm.print_string [] "Hello"; |
||
;;</ |
;;</syntaxhighlight> |
||
=={{header|Pascal}}== |
=={{header|Pascal}}== |
||
<syntaxhighlight lang="pascal"> |
|||
<lang Pascal> |
|||
program cursor_pos; |
program cursor_pos; |
||
uses crt; |
uses crt; |
||
Line 203: | Line 630: | ||
write('Hello'); |
write('Hello'); |
||
end. |
end. |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|PascalABC.NET}}== |
|||
<syntaxhighlight lang="delphi"> |
|||
uses CRT; |
|||
begin |
|||
GotoXY(3,6); |
|||
Write('Hello') |
|||
end. |
|||
</syntaxhighlight> |
|||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
Using the Term::Cap module: |
Using the Term::Cap module: |
||
< |
<syntaxhighlight lang="perl"> |
||
use Term::Cap; |
use Term::Cap; |
||
Line 213: | Line 652: | ||
print $t->Tgoto("cm", 2, 5); # 0-based |
print $t->Tgoto("cm", 2, 5); # 0-based |
||
print "Hello"; |
print "Hello"; |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header| |
=={{header|Phix}}== |
||
<!--<syntaxhighlight lang="phix">(notonline)--> |
|||
<lang nim>import terminal |
|||
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- position</span> |
|||
setCursorPos(3, 6) |
|||
<span style="color: #7060A8;">position</span><span style="color: #0000FF;">(</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span> |
|||
echo "Hello"</lang> |
|||
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Hello"</span><span style="color: #0000FF;">)</span> |
|||
<!--</syntaxhighlight>--> |
|||
=={{header| |
=={{header|PHP}}== |
||
<syntaxhighlight lang="php"> |
|||
Assuming an ANSI terminal: |
|||
echo "\033[".$x.",".$y."H"; // Position line $y and column $x. |
|||
<lang perl6>print "\e[6;3H"; |
|||
echo "\033[".$n."A"; // Up $n lines. |
|||
print 'Hello';</lang> |
|||
echo "\033[".$n."B"; // Down $n lines. |
|||
echo "\033[".$n."C"; // Forward $n columns. |
|||
echo "\033[".$n."D"; // Backward $n columns. |
|||
echo "\033[2J"; // Clear the screen, move to (0,0). |
|||
</syntaxhighlight> |
|||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
< |
<syntaxhighlight lang="picolisp">(call 'tput "cup" 6 3) |
||
(prin "Hello")</ |
(prin "Hello")</syntaxhighlight> |
||
=={{header|PowerShell}}== |
=={{header|PowerShell}}== |
||
The following will only work in the PowerShell console host. Most notably it will not work in the PowerShell ISE. |
The following will only work in the PowerShell console host. Most notably it will not work in the PowerShell ISE. |
||
< |
<syntaxhighlight lang="powershell">$Host.UI.RawUI.CursorPosition = New-Object System.Management.Automation.Host.Coordinates 2,5 |
||
$Host.UI.Write('Hello')</ |
$Host.UI.Write('Hello')</syntaxhighlight> |
||
Alternatively, in any PowerShell host that uses the Windows console, one can directly use the .NET <code>Console</code> class: |
Alternatively, in any PowerShell host that uses the Windows console, one can directly use the .NET <code>Console</code> class: |
||
< |
<syntaxhighlight lang="powershell">[Console]::SetCursorPosition(2,5) |
||
[Console]::Write('Hello')</ |
[Console]::Write('Hello')</syntaxhighlight> |
||
=={{header|PureBasic}}== |
|||
<lang PureBasic>EnableGraphicalConsole(#True) |
|||
ConsoleLocate(3,6) |
|||
Print("Hello")</lang> |
|||
=={{header|Python}}== |
=={{header|Python}}== |
||
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x:< |
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x:<syntaxhighlight lang="python">print("\033[6;3HHello")</syntaxhighlight> |
||
On Windows it needs to import and init the [http://code.google.com/p/colorama/ colorama] module first. |
On Windows it needs to import and init the [http://code.google.com/p/colorama/ colorama] module first. |
||
ANSI sequences are not recognized in Windows console, here is a program using Windows API: |
|||
<syntaxhighlight lang="python">from ctypes import * |
|||
STD_OUTPUT_HANDLE = -11 |
|||
class COORD(Structure): |
|||
pass |
|||
COORD._fields_ = [("X", c_short), ("Y", c_short)] |
|||
def print_at(r, c, s): |
|||
h = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE) |
|||
windll.kernel32.SetConsoleCursorPosition(h, COORD(c, r)) |
|||
c = s.encode("windows-1252") |
|||
windll.kernel32.WriteConsoleA(h, c_char_p(c), len(c), None, None) |
|||
print_at(6, 3, "Hello")</syntaxhighlight> |
|||
=={{header|Quackery}}== |
|||
<syntaxhighlight lang="quackery"> [ number$ swap number$ |
|||
$ 'print("\033[' rot join |
|||
char ; join |
|||
swap join |
|||
$ 'H", end="")' join |
|||
python ] is cursor-at ( x y --> ) |
|||
3 6 cursor-at say "Hello"</syntaxhighlight> |
|||
=={{header|Racket}}== |
=={{header|Racket}}== |
||
< |
<syntaxhighlight lang="racket"> |
||
#lang racket |
#lang racket |
||
(require (planet neil/charterm:3:0)) |
(require (planet neil/charterm:3:0)) |
||
Line 254: | Line 726: | ||
(charterm-cursor 3 6) |
(charterm-cursor 3 6) |
||
(displayln "Hello World")) |
(displayln "Hello World")) |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Raku}}== |
|||
(formerly Perl 6) |
|||
Assuming an ANSI terminal: |
|||
<syntaxhighlight lang="raku" line>print "\e[6;3H"; |
|||
print 'Hello';</syntaxhighlight> |
|||
=={{header|Retro}}== |
|||
<syntaxhighlight lang="retro">with console' |
|||
: hello 3 6 at-xy "Hello" puts ;</syntaxhighlight> |
|||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
The REXX language doesn't have any cursor or screen management tools, but some REXX interpreters have |
The REXX language doesn't have any cursor or screen management tools, but some REXX interpreters have |
||
<br>added the functionality via different methods (such as functions and/or subroutines). |
|||
{{works with|PC/REXX, Personal REXX}} |
{{works with|PC/REXX, Personal REXX}} |
||
< |
<syntaxhighlight lang="rexx">/*REXX program demonstrates moving the cursor position and writing of text to same place*/ |
||
call cursor 3,6 /*move the cursor to row 3, |
call cursor 3,6 /*move the cursor to row 3, column 6. */ |
||
say 'Hello' /*write the text at that location*/ |
say 'Hello' /*write the text at that location. */ |
||
call scrwrite 30,50,'Hello.' /*another method. */ |
|||
call scrwrite 40,60,'Hello.',,,14 /*another ... in yellow.*/</lang> |
|||
call scrwrite 30,50,'Hello.' /*another method, different location. */ |
|||
=={{header|Retro}}== |
|||
<lang Retro>with console' |
|||
call scrwrite 40,60,'Hello.',,,14 /*another method ... in yellow. */ |
|||
: hello 3 6 at-xy "Hello" puts ;</lang> |
|||
exit 0 /*stick a fork in it, we're all done. */</syntaxhighlight> |
|||
=={{header|Ring}}== |
|||
<syntaxhighlight lang="ring"> |
|||
# Project : Terminal control/Cursor positioning |
|||
for n = 1 to 5 |
|||
see nl |
|||
next |
|||
see " Hello" |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
Hello |
|||
</pre> |
|||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
{{libheader|curses}} |
{{libheader|curses}} |
||
< |
<syntaxhighlight lang="ruby">require 'curses' |
||
Curses.init_screen |
Curses.init_screen |
||
Line 284: | Line 785: | ||
ensure |
ensure |
||
Curses.close_screen |
Curses.close_screen |
||
end</ |
end</syntaxhighlight> |
||
=={{header|Scala}}== |
|||
{{Works with|Ubuntu|14.04}} |
|||
<syntaxhighlight lang="scala">object Main extends App { |
|||
print("\u001Bc") // clear screen first |
|||
println("\u001B[6;3HHello") |
|||
}</syntaxhighlight> |
|||
=={{header|Seed7}}== |
=={{header|Seed7}}== |
||
Line 291: | Line 799: | ||
''SetPos'' is based on terminfo respectively the Windows console API. |
''SetPos'' is based on terminfo respectively the Windows console API. |
||
< |
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
||
include "console.s7i"; |
include "console.s7i"; |
||
Line 305: | Line 813: | ||
# the program waits until Return/Enter is pressed. |
# the program waits until Return/Enter is pressed. |
||
readln; |
readln; |
||
end func;</ |
end func;</syntaxhighlight> |
||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
< |
<syntaxhighlight lang="tcl">exec tput cup 5 2 >/dev/tty |
||
puts "Hello"</ |
puts "Hello"</syntaxhighlight> |
||
=={{header|UNIX Shell}}== |
=={{header|UNIX Shell}}== |
||
< |
<syntaxhighlight lang="sh"># The tput utility numbers from zero, so we have subtracted 1 from row and column |
||
# number to obtain correct positioning. |
# number to obtain correct positioning. |
||
tput cup 5 2</ |
tput cup 5 2</syntaxhighlight> |
||
=={{header|Whitespace}}== |
=={{header|Whitespace}}== |
||
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x (see below): |
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x (see below): |
||
< |
<syntaxhighlight lang="whitespace"> |
||
Line 353: | Line 861: | ||
</syntaxhighlight> |
|||
</lang> |
|||
This solution was generated from the following pseudo-Assembly. |
This solution was generated from the following pseudo-Assembly. |
||
< |
<syntaxhighlight lang="asm">push "Hello" ;The characters are pushed onto the stack in reverse order |
||
push "[6;3H" |
push "[6;3H" |
||
push 27 ;ESC |
push 27 ;ESC |
||
Line 371: | Line 879: | ||
1: |
1: |
||
pop ret ;Pop counter and return</ |
pop ret ;Pop counter and return</syntaxhighlight> |
||
=={{header|Wren}}== |
|||
<syntaxhighlight lang="wren">System.write("\e[2J") // clear the terminal |
|||
System.print("\e[6;3HHello") // move to (6, 3) and print 'Hello'</syntaxhighlight> |
|||
=={{header|XPL0}}== |
=={{header|XPL0}}== |
||
< |
<syntaxhighlight lang="xpl0">include c:\cxpl\codes; \intrinsic 'code' declarations |
||
[Cursor(2, 5); \3rd column, 6th row |
[Cursor(2, 5); \3rd column, 6th row |
||
Text(0, "Hello"); \upper-left corner is coordinate 0, 0 |
Text(0, "Hello"); \upper-left corner is coordinate 0, 0 |
||
]</ |
]</syntaxhighlight> |
||
=={{header|Z80 Assembly}}== |
|||
Uses Amstrad CPC, but other machines with similar terminal functions can do the job. (The BIOS calls will be different however.) |
|||
<syntaxhighlight lang="z80">ld hl,&0603 ;6 = ROW, 3 = COLUMN |
|||
call &BB75 ;set text cursor according to HL |
|||
ld hl,Message |
|||
call PrintString |
|||
ret ;return to basic |
|||
Message: |
|||
byte "Hello",0 |
|||
PrintString: |
|||
ld a,(hl) ;read a byte from the string |
|||
or a ;check equality to zero |
|||
ret z ;if equal to zero, we're done |
|||
call &BB5A ;print accumulator as an ascii char to screen |
|||
inc hl ;next char |
|||
jr PrintString</syntaxhighlight> |
|||
=={{header|zkl}}== |
=={{header|zkl}}== |
||
{{trans|C/C++}} |
{{trans|C/C++}} |
||
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x: |
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x: |
||
< |
<syntaxhighlight lang="zkl">print("\e[6;3H" "Hello");</syntaxhighlight> |
||
{{omit from|ACL2}} |
{{omit from|ACL2}} |
Latest revision as of 20:58, 9 June 2024
Move the cursor to column 3, row 6, and display the word "Hello" (without the quotes), so that the letter H is in column 3 on row 6.
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
AArch64 Assembly
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program cursorPos64.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/*******************************************/
/* Initialized data */
/*******************************************/
.data
szMessStartPgm: .asciz "Program start \n"
szMessEndPgm: .asciz "Program normal end.\n"
szMessMovePos: .asciz "\033[6;3HHello\n"
szCarriageReturn: .asciz "\n"
szCleax1: .byte 0x1B
.byte 'c' // other console clear
.byte 0
/*******************************************/
/* UnInitialized data */
/*******************************************/
.bss
/*******************************************/
/* code section */
/*******************************************/
.text
.global main
main:
ldr x0,qAdrszMessStartPgm // display start message
bl affichageMess
ldr x0,qAdrszCleax1
bl affichageMess
ldr x0,qAdrszMessMovePos
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
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrszCleax1: .quad szCleax1
qAdrszMessMovePos: .quad szMessMovePos
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
Action!
PROC Main()
Position(3,6)
Print("Hello")
RETURN
- Output:
Ada
with Ada.Text_IO;
procedure Cursor_Pos is
begin
Ada.Text_IO.Set_Line(6);
Ada.Text_IO.Set_Col(3);
Ada.Text_IO.Put("Hello");
end Cursor_Pos;
ARM Assembly
/* ARM assembly Raspberry PI */
/* program cursorPos.s */
/* Constantes */
.equ STDOUT, 1 @ Linux output console
.equ EXIT, 1 @ Linux syscall
.equ WRITE, 4 @ Linux syscall
/* Initialized data */
.data
szMessStartPgm: .asciz "Program start \n"
szMessEndPgm: .asciz "Program normal end.\n"
szMessMovePos: .asciz "\033[6;3HHello\n"
szCarriageReturn: .asciz "\n"
szClear1: .byte 0x1B
.byte 'c' @ other console clear
.byte 0
/* UnInitialized data */
.bss
/* code section */
.text
.global main
main:
ldr r0,iAdrszMessStartPgm @ display start message
bl affichageMess
ldr r0,iAdrszClear1
bl affichageMess
ldr r0,iAdrszMessMovePos
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
iAdrszCarriageReturn: .int szCarriageReturn
iAdrszClear1: .int szClear1
iAdrszMessMovePos: .int szMessMovePos
/******************************************************************/
/* 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
Arturo
goto 3 6
print "Hello"
AutoHotkey
Remember that AHK is not built for the console, so we must call the WinAPI directly.
DllCall( "AllocConsole" ) ; create a console if not launched from one
hConsole := DllCall( "GetStdHandle", int, STDOUT := -11 )
DllCall("SetConsoleCursorPosition", UPtr, hConsole, UInt, (6 << 16) | 3)
WriteConsole(hConsole, "Hello")
MsgBox
WriteConsole(hConsole, text){
VarSetCapacity(out, 16)
If DllCall( "WriteConsole", UPtr, hConsole, Str, text, UInt, StrLen(text)
, UPtrP, out, uint, 0 )
return out
return 0
}
Axe
Since the rows and columns are zero-indexed, we must subtract 1 from both.
Output(2,5,"HELLO")
BASIC
Applesoft BASIC
10 VTAB 6: HTAB 3
20 PRINT "HELLO"
ASIC
Rows have the range 0-24, columns have the range 0-79.
LOCATE 5, 2
PRINT "Hello"
BaCon
' Cursor positioning, requires ANSI compliant terminal
GOTOXY 3,6
PRINT "Hello"
The X Y in GOTOXY
is Column Row order.
BBC BASIC
PRINT TAB(2,5);"Hello"
Commodore BASIC
10 CHAR ,2,5,"HELLO"
100 print chr$(19) :rem change to lowercase set
110 print chr$(14) :rem go to position 1,1
120 print:print:print:print
130 print tab(2) "Hello"
FreeBASIC
Locate 6, 3 : Print "Hello"
Sleep
GW-BASIC
10 LOCATE 6, 3
20 PRINT "Hello"
IS-BASIC
100 PRINT AT 6,3:"Hello"
Liberty BASIC
locate 3, 6
print "Hello"
Locomotive Basic
10 LOCATE 3,6
20 PRINT "Hello"
MSX Basic
10 LOCATE 2,5
20 PRINT "Hello"
Nascom BASIC
Line 16 is at the top of the screen and is not scrolled. Line 1 is the next line down, and line 15 is at the bottom.
10 SCREEN 3,5:PRINT "Hello"
NS-HUBASIC
10 LOCATE 3,6
20 PRINT "HELLO"
PureBasic
EnableGraphicalConsole(#True)
ConsoleLocate(3,6)
Print("Hello")
QuickBASIC
LOCATE 6, 3
PRINT "Hello"
RapidQ
See QuickBASIC.
ZX Spectrum Basic
10 REM The top left corner is at position 0,0
20 REM So we subtract one from the coordinates
30 PRINT AT 5,2 "Hello"
Befunge
Assuming a terminal with support for ANSI escape sequences.
0"olleHH3;6["39*>:#,_$@
Blast
# This will display a message at a specific position on the terminal screen
.begin
cursor 6,3
display "Hello!"
return
# This is the end of the script
C/C++
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x:
#include <stdio.h>
int main()
{
printf("\033[6;3HHello\n");
return 0;
}
The C version of the minesweeper game uses curses. Minesweeper_game#C
On Windows, using console API:
#include <windows.h>
int main() {
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
COORD pos = {3, 6};
SetConsoleCursorPosition(hConsole, pos);
WriteConsole(hConsole, "Hello", 5, NULL, NULL);
return 0;
}
C#
static void Main(string[] args)
{
Console.SetCursorPosition(3, 6);
Console.Write("Hello");
}
COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. cursor-positioning.
PROCEDURE DIVISION.
DISPLAY "Hello" AT LINE 6, COL 3
GOBACK
.
Common Lisp
ncurses
To interface the ncurses C library from Lisp, the croatoan library is used.
(defun cursor-positioning ()
(with-screen (scr :input-blocking t :input-echoing nil :cursor-visible nil)
(move scr 5 2)
(princ "Hello" scr)
(refresh scr)
;; wait for keypress
(get-char scr)))
D
ANSI escape sequences allow you to move the cursor anywhere on the screen. See more at: Bash Prompt HowTo - Chapter 6. ANSI Escape Sequences: Colours and Cursor Movement
Position the Cursor: \033[<L>;<C>H or \033[<L>;<C>f puts the cursor at line L and column C.
import std.stdio;
void main()
{
writef("\033[6;3fHello");
}
Output:
0123456789 1 2 3 4 5 6 Hello 9 8 9
Elena
ELENA 4.x :
public program()
{
console.setCursorPosition(3,6).write("Hello")
}
Euphoria
position(6,3)
puts(1,"Hello")
F#
open System
Console.SetCursorPosition(3, 6)
Console.Write("Hello")
Forth
2 5 at-xy ." Hello"
Fortran
Intel Fortran on Windows
program textposition
use kernel32
implicit none
integer(HANDLE) :: hConsole
integer(BOOL) :: q
hConsole = GetStdHandle(STD_OUTPUT_HANDLE)
q = SetConsoleCursorPosition(hConsole, T_COORD(3, 6))
q = WriteConsole(hConsole, loc("Hello"), 5, NULL, NULL)
end program
Go
External command
package main
import (
"bytes"
"fmt"
"os"
"os/exec"
)
func main() {
cmd := exec.Command("tput", "-S")
cmd.Stdin = bytes.NewBufferString("clear\ncup 5 2")
cmd.Stdout = os.Stdout
cmd.Run()
fmt.Println("Hello")
}
ANSI escape codes
package main
import "fmt"
func main() {
fmt.Println("\033[2J\033[6;3HHello")
}
Ncurses
package main
import (
"log"
gc "code.google.com/p/goncurses"
)
func main() {
s, err := gc.Init()
if err != nil {
log.Fatal("init:", err)
}
defer gc.End()
s.Move(5, 2)
s.Println("Hello")
s.GetChar()
}
Icon and Unicon
If the OS has older termcap files, CUP is included with link ansi
procedure main()
writes(CUP(6,3), "Hello")
end
procedure CUP(i,j)
writes("\^[[",i,";",j,"H")
return
end
J
Using terminal positioning verbs of Terminal_control/Coloured_text#J
'Hello',~move 6 3
jq
Also works with gojq and jaq.
jq -nr '"\u001b[2J", # clear the terminal
"\u001b[6;3HHello" # move to (6,3) and print Hello
'
Julia
const ESC = "\u001B"
gotoANSI(x, y) = print("$ESC[$(y);$(x)H")
gotoANSI(3, 6)
println("Hello")
Kotlin
// version 1.1.2
fun main(args: Array<String>) {
print("\u001Bc") // clear screen first
println("\u001B[6;3HHello")
}
Lasso
local(esc = decode_base64('Gw=='))
stdout( #esc + '[6;3HHello')
Logo
setcursor [2 5]
type "Hello
You can also draw positioned text on the turtle graphics window.
setpos [20 50]
setxy 20 30 ; alternate way to set position
label "Hello
M2000 Interpreter
M2000 has own console from M2000 Environment. Here we use a windows console, using Win32 Api.
Module Fix_Console_Window {
// This Module:
// a) move console window
// b) disable console close window. Without it, a close console terminates the M2000 environment
declare GetConsoleWindow Lib "Kernel32.GetConsoleWindow"
declare SetWindowPos Lib "User32.SetWindowPos" {Long hwnd, Long hWnd, Long x, Long y , Long nWidth, Long nHeight, Long uFlags}
declare GetSystemMenu Lib "User32.GetSystemMenu" {Long hWnd, Long bRevert}
const SC_CLOSE = 0xF060
const MF_BYCOMMAND = 0
declare DeleteMenu Lib "User32.DeleteMenu" {Long hMenu, Long uPosition, Long uFlags}
call Void DeleteMenu(GetSystemMenu(GetConsoleWindow(), 0), SC_CLOSE, MF_BYCOMMAND)
// if we dont move the M2000 console window (which is full screen),
// we can get the position and dimension of the current monitor
// current monitor return the read only variable Window
back {
gradient 0 ' set black preserving cursors
x=motion.x div twipsx ' make x,y,w, h PIXELS
y=motion.y div twipsy
w=scale.x div twipsx
h=scale.y div twipsy
}
// set console window 50px smaller form all sides from full screen
call void SetWindowPos(GetConsoleWindow(), -1, x+50, y+50, w-100, h-100, 0x0040)
}
declare SetCosnoleDispMode lib "Kernel32.SetConsoleDisplayMode" { Long cons, Long b, Long &opt}
declare GetMode lib "Kernel32.GetConsoleMode" {Long cons, long &a}
declare SetMode lib "kernel32.SetConsoleMode" {Long cons, long a}
declare GetConsole lib "Kernel32.AllocConsole"
declare FreeConsole lib "Kernel32.FreeConsole"
declare ConsoleCaption lib "Kernel32.SetConsoleTitleW" {a$}
declare GetHandle lib "Kernel32.GetStdHandle" {Long a}
declare CloseHandle lib "Kernel32.CloseHandle" {Long a}
// we use the W version (always M2000 need the W version for strings)
declare global WriteCons Lib "Kernel32.WriteConsoleW" {Long cons, a$, Long n, Long &p, Long u}
const CONSOLE_FULLSCREEN_MODE=1&, CONSOLE_WINDOWED_MODE=0&
const ENABLE_VIRTUAL_TERMINAL_PROCESSING=0x0004
// These are special sequences
const StopBlinking$=chr$(27)+"[?25l"
Def EscXY$(x,y)=chr$(27)+"["+str$(y,0)+";"+str$(x,0)+"H"
// Using Windows Console
// void make the call to drop return value, without this the call use non zero values as error number
// using R=GetConsole() we can get the return value.
call void GetConsole()
call void ConsoleCaption("M2000 Windows Console")
// -11 for output
Long m=-11, RetLong
m=GetHandle(m)
Call Fix_Console_Window
// you can skip SetCosnoleDispModet,
// it seems this mode CONSOLE_WINDOWED_MODE is by default.
// call void SetCosnoleDispMode(m, CONSOLE_WINDOWED_MODE, &RetLong) ' 1 for fullscreen
wait 10 ' give 10ms time to OS
// Now we set the Virtual Terminal Processing (so we can send ESC codes)
Call Void GetMode(m, &RetLong)
Call Void SetMode(M,binary.or(Retlong, ENABLE_VIRTUAL_TERMINAL_PROCESSING))
// Stop Blinking and set cursor (we can't see) to 3rd column and 6th row
// window's console origin is at 1,1
PrintConsole(StopBlinking$+EscXY$(3, 6))
// Print RetLong
wait 1000
PrintConsole("Hello")
// Print RetLong
wait 12000
call void CloseHandle(m)
call void FreeConsole()
// Using M2000 console (not the window one)
cls 0, 0
// M2000 layer origin is 0,0
// Cursor 3-1, 6-1 ' statement to set cursor
Print @(3-1, 6-1), "Hello"
Sub PrintConsole(a$)
RetLong=0&
call Void WriteCons(m, a$, Len(a$), &RetLong, 0)
End Sub
Mathematica/Wolfram Language
Run["tput cup 6 3"]
Print["Hello"]
Nim
import terminal
setCursorPos(3, 6)
echo "Hello"
OCaml
Using the library ANSITerminal:
#load "unix.cma"
#directory "+ANSITerminal"
#load "ANSITerminal.cma"
module Trm = ANSITerminal
let () =
Trm.erase Trm.Screen;
Trm.set_cursor 3 6;
Trm.print_string [] "Hello";
;;
Pascal
program cursor_pos;
uses crt;
begin
gotoxy(6,3);
write('Hello');
end.
PascalABC.NET
uses CRT;
begin
GotoXY(3,6);
Write('Hello')
end.
Perl
Using the Term::Cap module:
use Term::Cap;
my $t = Term::Cap->Tgetent;
print $t->Tgoto("cm", 2, 5); # 0-based
print "Hello";
Phix
without js -- position position(6,3) puts(1,"Hello")
PHP
echo "\033[".$x.",".$y."H"; // Position line $y and column $x.
echo "\033[".$n."A"; // Up $n lines.
echo "\033[".$n."B"; // Down $n lines.
echo "\033[".$n."C"; // Forward $n columns.
echo "\033[".$n."D"; // Backward $n columns.
echo "\033[2J"; // Clear the screen, move to (0,0).
PicoLisp
(call 'tput "cup" 6 3)
(prin "Hello")
PowerShell
The following will only work in the PowerShell console host. Most notably it will not work in the PowerShell ISE.
$Host.UI.RawUI.CursorPosition = New-Object System.Management.Automation.Host.Coordinates 2,5
$Host.UI.Write('Hello')
Alternatively, in any PowerShell host that uses the Windows console, one can directly use the .NET Console
class:
[Console]::SetCursorPosition(2,5)
[Console]::Write('Hello')
Python
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x:
print("\033[6;3HHello")
On Windows it needs to import and init the colorama module first.
ANSI sequences are not recognized in Windows console, here is a program using Windows API:
from ctypes import *
STD_OUTPUT_HANDLE = -11
class COORD(Structure):
pass
COORD._fields_ = [("X", c_short), ("Y", c_short)]
def print_at(r, c, s):
h = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
windll.kernel32.SetConsoleCursorPosition(h, COORD(c, r))
c = s.encode("windows-1252")
windll.kernel32.WriteConsoleA(h, c_char_p(c), len(c), None, None)
print_at(6, 3, "Hello")
Quackery
[ number$ swap number$
$ 'print("\033[' rot join
char ; join
swap join
$ 'H", end="")' join
python ] is cursor-at ( x y --> )
3 6 cursor-at say "Hello"
Racket
#lang racket
(require (planet neil/charterm:3:0))
(with-charterm
(charterm-clear-screen)
(charterm-cursor 3 6)
(displayln "Hello World"))
Raku
(formerly Perl 6) Assuming an ANSI terminal:
print "\e[6;3H";
print 'Hello';
Retro
with console'
: hello 3 6 at-xy "Hello" puts ;
REXX
The REXX language doesn't have any cursor or screen management tools, but some REXX interpreters have
added the functionality via different methods (such as functions and/or subroutines).
/*REXX program demonstrates moving the cursor position and writing of text to same place*/
call cursor 3,6 /*move the cursor to row 3, column 6. */
say 'Hello' /*write the text at that location. */
call scrwrite 30,50,'Hello.' /*another method, different location. */
call scrwrite 40,60,'Hello.',,,14 /*another method ... in yellow. */
exit 0 /*stick a fork in it, we're all done. */
Ring
# Project : Terminal control/Cursor positioning
for n = 1 to 5
see nl
next
see " Hello"
Output:
Hello
Ruby
require 'curses'
Curses.init_screen
begin
Curses.setpos(6, 3) # column 6, row 3
Curses.addstr("Hello")
Curses.getch # Wait until user presses some key.
ensure
Curses.close_screen
end
Scala
object Main extends App {
print("\u001Bc") // clear screen first
println("\u001B[6;3HHello")
}
Seed7
The function setPos is portable and positions the cursor on the console window. SetPos is based on terminfo respectively the Windows console API.
$ include "seed7_05.s7i";
include "console.s7i";
const proc: main is func
local
var text: console is STD_NULL;
begin
console := open(CONSOLE);
setPos(console, 6, 3);
write(console, "Hello");
# Terminal windows often restore the previous
# content, when a program is terminated. Therefore
# the program waits until Return/Enter is pressed.
readln;
end func;
Tcl
exec tput cup 5 2 >/dev/tty
puts "Hello"
UNIX Shell
# The tput utility numbers from zero, so we have subtracted 1 from row and column
# number to obtain correct positioning.
tput cup 5 2
Whitespace
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x (see below):
This solution was generated from the following pseudo-Assembly.
push "Hello" ;The characters are pushed onto the stack in reverse order
push "[6;3H"
push 27 ;ESC
push 11 ;Number of characters to print
call 0 ;Calls print-string function
exit
0:
dup jumpz 1 ;Return if counter is zero
exch prtc ;Swap counter with the next character and print it
push 1 sub ;Subtract one from counter
jump 0 ;Loop back to print next character
1:
pop ret ;Pop counter and return
Wren
System.write("\e[2J") // clear the terminal
System.print("\e[6;3HHello") // move to (6, 3) and print 'Hello'
XPL0
include c:\cxpl\codes; \intrinsic 'code' declarations
[Cursor(2, 5); \3rd column, 6th row
Text(0, "Hello"); \upper-left corner is coordinate 0, 0
]
Z80 Assembly
Uses Amstrad CPC, but other machines with similar terminal functions can do the job. (The BIOS calls will be different however.)
ld hl,&0603 ;6 = ROW, 3 = COLUMN
call &BB75 ;set text cursor according to HL
ld hl,Message
call PrintString
ret ;return to basic
Message:
byte "Hello",0
PrintString:
ld a,(hl) ;read a byte from the string
or a ;check equality to zero
ret z ;if equal to zero, we're done
call &BB5A ;print accumulator as an ascii char to screen
inc hl ;next char
jr PrintString
zkl
Using ANSI escape sequence, where ESC[y;xH moves curser to row y, col x:
print("\e[6;3H" "Hello");