IMPLEMENTATION MODULE VT100;

IMPORT ASCII;
FROM STextIO IMPORT WriteString, WriteChar, WriteLn, ReadString;
FROM NumberIO IMPORT WriteCard, CardToStr,StrToCard;
FROM Strings IMPORT Concat, Length, String1, Assign, Delete;
FROM NumberIO IMPORT WriteHex;
FROM Delay IMPORT Delay;
IMPORT SplitV1;
IMPORT termios;

(*
Name                  DASCII.escription                            ASCII.esc Code

setnl LMN             Set new line mode                      ^[[20h
setappl DECCKM        Set cursor key to application          ^[[?1h
setansi DECANM        Set ANSI (versus VT52)                 none
setcol DECCOLM        Set number of columns to 132           ^[[?3h
setsmooth DECSCLM     Set smooth scrolling                   ^[[?4h
setrevscrn DECSCNM    Set reverse video on screen            ^[[?5h
setorgrel DECOM       Set origin to relative                 ^[[?6h
setwrap DECAWM        Set auto-wrap mode                     ^[[?7h
setrep DECARM         Set auto-repeat mode                   ^[[?8h
setinter DECINLM      Set interlacing mode                   ^[[?9h

setlf LMN             Set line feed mode                     ^[[20l
setcursor DECCKM      Set cursor key to cursor               ^[[?1l
setvt52 DECANM        Set VT52 (versus ANSI)                 ^[[?2l
resetcol DECCOLM      Set number of columns to 80            ^[[?3l
setjump DECSCLM       Set jump scrolling                     ^[[?4l
setnormscrn DECSCNM   Set normal video on screen             ^[[?5l
setorgabs DECOM       Set origin to absolute                 ^[[?6l
resetwrap DECAWM      Reset auto-wrap mode                   ^[[?7l
resetrep DECARM       Reset auto-repeat mode                 ^[[?8l
resetinter DECINLM    Reset interlacing mode                 ^[[?9l

altkeypad DECKPAM     Set alternate keypad mode              ^[=
numkeypad DECKPNM     Set numeric keypad mode                ^[>

setukg0               Set United Kingdom G0 character set    ^[(A
setukg1               Set United Kingdom G1 character set    ^[)A
setusg0               Set United States G0 character set     ^[(B
setusg1               Set United States G1 character set     ^[)B
setspecg0             Set G0 special chars. & line set       ^[(0
setspecg1             Set G1 special chars. & line set       ^[)0
setaltg0              Set G0 alternate character ROM         ^[(1
setaltg1              Set G1 alternate character ROM         ^[)1
setaltspecg0          Set G0 alt char ROM and spec. graphics ^[(2
setaltspecg1          Set G1 alt char ROM and spec. graphics ^[)2

setss2 SS2            Set single shift 2                     ^[N
setss3 SS3            Set single shift 3                     ^[O

modesoff SGR0         Turn off character attributes          ^[[m
modesoff SGR0         Turn off character attributes          ^[[0m
bold SGR1             Turn bold mode on                      ^[[1m
lowint SGR2           Turn low intensity mode on             ^[[2m
underline SGR4        Turn underline mode on                 ^[[4m
blink SGR5            Turn blinking mode on                  ^[[5m
reverse SGR7          Turn reverse video on                  ^[[7m
invisible SGR8        Turn invisible text mode on            ^[[8m

setwin DECSTBM        Set top and bottom line#s of a window  ^[[<v>;<v>r

cursorup(n) CUU       Move cursor up n lines                 ^[[<n>A
cursordn(n) CUD       Move cursor down n lines               ^[[<n>B
cursorrt(n) CUF       Move cursor right n lines              ^[[<n>C
cursorlf(n) CUB       Move cursor left n lines               ^[[<n>D
cursorhome            Move cursor to upper left corner       ^[[H
cursorhome            Move cursor to upper left corner       ^[[;H
cursorpos(v,h) CUP    Move cursor to screen location v,h     ^[[<v>;<h>H
hvhome                Move cursor to upper left corner       ^[[f
hvhome                Move cursor to upper left corner       ^[[;f
hvpos(v,h) CUP        Move cursor to screen location v,h     ^[[<v>;<h>f
index IND             Move/scroll window up one line         ^[D
revindex RI           Move/scroll window down one line       ^[M
nextline NEL          Move to next line                      ^[E
savecursor DECSC      Save cursor position and attributes    ^[7
restorecursor DECSC   Restore cursor position and attributes ^[8

tabset HTS            Set a tab at the current column        ^[H
tabclr TBC            Clear a tab at the current column      ^[[g
tabclr TBC            Clear a tab at the current column      ^[[0g
tabclrall TBC         Clear all tabs                         ^[[3g

dhtop DECDHL          Double-height letters, top half        ^[#3
dhbot DECDHL          Double-height letters, bottom half     ^[#4
swsh DECSWL           Single width, single height letters    ^[#5
dwsh DECDWL           Double width, single height letters    ^[#6

cleareol EL0          Clear line from cursor right           ^[[K
cleareol EL0          Clear line from cursor right           ^[[0K
clearbol EL1          Clear line from cursor left            ^[[1K
clearline EL2         Clear entire line                      ^[[2K

cleareos ED0          Clear screen from cursor down          ^[[J
cleareos ED0          Clear screen from cursor down          ^[[0J
clearbos ED1          Clear screen from cursor up            ^[[1J
clearscreen ED2       Clear entire screen                    ^[[2J

devstat DSR           Device status report                   ^[5n
termok DSR               Response: terminal is OK            ^[0n
termnok DSR              Response: terminal is not OK        ^[3n

getcursor DSR         Get cursor position                    ^[6n
cursorpos CPR            Response: cursor is at v,h          ^[<v>;<h>R

ident DA              Identify what terminal type            ^[[c
ident DA              Identify what terminal type (another)  ^[[0c
gettype DA               Response: terminal type code n      ^[[?1;<n>0c

reset RIS             Reset terminal to initial state        ^[c

align DECALN          Screen alignment display               ^[#8
testpu DECTST         Confidence power up test               ^[[2;1y
testlb DECTST         Confidence loopback test               ^[[2;2y
testpurep DECTST      Repeat power up test                   ^[[2;9y
testlbrep DECTST      Repeat loopback test                   ^[[2;10y

ledsoff DECLL0        Turn off all four leds                 ^[[0q
led1 DECLL1           Turn on LED #1                         ^[[1q
led2 DECLL2           Turn on LED #2                         ^[[2q
led3 DECLL3           Turn on LED #3                         ^[[3q
led4 DECLL4           Turn on LED #4                         ^[[4q

#
#  All codes below are for use in VT52 compatibility mode.
#

setansi               Enter/exit ANSI mode (VT52)            ^[<

altkeypad             Enter alternate keypad mode            ^[=
numkeypad             Exit alternate keypad mode             ^[>

setgr                 Use special graphics character set     ^[F
resetgr               Use normal US/UK character set         ^[G

cursorup              Move cursor up one line                ^[A
cursordn              Move cursor down one line              ^[B
cursorrt              Move cursor right one char             ^[C
cursorlf              Move cursor left one char              ^[D
cursorhome            Move cursor to upper left corner       ^[H
cursorpos(v,h)        Move cursor to v,h location            ^[<v><h>
revindex              Generate a reverse line-feed           ^[I

cleareol              Erase to end of current line           ^[K
cleareos              Erase to end of screen                 ^[J

ident                 Identify what the terminal is          ^[Z
identresp             Correct response to ident              ^[/Z

*)

(*                    VT52 compatibility mode                 *)

TYPE 
    Array2  = ARRAY[0..1] OF CHAR;  
    Array3  = ARRAY[0..2] OF CHAR;
    Array4  = ARRAY[0..3] OF CHAR;
    Array5  = ARRAY[0..4] OF CHAR;
    Array6  = ARRAY[0..5] OF CHAR;
    Array7  = ARRAY[0..6] OF CHAR;
    Array8  = ARRAY[0..7] OF CHAR;
    Array10 = ARRAY[0..9] OF CHAR;


VAR 
    theterminal     : termios.TERMIOS;
    savedFd         : INTEGER;

VAR                 (* cursor *)
    cursorupStr     : Array4;
    cursordnStr     : Array4;
    cursorrtStr     : Array4;
    cursorlfStr     : Array4;
    cursorhomeStr   : Array4;
    cursorposStr    : ARRAY [0..10] OF CHAR;
    revindexStr     : Array4;

    cleareolStr     : Array4;
    cleareosStr     : Array4;
    
VAR                 (* ident *)
    identStr        : Array4;
    identrespStr    : Array5;

VAR                 (* graphic *)
    setgrStr        : Array4;
    resetgrStr      : Array4;

VAR                 (* VT52 mode *)
    setansiStr      : Array4;

VAR                 (* keypad switch *)
    altkeypadStr    : Array4;
    numkeypadStr    : Array4;

(*                                    VT100                                      *)
VAR
    setnlStr        : Array3;
    setapplStr      : Array3;
    setansi1Str     : Array3;
    setcolStr       : Array3;
    setsmoothStr    : Array3;
    setrevscrnStr   : Array3;
    setorgrelStr    : Array3;
    setwrapStr      : Array3;
    setrepStr       : Array3;
    setinterStr     : Array3;

    setlfStr        : Array3;
    setcursorStr    : Array3;
    setvt52Str      : Array3;
    resetcolStr     : Array3;
    setjumpStr      : Array3;
    setnormscrnStr  : Array3;
    setorgabsStr    : Array3;
    resetwrapStr    : Array3;
    resetrepStr     : Array3;
    resetinterStr   : Array3;

    altkeypad1Str   : Array3;
    numkeypad1Str   : Array3;

    setukg0Str      : Array3;
    setukg1Str      : Array3;
    setusg0Str      : Array3;
    setusg1Str      : Array3;
    setspecg0Str    : Array3;
    setspecg1Str    : Array3;
    setaltg0Str     : Array3;
    setaltg1Str     : Array3;
    setaltspecg0Str : Array3;
    setaltspecg1Str : Array3;

    setss2Str       : Array3;
    setss3Str       : Array3;

    modesoff0Str    : Array4;
    modesoff1Str    : Array5;
    boldStr         : Array5;
    lowintStr       : Array5;
    underlineStr    : Array5;
    blinkStr        : Array5;
    reverseStr      : Array5;
    invisibleStr    : Array5;
    italicStr       : Array5;
    strikethroughStr : Array5;

    resetboldStr    : Array6;
    resetlowintStr  : Array6;
    resetunderlineStr : Array6;
    resetblinkStr   : Array6;
    resetreverseStr : Array6;
    resetinvisibleStr : Array6;
    resetitalicStr  : Array6;
    resetstrikethroughStr : Array6;

    setwinStr       : Array3;

    cursorhome0Str  : Array3;
    cursorhome1Str  : Array5;
    hvhome0Str      : Array3;
    hvhome1Str      : Array3;
    hvposStr        : Array3;
    indexStr        : Array3;
    revindex1Str    : Array3;
    nextlineStr     : Array3;
    savecursStr     : Array3;
    restorecursorStr: Array3;
    requestCursorPositionStr : Array5;
    tabsetStr       : Array3;
    tabclr0Str      : Array3;
    tabclr1Str      : Array3;
    tabclrallStr    : Array3;

    dhtopStr        : Array3;
    dhbotStr        : Array3;
    swshStr         : Array3;
    dwshStr         : Array3;

    cleareol0Str    : Array3;
    cleareol1Str    : Array3;
    clearbol2Str    : Array3;
    clearlineStr    : Array3;

    cleareos0Str    : Array3;
    cleareos1Str    : Array3;
    clearbos2Str    : Array3;
    clearscreenStr  : Array5;

    devstatStr      : Array3;
    termokStr       : Array3;
    termnokStr      : Array3;

    getcursorStr    : Array3;
    cursorpos2Str   : Array3;
    cursorbnlStr    : Array3;
    cursorblplStr   : Array3;
    cursottocolStr  : Array3;
    ident1Str       : Array3;
    ident2Str       : Array3;
    gettypeStr      : Array3;

    resetStr        : Array3;

    alignStr        : Array3;
    testpuStr       : Array3;
    testlbStr       : Array3;
    testpurepStr    : Array3;
    testlbrepStr    : Array3;
    (* screen modes *)
    resetScreenModeStr : Array6;
    ledsoffStr      : Array3;
    led1Str         : Array3;
    led2Str         : Array3;
    led3Str         : Array3;
    led4Str         : Array3;
    M40x25BWStr     : Array6;
    M40x25CStr      : Array6;
    M80x25BWStr     : Array6;
    M80x25CStr      : Array6;
    M320x200C4Str   : Array6;
    M320x200BWStr   : Array6;
    M640x200BWStr   : Array6;
    M320x200C256Str : Array6;
    M640x200CStr    : Array7;
    M640x350BWStr   : Array7;
    M640x350CStr    : Array7;
    M640x480BWStr   : Array7;
    M640x480CStr    : Array7;
    M320x200CStr    : Array7;
    lineWrappingStr : Array6;
    resetLineWrappingStr : Array6;

    (* some proprietary extensions *)
    makeCursorInvisibleStr  : Array7;
    makeCursorVisibleStr    : Array7;
    restoreScreenStr        : Array7;
    saveScreenStr           : Array7;
    enableAlternativeBufferStr  : Array10;
    disableAlternativeBufferStr : Array10;

    doubleUnderlineStr      : Array6;
    resetDoubleUnderlineStr : Array6;
    
    (* colors *)

VAR
    i : CARDINAL;

PROCEDURE affiche ( m : ARRAY OF CHAR; s : ARRAY OF CHAR);

BEGIN
    WriteString(m);WriteLn;
    FOR i := 0 TO Length(s) DO
        WriteHex(ORD(s[i]),2);
        WriteChar(" ")
    END; 
    WriteLn;
END affiche;

PROCEDURE modesoff; (*OK*)
(* SGR0 Turn off character attributes          ^[[m *)
BEGIN
    WriteString(modesoff0Str)
END modesoff;

PROCEDURE modesoff1; (*OK*)
        (* SGR0 Turn off character attributes          ^[[0m *)
BEGIN
    WriteString(modesoff1Str)
END modesoff1;

PROCEDURE bold; (*OK*)
    (* SGR1 Turn bold mode on                      ^[[1m *)
BEGIN
    WriteString(boldStr);
END bold;

PROCEDURE lowint; (*OK*)
    (* SGR2 Turn low intensity mode on             ^[[2m *)
BEGIN
    WriteString(lowintStr)
END lowint;

PROCEDURE italic; (*OK*)
    (* set italic mode                           ESC[3m *)
BEGIN
    WriteString(italicStr)
END italic;

PROCEDURE underline; (*OK*)
    (* SGR4 Turn underline mode on                 ^[[4m *)
BEGIN
    WriteString(underlineStr)
END underline;

PROCEDURE blink; (*OK*)
    (* SGR5 Turn blinking mode on                  ^[[5m *)
BEGIN
    WriteString(blinkStr)
END blink;

PROCEDURE reverse; (*OK*)
    (* SGR7 Turn reverse video on                  ^[[7m *)
BEGIN
    WriteString(reverseStr)
END reverse;

PROCEDURE invisible; (*OK*)
    (* SGR8 Turn invisible text mode on            ^[[8m *)
BEGIN
    WriteString(invisibleStr)
END invisible;

PROCEDURE strikethrough; (*OK*)
BEGIN
    WriteString(strikethroughStr)
END strikethrough;

PROCEDURE doubleUnderline;
    (* ESC[21m *)
BEGIN
    WriteString(doubleUnderlineStr)
END doubleUnderline;

PROCEDURE resetbold; (*OK*)
    (* SGR1 Turn bold mode on                      ^[[21m *)

BEGIN
    WriteString(resetboldStr)
END resetbold;

PROCEDURE resetlowint; (*OK*)
    (* SGR2 Turn low intensity mode on             ^[[22m *)
BEGIN
    WriteString(resetlowintStr)
END resetlowint;


PROCEDURE resetitalic; (*OK*)
    (* set italic mode                              ESC[23m *)
BEGIN
    WriteString(resetitalicStr)
END resetitalic;


PROCEDURE resetunderline; (*OK*)
    (* SGR4 Turn underline mode on                 ^[[24m *)
BEGIN
    WriteString(resetunderlineStr)
END resetunderline;


PROCEDURE resetblink; (*OK*)
    (* SGR5 Turn blinking mode on                  ^[[25m *)
BEGIN
    WriteString(resetblinkStr)
END resetblink;


PROCEDURE resetreverse; (*OK*)
    (* SGR7 Turn reverse video on                  ^[[27m *)
BEGIN
    WriteString(resetreverseStr)
END resetreverse;


PROCEDURE resetinvisible; (*OK*)
    (* SGR8 Turn invisible text mode on            ^[[28m *)
BEGIN
    WriteString(resetinvisibleStr)
END resetinvisible;


PROCEDURE resetstrikethrough; (*OK*)
    (* ESC[9m 	ESC[29m 	set strikethrough mode. *)
BEGIN
    WriteString(resetstrikethroughStr)
END resetstrikethrough;

PROCEDURE resetDoubleUnderline;
    (* ESC[24m. *)
BEGIN
    WriteString(resetDoubleUnderlineStr)
END resetDoubleUnderline;



PROCEDURE requestCursorPosition(VAR x,y : CARDINAL);
    (* ESC[6n 	request cursor position (reports as ESC[#;#R) *)

VAR
    str          : ARRAY [0..15] OF CHAR;
    theStructure : SplitV1.Structure;

BEGIN
    SplitV1.InitStructure(theStructure);
    (* sending the request *)
    WriteString(requestCursorPositionStr);
    (* quering the answer *)
    ReadString(str);
    (* extracting coodinates from the answer *)
    (*PROCEDURE Delete (VAR stringVar: ARRAY OF CHAR; startIndex, numberToDelete: CARDINAL);
D   eletes at most numberToDelete characters from stringVar, starting at position startIndex.
    *)
    Delete(str,0,2);
    Delete(str,Length(str) -1 ,1);
    SplitV1.SplitStr(str, ";", theStructure);
    StrToCard(theStructure[0].element,x);
    StrToCard(theStructure[1].element,y);

END requestCursorPosition;

PROCEDURE cursorhome; (*OK*)
    (* Move cursor to upper left corner       ^[[H *)
BEGIN
    WriteString(cursorhomeStr)
END cursorhome;

PROCEDURE cursorhome1; (*OK*)
    (* Move cursor to upper left corner       ^[[;H *)
BEGIN
    WriteString(cursorhome1Str)
END cursorhome1;

PROCEDURE cursorpos(x,y : CARDINAL); (*OK*)
    (* CUP Move cursor to screen location v,h     ^[[<v>;<h>H *)

BEGIN
    WriteString(cursorblplStr);
END cursorpos;

PROCEDURE clearscreen; (*OK*)
(* ED2 Clear entire screen                    ^[[2J *)
BEGIN
    WriteString(clearscreenStr)
END clearscreen;

PROCEDURE screenMode(mode : screenModes);
VAR
    tmpString   : Array7;
BEGIN
    tmpString := "";
    CASE mode OF
        M40x25BW:       Assign(M40x25BWStr, tmpString);       |
        M40x25C:        Assign(M40x25CStr, tmpString);        |
        M80x25BW:       Assign(M80x25BWStr, tmpString);       |
        M80x25C:        Assign(M80x25CStr, tmpString);        |
        M320x200C4:     Assign(M320x200C4Str, tmpString);     |
        M320x200BW:     Assign(M320x200BWStr, tmpString);     |
        M640x200BW:     Assign(M640x200BWStr, tmpString);     |
        M320x200C256:   Assign(M320x200C256Str, tmpString);   |
        M640x200C:      Assign(M640x200CStr, tmpString);      |
        M640x350BW:     Assign(M640x350BWStr, tmpString);     |
        M640x350C:      Assign(M640x350CStr, tmpString);      |
        M640x480BW:     Assign(M640x480BWStr, tmpString);     |
        M640x480C:      Assign(M640x480CStr, tmpString);      |
        M320x200C:      Assign(M320x200CStr, tmpString);
    END;
    WriteString(tmpString)
END screenMode;

PROCEDURE resetScreenMode(mode : screenModes);
BEGIN
   WriteString(resetScreenModeStr)
END resetScreenMode;

PROCEDURE lineWrapping;
BEGIN
   WriteString(lineWrappingStr)
END lineWrapping;

PROCEDURE resetLineWrapping;
BEGIN
   WriteString(resetLineWrappingStr)
END resetLineWrapping;

PROCEDURE makeCursorInvisible;
BEGIN
   WriteString(makeCursorInvisibleStr)
END makeCursorInvisible;

PROCEDURE makeCursorVisible;
BEGIN
   WriteString(makeCursorVisibleStr)
END makeCursorVisible;

PROCEDURE restoreScreen;
BEGIN
   WriteString(restoreScreenStr)
END restoreScreen;

PROCEDURE saveScreen;
BEGIN
   WriteString(saveScreenStr)
END saveScreen;

PROCEDURE enableAlternativeBuffer;
BEGIN
   WriteString(enableAlternativeBufferStr)
END enableAlternativeBuffer;

PROCEDURE disableAlternativeBuffer;
BEGIN
   WriteString(disableAlternativeBufferStr)
END disableAlternativeBuffer;

PROCEDURE setAttribut ( attribut : Attribut; front, back : Colors );
    (* esc + [ + attribut + ; + front + ; back + m, written directly. *)
BEGIN
    WriteChar(ASCII.esc);
    WriteChar("[");
    (* attribute *)
    CASE attribut OF
      boldAt:           WriteString("1");   |
      dimAt:            WriteString("2");   |
      italicAt:         WriteString("3");   |
      underlineAt:      WriteString("4");   |
      blinkingAt:       WriteString("5");   |
      inverseAt:        WriteString("7");   |
      hiddenAt:         WriteString("8");   |
      strikethroughAt:  WriteString("9");   |
      doubleunderlineAt:WriteString("21");
    END;
    (* ; *)
    WriteChar(";");
    (* front *)
    CASE front OF
        Black:          WriteString("30"); |
        Red:            WriteString("31"); |
        Green:          WriteString("32"); |
        Yellow:         WriteString("33"); |
        Blue:           WriteString("34"); |
        Magenta:        WriteString("35"); |
        Cyan:           WriteString("36"); |
        White:          WriteString("37"); |
        Default:        WriteString("39"); |
        BrightBlack:    WriteString("90"); |
        BrightRed:      WriteString("91"); |
        BrightGreen:    WriteString("92"); |
        BrightYellow:   WriteString("93"); |
        BrightBlue:     WriteString("94"); |
        BrighMagenta:   WriteString("95"); |
        BrightCyan:     WriteString("96"); |
        BrightWhite:    WriteString("97");
    END;
    WriteChar(";");
    (* back *)
    CASE back OF
        Black:          WriteString("40");  |
        Red:            WriteString("41");  |
        Green:          WriteString("42");  |
        Yellow:         WriteString("43");  |
        Blue:           WriteString("44");  |
        Magenta:        WriteString("45");  |
        Cyan:           WriteString("46");  |
        White:          WriteString("47");  |
        Default:        WriteString("49");  |
        BrightBlack:    WriteString("100"); |
        BrightRed:      WriteString("101"); |
        BrightGreen:    WriteString("102"); |
        BrightYellow:   WriteString("103"); |
        BrightBlue:     WriteString("104"); |
        BrighMagenta:   WriteString("105"); |
        BrightCyan:     WriteString("106"); |
        BrightWhite:    WriteString("107");
    END;
    (* m *)
    WriteChar("m")
END setAttribut;

(* 
#
#  All codes below are for use in VT52 compatibility mode.
# 
*)

PROCEDURE VT52setansi; (*OK*)
    (* Enter/exit ANSI mode (VT52)            ^[< *)
BEGIN
    WriteString(setansiStr)
END VT52setansi ;

PROCEDURE VT52altkeypad;
    (* Enter alternate keypad mode            ^[= *)
BEGIN
    WriteString(altkeypadStr)
END VT52altkeypad;

PROCEDURE VT52numkeypad ;
    (* Exit alternate keypad mode             ^[> *)
BEGIN
    WriteString(numkeypadStr)
END VT52numkeypad;

PROCEDURE VT52setgr ;
    (* Use special graphics character set     ^[F *)
BEGIN
    WriteString(setgrStr)
END VT52setgr;

PROCEDURE VT52resetgr;
    (* Use normal US/UK character set         ^[G *)
BEGIN
    WriteString(resetgrStr)
END VT52resetgr;

PROCEDURE VT52cursorup; (*OK*)
    (* Move cursor up one line                ^[A *)
BEGIN
    WriteString(cursorupStr)
END VT52cursorup;

PROCEDURE VT52cursordn; (*OK*)
    (* Move cursor down one line              ^[B *)
BEGIN
    WriteString(cursordnStr)
END VT52cursordn;

PROCEDURE VT52cursorrt; (*OK*)
    (* Move cursor right one char             ^[C *)
BEGIN
    WriteString(cursorrtStr)
END VT52cursorrt;

PROCEDURE VT52cursorlf; (*OK*)
    (* Move cursor left one char              ^[D *)
BEGIN
    WriteString(cursorlfStr)
END VT52cursorlf;

PROCEDURE VT52cursorhome; (*OK*)
    (* Move cursor to upper left corner       ^[H *)
BEGIN
    WriteString(cursorhomeStr)
END VT52cursorhome;

PROCEDURE VT52cursorpos(y ,x : CARDINAL);
    (* Move cursor to v,h location            ^[<v><h> *)
    VAR
        xPos, yPos      : CARDINAL;

BEGIN
    WriteString(cursorposStr);
    xPos := x  + 31;
    yPos := y + 31;
    (* don't forget to flip x and y *)
    WriteChar(CHR(yPos));
    WriteChar(CHR(xPos))
END VT52cursorpos;

PROCEDURE VT52revindex;
    (* Generate a reverse line-feed           ^[I *)
BEGIN
    WriteString(revindexStr)
END VT52revindex;

PROCEDURE VT52cleareol; (*OK*)
    (* Erase to end of current line           ^[K *)
BEGIN
    WriteString(cleareolStr)
END VT52cleareol;

PROCEDURE VT52cleareos; (*OK*)
    (* Erase to end of screen                 ^[J *)
BEGIN
    WriteString(cleareosStr)
END VT52cleareos;

PROCEDURE VT52ident;
    (* Identify what the terminal is          ^[Z *)
BEGIN
    WriteString(identStr)
END VT52ident;

PROCEDURE VT52identresp;
    (* Correct response to ident              ^[/Z *)
BEGIN
    WriteString(identrespStr)
END VT52identresp; 

PROCEDURE CloseTerminal;
    (* PROCEDURE tcsetattr (fd: INTEGER; option: INTEGER; t: TERMIOS) : INTEGER ; *)

   VAR
        theResult : INTEGER;
BEGIN
    theResult  := termios.tcsetattr(savedFd,termios.lflusho,theterminal);
    IF theResult <> 0 THEN
        WriteString(" Terminal state properly restored !")
    ELSE
        WriteString("Terminal not properly restored !")
    END;
END CloseTerminal;


PROCEDURE InitTerminal;
(* PROCEDURE tcgetattr (fd: INTEGER; t: TERMIOS) : INTEGER ; *)

    VAR
        theResult : INTEGER;
BEGIN
    theterminal := termios.InitTermios();
    theResult  := termios.tcgetattr(savedFd, theterminal);
    IF theResult <> -1 THEN
        WriteString(" Terminal state properly saved !")
    ELSE
        WriteString("Terminal state not properly saved")
    END;
    termios.cfmakeraw (theterminal) ;
END InitTerminal;

BEGIN
    (* VT 52 mode *)
    Concat(ASCII.esc,"[<",setansiStr);

    Concat(ASCII.esc,"[=",altkeypadStr);
    Concat(ASCII.esc,"[>",numkeypadStr);

    Concat(ASCII.esc,"[F",setgrStr);
    Concat(ASCII.esc,"[G",resetgrStr);

    Concat(ASCII.esc,"[A",cursorupStr);
    Concat(ASCII.esc,"[B",cursordnStr);
    Concat(ASCII.esc,"[C",cursorrtStr);
    Concat(ASCII.esc,"[D",cursorlfStr);
    Concat(ASCII.esc,"[H",cursorhomeStr);
    Concat(ASCII.esc,"[Y",cursorposStr);
    Concat(ASCII.esc,"[I",revindexStr);

    Concat(ASCII.esc,"[K",cleareolStr);
    Concat(ASCII.esc,"[J",cleareosStr);

    Concat(ASCII.esc,"[Z",identStr);
    Concat(ASCII.esc,"[/Z",identrespStr);

    (* VT100 mode *)
    Concat(ASCII.esc,"[",setnlStr);
    Concat(ASCII.esc,"[",setapplStr);
    Concat(ASCII.esc,"[",setansi1Str);
    Concat(ASCII.esc,"[",setcolStr);
    Concat(ASCII.esc,"[",setsmoothStr);
    Concat(ASCII.esc,"[",setrevscrnStr);
    Concat(ASCII.esc,"[",setorgrelStr);
    Concat(ASCII.esc,"[",setwrapStr);
    Concat(ASCII.esc,"[",setrepStr);
    Concat(ASCII.esc,"[",setinterStr);

    Concat(ASCII.esc,"[",setlfStr);
    Concat(ASCII.esc,"[",setcursorStr);
    Concat(ASCII.esc,"[",setvt52Str);
    Concat(ASCII.esc,"[",resetcolStr);
    Concat(ASCII.esc,"[",setjumpStr);
    Concat(ASCII.esc,"[",setnormscrnStr);
    Concat(ASCII.esc,"[",setorgabsStr);
    Concat(ASCII.esc,"[",resetwrapStr);
    Concat(ASCII.esc,"[",resetrepStr);
    Concat(ASCII.esc,"[",resetinterStr);

    Concat(ASCII.esc,"[",altkeypad1Str);
    Concat(ASCII.esc,"[",numkeypad1Str);

    Concat(ASCII.esc,"[",setukg0Str);
    Concat(ASCII.esc,"[",setukg1Str);
    Concat(ASCII.esc,"[",setusg0Str);
    Concat(ASCII.esc,"[",setusg1Str);
    Concat(ASCII.esc,"[",setspecg0Str);
    Concat(ASCII.esc,"[",setspecg1Str);
    Concat(ASCII.esc,"[",setaltg0Str);
    Concat(ASCII.esc,"[",setaltg1Str);
    Concat(ASCII.esc,"[",setaltspecg0Str);
    Concat(ASCII.esc,"[",setaltspecg1Str);

    Concat(ASCII.esc,"[",setss2Str);
    Concat(ASCII.esc,"[",setss3Str);

    Concat(ASCII.esc,"[m",modesoff0Str);
    Concat(ASCII.esc,"[0m",modesoff1Str);
    Concat(ASCII.esc,"[1m",boldStr);
    Concat(ASCII.esc,"[2m",lowintStr);
    Concat(ASCII.esc,"[3m",italicStr);
    Concat(ASCII.esc,"[4m",underlineStr);
    Concat(ASCII.esc,"[5m",blinkStr);
    Concat(ASCII.esc,"[7m",reverseStr);
    Concat(ASCII.esc,"[8m",invisibleStr);
    Concat(ASCII.esc,"[9m",strikethroughStr);

    Concat(ASCII.esc,"[22m",resetboldStr);
    Concat(ASCII.esc,"[22m",resetlowintStr);
    Concat(ASCII.esc,"[23m",resetitalicStr);
    Concat(ASCII.esc,"[24m",resetunderlineStr);
    Concat(ASCII.esc,"[25m",resetblinkStr);
    Concat(ASCII.esc,"[27m",resetreverseStr);
    Concat(ASCII.esc,"[28m",resetinvisibleStr);
    Concat(ASCII.esc,"[29m",resetstrikethroughStr);

(*)
    Concat(ASCII.esc,"[",setwinStr);
    Concat(ASCII.esc,"[",cursorhome0Str);
    Concat(ASCII.esc,"[;H",cursorhome1Str);
    Concat(ASCII.esc,"[6n",requestCursorPositionStr);
    Concat(ASCII.esc,"[",hvhome0Str);
    Concat(ASCII.esc,"[",hvhome1Str);
    Concat(ASCII.esc,"[",cursorbnlStr);
    Concat(ASCII.esc,"[",cursorblplStr);
    Concat(ASCII.esc,"[",cursottocolStr);
    Concat(ASCII.esc,"[",hvposStr);
    Concat(ASCII.esc,"[",indexStr);
    Concat(ASCII.esc,"[",revindex1Str);
    Concat(ASCII.esc,"[",nextlineStr);
    Concat(ASCII.esc,"[",savecursStr);
    Concat(ASCII.esc,"[",restorecursorStr);

    Concat(ASCII.esc,"[",tabsetStr);
    Concat(ASCII.esc,"[",tabclr0Str);
    Concat(ASCII.esc,"[",tabclr1Str);
    Concat(ASCII.esc,"[",tabclrallStr);

    Concat(ASCII.esc,"[",dhtopStr);
    Concat(ASCII.esc,"[",dhbotStr);
    Concat(ASCII.esc,"[",swshStr);
    Concat(ASCII.esc,"[",dwshStr);

    Concat(ASCII.esc,"[",cleareol0Str);
    Concat(ASCII.esc,"[",cleareol1Str);
    Concat(ASCII.esc,"[",clearbol2Str);
    Concat(ASCII.esc,"[",clearlineStr);

    Concat(ASCII.esc,"[",cleareos0Str);
    Concat(ASCII.esc,"[",cleareos1Str);
    Concat(ASCII.esc,"[",clearbos2Str);
    Concat(ASCII.esc,"[2J",clearscreenStr);

    Concat(ASCII.esc,"[",devstatStr);
    Concat(ASCII.esc,"[",termokStr);
    Concat(ASCII.esc,"[",termnokStr);

    Concat(ASCII.esc,"[",getcursorStr);
    Concat(ASCII.esc,"[",cursorpos2Str);

    Concat(ASCII.esc,"[",ident1Str);
    Concat(ASCII.esc,"[",ident2Str);
    Concat(ASCII.esc,"[",gettypeStr);

    Concat(ASCII.esc,"[",resetStr);

    Concat(ASCII.esc,"[",alignStr);
    Concat(ASCII.esc,"[",testpuStr);
    Concat(ASCII.esc,"[",testlbStr);
    Concat(ASCII.esc,"[",testpurepStr);
    Concat(ASCII.esc,"[",testlbrepStr);

    Concat(ASCII.esc,"[",ledsoffStr);
    Concat(ASCII.esc,"[",led1Str);
    Concat(ASCII.esc,"[",led2Str);
    Concat(ASCII.esc,"[",led3Str);
    Concat(ASCII.esc,"[",led4Str);
*)

    Concat(ASCII.esc,"[=0h",M40x25BWStr);    (*	40 x 25 monochrome (text)*)
    Concat(ASCII.esc,"[=1h",M40x25CStr);     (* 	40 x 25 color (text)*)
    Concat(ASCII.esc,"[=2h",M80x25BWStr);  (* 	80 x 25 monochrome (text)*)
    Concat(ASCII.esc,"[=3h",M80x25CStr);     (* 	80 x 25 color (text)*)
    Concat(ASCII.esc,"[=4h",M320x200C4Str);   (* 	320 x 200 4-color (graphics)*)
    Concat(ASCII.esc,"[=5h",M320x200BWStr);  (* 	320 x 200 monochrome (graphics)*)
    Concat(ASCII.esc,"[=6h",M640x200BWStr);  (* 	640 x 200 monochrome (graphics)*)
    Concat(ASCII.esc,"[=7h",resetLineWrappingStr);              (* 	Enables line wrapping*)
    (* [=13h "320x200 color" dropped: it overwrote M640x200BWStr and
    matches no declared mode variable; see M320x200CStr ([=19h)). *)
    Concat(ASCII.esc,"[=14h",M640x200CStr);  (* 	640 x 200 color (16-color graphics)*)
    Concat(ASCII.esc,"[=15h",M640x350BWStr);(* 	640 x 350 monochrome (2-color graphics)*)
    Concat(ASCII.esc,"[=16h",M640x350CStr);  (* 	640 x 350 color (16-color graphics)*)
    Concat(ASCII.esc,"[=17h",M640x480BWStr); (*	640 x 480 monochrome (2-color graphics)*)
    Concat(ASCII.esc,"[=18h",M640x480CStr);  (* 	640 x 480 color (16-color graphics)*)
    Concat(ASCII.esc,"[=19h",M320x200CStr);  (* 	320 x 200 color (256-color graphics)*)
    (* ESC[={value}l *)

    Concat(ASCII.esc,"[?25l",makeCursorInvisibleStr); (* ESC[?25l 	make cursor invisible *)
    Concat(ASCII.esc,"[?25h",makeCursorVisibleStr); (* ESC[?25h 	make cursor visible *)
    Concat(ASCII.esc,"[?47l",restoreScreenStr); (* ESC[?47l 	restore screen *)
    Concat(ASCII.esc,"[?47h",saveScreenStr); (* ESC[?47h 	save screen *)
    Concat(ASCII.esc,"[?1049h",enableAlternativeBufferStr); (* ESC[?1049h 	enables the alternative buffer *)
    Concat(ASCII.esc,"[?1049l",disableAlternativeBufferStr); (* ESC[?1049l 	disables the alternative buffer *)

    Concat(ASCII.esc,"[28m",resetinvisibleStr);          (* ESC[28m. *)
    Concat(ASCII.esc,"[21m",doubleUnderlineStr);             (* ESC[21m *)
    Concat(ASCII.esc,"[24m",resetDoubleUnderlineStr);      (* ESC[24m. *)

END VT100.

   (*Debug*)
    (* chaine := "toto"; *)
    (* FOR i := 0 TO Length(tmpString) DO
        WriteHex(ORD(tmpString[i]),2);
        WriteChar(" ")
    END; *)
    (*End Debug*)