Código de escape ANSI - ANSI escape code

ANSI X3.64 (ISO 6429)

Saída do monitor do sistema htop , um aplicativo ncurses (que usa SGR e outras sequências de controle ANSI / ISO).
Padrão
Classificação	Código de controle baseado em ISO / IEC 2022 e conjunto de sequência de controle
Outras codificações relacionadas	Outros padrões de função de controle: ITU T.101 , JIS X 0207 , ISO 6630 , DIN 31626 , ETS 300 706
v t e

As sequências de escape ANSI são um padrão para sinalização em banda para controlar a localização do cursor, cor, estilo da fonte e outras opções em terminais de texto de vídeo e emuladores de terminal . Certas sequências de bytes , a maioria começando com um caractere de escape ASCII e um caractere de colchete , são incorporadas ao texto. O terminal interpreta essas sequências como comandos, em vez de texto para exibir literalmente.

As sequências ANSI foram introduzidas na década de 1970 para substituir as sequências específicas do fornecedor e se espalharam no mercado de equipamentos de informática no início dos anos 1980. Eles são usados ​​em aplicativos de desenvolvimento, científicos e comerciais baseados em texto, bem como em sistemas de BBS para oferecer funcionalidade padronizada.

Embora os terminais de texto de hardware tenham se tornado cada vez mais raros no século 21, a relevância do padrão ANSI persiste porque a grande maioria dos emuladores de terminal e consoles de comando interpretam pelo menos uma parte do padrão ANSI.

História

Quase todos os fabricantes de terminais de vídeo adicionaram sequências de escape específicas do fornecedor para realizar operações como colocar o cursor em posições arbitrárias na tela. Um exemplo é o terminal VT52 , que permite que o cursor seja colocado em um local x, y na tela, enviando o ESCcaractere, um Ycaractere e, em seguida, dois caracteres representando com valores numéricos iguais ao local x, y mais 32 (assim começando no caractere de espaço ASCII e evitando os caracteres de controle). O Hazeltine 1500 tinha um recurso semelhante, invocado usando e ~, em DC1seguida, as posições X e Y separadas por uma vírgula. Embora os dois terminais tenham funcionalidade idêntica a este respeito, diferentes sequências de controle tiveram que ser usadas para invocá-los.

Como essas sequências eram diferentes para terminais diferentes, bibliotecas elaboradas como termcap ("capacidades de terminal") e utilitários como tput tiveram que ser criadas para que os programas pudessem usar a mesma API para trabalhar com qualquer terminal. Além disso, muitos desses terminais exigiam o envio de números (como linha e coluna) como os valores binários dos caracteres; para algumas linguagens de programação e para sistemas que não usavam ASCII internamente, muitas vezes era difícil transformar um número no caractere correto.

O padrão ANSI tentou resolver esses problemas criando um conjunto de comandos que todos os terminais usariam e exigindo que todas as informações numéricas sejam transmitidas como números ASCII. O primeiro padrão da série foi o ECMA-48, adotado em 1976. Era uma continuação de uma série de padrões de codificação de caracteres, sendo o primeiro o ECMA-6 de 1965, um padrão de 7 bits do qual se originou o ISO 646 . O nome "seqüência de escape ANSI" data de 1979, quando o ANSI adotou o ANSI X3.64. O comitê ANSI X3L2 colaborou com o comitê ECMA TC 1 para produzir padrões quase idênticos. Esses dois padrões foram fundidos em um padrão internacional, ISO 6429. Em 1994, ANSI retirou seu padrão em favor do padrão internacional.

O terminal de exibição de vídeo DEC VT100.

O primeiro terminal de vídeo popular a suportar essas sequências foi o Digital VT100 , lançado em 1978. Esse modelo fez muito sucesso no mercado, o que gerou uma variedade de clones VT100, entre os quais o mais antigo e popular foi o muito mais acessível Zenith Z -19 em 1979. Outros incluíram o Qume QVT-108, Televideo TVI-970, Wyse WY-99GT, bem como os modos "VT100" ou "VT103" ou "ANSI" opcionais com vários graus de compatibilidade em muitas outras marcas. A popularidade destes gradualmente levou a mais e mais softwares (especialmente sistemas de BBS e outros serviços online ) assumindo que as sequências de escape funcionaram, levando a quase todos os novos terminais e programas de emulação que os suportam.

Em 1981, o ANSI X3.64 foi adotado para uso no governo dos Estados Unidos pela publicação 86 do FIPS . Mais tarde, o governo dos Estados Unidos parou de duplicar os padrões da indústria, então o FIPS publicou. 86 foi retirado.

O ECMA-48 foi atualizado diversas vezes e atualmente está em sua 5ª edição, de 1991. Também é adotado pela ISO e IEC como padrão ISO / IEC 6429 . Uma versão é adotada como Padrão Industrial Japonês , como JIS X 0211 .

Os padrões relacionados incluem ITU T.61 , o padrão Teletex e o ISO / IEC 8613 , o padrão Open Document Architecture (principalmente ISO / IEC 8613-6 ou ITU T.416). Os dois sistemas compartilham muitos códigos de escape com o sistema ANSI, com extensões que não são necessariamente significativas para terminais de computador. Ambos os sistemas caíram rapidamente em desuso, mas o ECMA-48 marca as extensões usadas neles como reservadas.

Suporte de plataforma

Sistemas tipo Unix

Embora as bibliotecas do estilo termcap / terminfo tenham sido desenvolvidas principalmente no e para o Unix, em meados da década de 1980 os programas executados em sistemas operacionais do tipo Unix quase sempre podiam assumir que estavam usando um terminal ou emulador que suportava sequências ANSI; isso levou ao uso generalizado de ANSI por programas executados nessas plataformas. Por exemplo, muitos jogos e scripts de shell e utilitários, como listas de diretórios de cores, gravam diretamente as sequências ANSI e, portanto, não podem ser usados ​​em um terminal que não as interprete. Muitos programas, incluindo editores de texto como vi e GNU Emacs , usam termcap ou terminfo, ou usam bibliotecas como curses que usam termcap ou terminfo e, portanto, em teoria suportam terminais não ANSI, mas isso é tão raramente testado hoje em dia que são improvável que funcione com esses terminais.

O emulador de terminal Xterm.

Emuladores de terminal para comunicação com programas locais e também com máquinas remotas e o console do sistema de texto quase sempre oferecem suporte a códigos de escape ANSI. Isso inclui emuladores de terminal como xterm , rxvt , GNOME Terminal e Konsole em sistemas com sistemas de janela baseados em X11 ou Wayland e Terminal.app e emuladores de terminal de terceiros, como iTerm2 no macOS .

DOS, OS / 2 e Windows

MS-DOS 1.x não oferece suporte a ANSI ou qualquer outra seqüência de escape. Apenas alguns caracteres de controle ( BEL , CR , LF , BS ) foram interpretados pelo BIOS subjacente, tornando quase impossível fazer qualquer tipo de aplicativo de tela inteira. Quaisquer efeitos de exibição tinham que ser feitos com chamadas de BIOS, que eram notoriamente lentas, ou manipulando diretamente o hardware do PC IBM.

O DOS 2.0 introduziu a capacidade de adicionar um driver de dispositivo para as sequências de escape ANSI - o padrão de fato sendo ANSI.SYS , mas outros como ANSI.COM , NANSI.SYS e ANSIPLUS.EXE também são usados ​​(estes são consideravelmente mais rápidos porque ignorar o BIOS). A lentidão e o fato de não ter sido instalado por padrão faz com que o software raramente tire vantagem disso; em vez disso, os aplicativos continuaram a manipular diretamente o hardware para obter a exibição de texto necessária. ANSI.SYS e drivers semelhantes continuaram a funcionar no Windows 9x até o Windows ME e em sistemas derivados do NT para programas legados de 16 bits em execução no NTVDM .

Muitos clones do DOS foram capazes de interpretar as sequências e não exigem o carregamento de um driver ANSI separado. O PTS-DOS , bem como o DOS simultâneo , o DOS multiusuário e o REAL / 32 possuem suporte integrado (além de várias extensões). OS / 2 tinha um comando ANSI que habilitava as sequências.

O Console do Windows não oferece suporte a sequências de escape ANSI, nem a Microsoft fornece nenhum método para ativá-las. Algumas substituições ou acréscimos para a janela do console, como JP Software's TCC (anteriormente 4NT), Michael J. Mefford's ANSI.COM, Jason Hood's ANSICON e Maximus5 's ConEmu interpretaram sequências de escape ANSI impressas por programas. Um pacote Python interpretou internamente as sequências de escape ANSI no texto que está sendo impresso, convertendo-as em chamadas para manipular a cor e a posição do cursor, para facilitar a portabilidade do código Python usando ANSI para o Windows. O Cygwin executa uma tradução semelhante para todas as saídas gravadas no console usando os descritores de arquivo Cygwin, a filtragem é feita pelas funções de saída do cygwin1.dll , para permitir a portabilidade do código POSIX C para o Windows.

Em 2016, a Microsoft lançou a atualização do Windows 10 versão 1511 que implementou inesperadamente o suporte para sequências de escape ANSI, mais de duas décadas após o lançamento do Windows NT. Isso foi feito junto com o subsistema do Windows para Linux , permitindo que software baseado em terminal semelhante ao Unix usasse as sequências no console do Windows. Infelizmente, o padrão é desativado, mas o Windows PowerShell 5.1 o habilitou. O PowerShell 6 tornou possível incorporar o caractere ESC necessário em uma string com `e. O Windows Terminal , lançado em 2019, suporta as sequências por padrão, e a Microsoft pretende substituir o Windows Console pelo Windows Terminal.

Atari ST

O Atari ST usava o sistema de comando adaptado do VT52 com algumas expansões para suporte a cores, em vez de suportar códigos de escape ANSI.

AmigaOS

O AmigaOS não apenas interpreta sequências de código ANSI para saída de texto na tela, o driver da impressora AmigaOS também as interpreta (com extensões proprietárias do AmigaOS) e as traduz nos códigos necessários para a impressora específica que está realmente conectada.

VMS / OpenVMS

O VMS foi projetado para ser gerenciado interativamente usando terminais de vídeo baseados em texto da Digital, como o já mencionado VT100 ; mais tarde, com emuladores de terminal gráfico, como o Terminal VWS, DECTerm e xterm.

Descrição

Personagens de controle

Embora não seja tecnicamente parte do padrão, quase todos os usuários assumem algumas funções de alguns caracteres de byte único. Isso é usado para reduzir a quantidade de dados transmitidos ou para executar algumas funções que não estão disponíveis nas sequências de escape:

As sequências de escape variam em comprimento. O formato geral para uma sequência de escape compatível com ANSI é definido por ANSI X3.41 (equivalente a ECMA-35 ou ISO / IEC 2022). As sequências de escape consistem apenas em bytes no intervalo 0x20—0x7F (todos os caracteres ASCII não de controle) e podem ser analisadas sem olhar para frente. O comportamento quando um caractere de controle, um byte com o bit alto definido ou um byte que não faz parte de nenhuma sequência válida, é encontrado antes do final, é indefinido.

Sequências de Fe Escape

Se ESCfor seguido por um byte na faixa de 0x40 a 0x5F, é desse tipo. Delegado ao padrão de código de controle C1 aplicável . Consequentemente, todas as sequências de escape correspondentes aos códigos de controle C1 de ANSI X3.64 / ECMA-48 seguem este formato.

O padrão diz que, em ambientes de 8 bits, as funções de controle correspondentes às Fesequências de escape do tipo (aquelas do conjunto de códigos de controle C1 ) podem ser representadas como bytes únicos no intervalo 0x80–0x9F. No entanto, em dispositivos modernos, esses códigos são frequentemente usados ​​para outros fins, como partes de UTF-8 ou para caracteres CP-1252 , portanto, apenas a sequência de 2 bytes é normalmente usada. No caso de UTF-8, um código de controle C1 pode ser codificado como dois bytes (por exemplo, 0xC2,0x8E para U + 008E ), mas nenhum espaço é salvo dessa forma.

Sequências CSI (introdutor de sequência de controle)

Para comandos do introdutor de sequência de controle ou CSI, o ESC [é seguido por qualquer número (incluindo nenhum) de "bytes de parâmetro" no intervalo 0x30–0x3F (ASCII 0–9:;<=>?) e, em seguida, por qualquer número de "bytes intermediários" no intervalo 0x20–0x2F (Espaço ASCII e !"#$%&'()*+,-./), finalmente por um único "byte final" no intervalo 0x40–0x7E (ASCII @A–Z[\]^_`a–z{|}~).

Todas as sequências comuns usam apenas os parâmetros como uma série de números separados por ponto e vírgula, como 1;2;3. Os números ausentes são tratados como 0( 1;;3age como o número do meio 0, e nenhum parâmetro em ESC[matua como um 0código de reinicialização). Algumas sequências (como CUU) tratam 0como 1para tornar úteis os parâmetros ausentes.

Um subconjunto de arranjos foi declarado "privado" para que os fabricantes de terminais pudessem inserir suas próprias sequências sem entrar em conflito com o padrão. As sequências contendo os bytes do parâmetro <=>?ou os bytes finais 0x70–0x7E ( p–z{|}~) são privadas.

O comportamento do terminal é indefinido no caso em que uma sequência CSI contém qualquer caractere fora do intervalo 0x20–0x7E. Esses caracteres ilegais são caracteres de controle C0 (o intervalo 0–0x1F), DEL (0x7F) ou bytes com o bit alto definido. As respostas possíveis são ignorar o byte, processá-lo imediatamente e, além disso, continuar com a sequência CSI, abortá-la imediatamente ou ignorar o resto.

Parâmetros SGR (Selecionar Renderização Gráfica)

Selecione Graphic Rendition (SGR) para definir os atributos de exibição. Vários atributos podem ser definidos na mesma sequência, separados por ponto e vírgula. Cada atributo de exibição permanece em vigor até que uma ocorrência seguinte de SGR o redefina. Se nenhum código for fornecido, CSI mé tratado como CSI 0 m(redefinir / normal).

Cores

3 bits e 4 bits

A especificação original tinha apenas 8 cores e apenas deu nomes a elas. Os parâmetros SGR 30–37 selecionaram a cor do primeiro plano, enquanto 40–47 selecionaram o fundo. Vários terminais implementaram "negrito" (código SGR 1) como uma cor mais brilhante ao invés de uma fonte diferente, fornecendo assim 8 cores de primeiro plano adicionais. Normalmente você não pode obtê-las como cores de fundo, embora às vezes o vídeo inverso (código SGR 7) permita isso. Exemplos: para obter letras pretas sobre fundo branco use ESC[30;47m, para obter vermelho use ESC[31m, para obter vermelho brilhante use ESC[1;31m. Para redefinir as cores para seus padrões, use ESC[39;49m(não suportado em alguns terminais) ou redefina todos os atributos com ESC[0m. Terminais posteriores adicionaram a capacidade de especificar diretamente as cores "brilhantes" com 90–97 e 100–107.

Quando o hardware começou a usar conversores digital-analógico (DACs) de 8 bits, vários softwares atribuíram números de cores de 24 bits a esses nomes. O gráfico abaixo mostra os valores padrão enviados ao DAC para alguns hardwares e softwares comuns; na maioria dos casos, eles são configuráveis.

8 bits

À medida que as tabelas de consulta de 256 cores se tornaram comuns em placas gráficas, sequências de escape foram adicionadas para selecionar a partir de um conjunto predefinido de 256 cores:

ESC[38;5;⟨n⟩m Select foreground color
ESC[48;5;⟨n⟩m Select background color
  0-  7:  standard colors (as in ESC [ 30–37 m)
  8- 15:  high intensity colors (as in ESC [ 90–97 m)
 16-231:  6 × 6 × 6 cube (216 colors): 16 + 36 × r + 6 × g + b (0 ≤ r, g, b ≤ 5)
232-255:  grayscale from black to white in 24 steps

A tecnologia da informação T.416 da ITU - Open Document Architecture (ODA) e formato de intercâmbio: As arquiteturas de conteúdo de caracteres usam ':' como caracteres separadores:

ESC[38;5;⟨n⟩m Select foreground color      where n is a number from the table below
ESC[48;5;⟨n⟩m Select background color

Também houve uma codificação de 88 cores semelhante, mas incompatível, usando a mesma sequência de escape, vista em rxvte xterm-88color. Não se sabe muito sobre o esquema além dos códigos de cores. Ele usa um cubo de cores 4 × 4 × 4.

24 bits

À medida que as placas gráficas "true color" com 16 a 24 bits de cor se tornaram comuns, os aplicativos começaram a oferecer suporte a cores de 24 bits. Emuladores de terminal que suportam a configuração de cores de primeiro plano e fundo de 24 bits com sequências de escape incluem Xterm, Konsole do KDE e iTerm, bem como todos os terminais baseados em libvte, incluindo Terminal GNOME .

ESC[ 38;2;⟨r⟩;⟨g⟩;⟨b⟩ m Select RGB foreground color
ESC[ 48;2;⟨r⟩;⟨g⟩;⟨b⟩ m Select RGB background color

A tecnologia da informação T.416 da ITU - Open Document Architecture (ODA) e formato de intercâmbio: arquiteturas de conteúdo de caracteres que foram adotadas como ISO / IEC International Standard 8613-6 oferece uma versão alternativa que parece ser menos suportada. Os parâmetros após '2', ou seja, até mesmo r, g, b são opcionais. Observe que esta não é apenas a sequência acima com ponto-e-vírgula substituído por dois-pontos, há um "ID de espaço de cor" inicial (este fato não foi percebido por muitos emuladores de terminal, esta omissão parece ter vindo do KDE Konsole). A definição do ID do espaço de cores não está incluída nesse documento, portanto, pode estar em branco para representar o padrão não especificado. Bem como o valor '2' para especificar um formato Vermelho-Verde-Azul (e o '5' acima para uma cor indexada de 0-255), existem alternativas de '0' para a implementação definida e '1' para transparente - nenhum do que tem quaisquer parâmetros adicionais; '3' especifica cores usando um esquema Ciano-Magenta-Amarelo e '4' para um Ciano-Magenta-Amarelo-Preto, o último usando a posição marcada como "não utilizada" para o componente Preto:

ESC[ 38:2:⟨Color-Space-ID⟩:⟨r⟩:⟨g⟩:⟨b⟩:⟨unused⟩:⟨CS tolerance⟩:⟨Color-Space associated with tolerance: 0 for "CIELUV"; 1 for "CIELAB"⟩ m Select RGB foreground color
ESC[ 48:2:⟨Color-Space-ID⟩:⟨r⟩:⟨g⟩:⟨b⟩:⟨unused⟩:⟨CS tolerance⟩:⟨Color-Space associated with tolerance: 0 for "CIELUV"; 1 for "CIELAB"⟩ m Select RGB background color

Sequências OSC (Comando do Sistema Operacional)

Em sua maioria, eles foram definidos pelo Xterm. Por razões históricas, xterm pode encerrar o comando com BELtambém ST.

O Xterm permite que o título da janela seja definido por ESC ]0;this is the window title BEL.

Uma extensão não xterm é o hiperlink, ESC ]8;;link STde 2017, usado por VTE, iTerm2 e mintty.

O console do Linux usa ESC ] P n rr gg bbpara alterar a paleta, que, se embutida em um aplicativo, pode travar outros terminais. No entanto, o acréscimo STserá ignorado pelo Linux e formará uma sequência adequada e ignorável para outros terminais.

Sequências Fs Escape

Se o ESCfor seguido por um byte no intervalo 0x60—0x7E , é desse tipo. Usado para funções de controle registradas individualmente no registro ISO-IR e, conseqüentemente, disponível mesmo em contextos onde um conjunto de códigos de controle C1 diferente é usado. Especificamente, eles correspondem a funções de controle únicas aprovadas pela ISO / IEC JTC 1 / SC 2 e padronizadas pela ISO ou um organismo reconhecido pela ISO. Alguns deles são especificados em ECMA-35 (ISO 2022 / ANSI X3.41), outros em ECMA-48 (ISO 6429 / ANSI X3.64). ECMA-48 refere-se a isso como "funções de controle independentes".

Sequências Fp Escape

Se ESCfor seguido por um byte no intervalo 0x30—0x3F, ele é desse tipo. Separado para funções de controle de uso privado.

Sequências de escape nF

Se ESCfor seguido por um byte no intervalo 0x20—0x2F , é desse tipo. Seguido por qualquer número de bytes adicionais neste intervalo e, em seguida, um byte no intervalo 0x30-0x7E . Eles são posteriormente subcategorizados pelos quatro bits mais baixos do primeiro byte, por exemplo, "tipo 2F" para sequências em que o primeiro byte é 0x22 ; e se o byte final está no intervalo de uso privado 0x30–0x3F (por exemplo, "tipo 2Fp") ou não (por exemplo, "tipo 2Ft"). Eles são usados ​​principalmente para mecanismos de comutação de código ANSI / ISO, como aqueles usados ​​pela ISO-2022-JP , exceto para 3Fsequências de tipo (aquelas em que o primeiro byte intermediário é 0x23), que são usadas para funções de controle individuais. As 3Ftsequências de tipo são reservadas para funções de controle individuais adicionais registradas pelo ISO-IR, enquanto as 3Fpsequências de tipo estão disponíveis para funções de controle de uso privado.

Exemplos

CSI 2 J - Isso limpa a tela e, em alguns dispositivos, posiciona o cursor na posição y, x 1,1 (canto superior esquerdo).

CSI 32 m- Isso torna o texto verde. O verde pode ser um verde escuro e opaco, portanto, você pode ativar o Negrito com a sequência CSI 1 mque o tornaria verde brilhante ou combinado como CSI 32 ; 1 m. Algumas implementações usam o estado Bold para tornar o personagem Bright.

CSI 0 ; 6 8 ; "DIR" ; 13 p- Isso reatribui a tecla F10 para enviar ao buffer do teclado a string "DIR" e ENTER, que na linha de comando do DOS exibiria o conteúdo do diretório atual. (Somente MS-DOS ANSI.SYS) Isso às vezes era usado para bombas ANSI . Este é um código de uso privado (conforme indicado pela letra p), usando uma extensão não padrão para incluir um parâmetro com valor de string. Seguir a letra da norma consideraria que a sequência terminaria na letra D.

CSI s- Isso salva a posição do cursor. Usar a sequência CSI uirá restaurá-lo à posição. Digamos que a posição atual do cursor seja 7 (y) e 10 (x). A sequência CSI ssalvará esses dois números. Agora você pode mover para uma posição diferente do cursor, como 20 (y) e 3 (x), usando a sequência CSI 20 ; 3 Hou CSI 20 ; 3 f. Agora, se você usar a sequência CSI u, a posição do cursor retornará a 7 (y) e 10 (x). Alguns terminais requerem as sequências DEC ESC 7/, ESC 8que são mais amplamente suportadas.

Em script de shell

Códigos de escape ANSI são frequentemente utilizados em UNIX e UNIX-like terminais para fornecer destaque de sintaxe . Por exemplo, em terminais compatíveis, o comando de lista a seguir codifica os nomes dos arquivos e diretórios por tipo.

ls --color

Os usuários podem empregar códigos de escape em seus scripts, incluindo-os como parte da saída padrão ou erro padrão . Por exemplo, o seguinte comando GNU sed embeleza a saída do comando make exibindo linhas contendo palavras começando com "WARN" em vídeo reverso e palavras começando com "ERR" em amarelo brilhante em um fundo vermelho escuro ( letras maiúsculas são ignoradas). As representações dos códigos são destacadas.

make 2>&1 | sed -e 's/.*\bWARN.*/\x1b[7m&\x1b[0m/i' -e 's/.*\bERR.*/\x1b[93;41m&\x1b[0m/i'

A seguinte função Bash pisca o terminal (enviando alternadamente códigos de modo de vídeo normal e reverso) até que o usuário pressione uma tecla.

flasher () { while true; do printf \\e[?5h; sleep 0.1; printf \\e[?5l; read -s -n1 -t1 && break; done; }

Isso pode ser usado para alertar um programador quando um comando longo termina, como com make ; flasher .

printf \\033c

Isso redefinirá o console, semelhante ao comando resetnos sistemas Linux modernos; no entanto, deve funcionar mesmo em sistemas Linux mais antigos e em outras variantes UNIX (não Linux).

Em C

#include <stdio.h>

int main(void)
{
  int i, j, n;
  
  for (i = 0; i < 11; i++) {
    for (j = 0; j < 10; j++) {
      n = 10*i + j;
      if (n > 108) break;
      printf("\033[%dm %3d\033[m", n, n);
    }
    printf("\n");
  }
  return 0;
}

Sequências de entrada terminal

Pressionar teclas especiais no teclado, bem como emitir muitas sequências xterm CSI, DCS ou OSC, geralmente produz uma sequência CSI, DCS ou OSC, enviada do terminal para o computador como se o usuário a tivesse digitado.

Ao digitar a entrada em um terminal, os pressionamentos de tecla fora da área normal do teclado alfanumérico principal podem ser enviados ao host como sequências ANSI. Para as teclas que têm uma função de saída equivalente, como as teclas do cursor, elas geralmente refletem as sequências de saída. No entanto, para a maioria dos pressionamentos de tecla, não há uma sequência de saída equivalente a ser usada.

Existem vários esquemas de codificação e, infelizmente, a maioria dos terminais mistura sequências de diferentes esquemas, de modo que o software host deve ser capaz de lidar com sequências de entrada usando qualquer esquema. Para complicar a questão, os próprios terminais VT têm dois esquemas de entrada, modo normal e modo de aplicação, que podem ser alternados pela aplicação.

(seção de rascunho)

<char>                                -> char
<esc> <nochar>                        -> esc
<esc> <esc>                           -> esc
<esc> <char>                          -> Alt-keypress or keycode sequence
<esc> '[' <nochar>                    -> Alt-[
<esc> '[' (<num>) (';'<num>) '~'      -> keycode sequence, <num> defaults to 1

Se o caractere de terminação for '~', o primeiro número deve estar presente e é um número do código-chave, o segundo número é um valor modificador opcional. Se o caractere final for uma letra, a letra será o valor do código-chave e o número opcional será o valor do modificador.

O valor do modificador é padronizado para 1 e, após subtrair 1, é um bitmap de teclas modificadoras sendo pressionadas: Meta-Ctrl-Alt-Shift. Assim, por exemplo, <esc> [4; 2 ~ é Shift-End, <esc> [20 ~ é a tecla de função 9, <esc> [5C é Ctrl-Right.

vt sequences:
<esc>[1~    - Home        <esc>[16~   -             <esc>[31~   - F17
<esc>[2~    - Insert      <esc>[17~   - F6          <esc>[32~   - F18
<esc>[3~    - Delete      <esc>[18~   - F7          <esc>[33~   - F19
<esc>[4~    - End         <esc>[19~   - F8          <esc>[34~   - F20
<esc>[5~    - PgUp        <esc>[20~   - F9          <esc>[35~   - 
<esc>[6~    - PgDn        <esc>[21~   - F10         
<esc>[7~    - Home        <esc>[22~   -             
<esc>[8~    - End         <esc>[23~   - F11         
<esc>[9~    -             <esc>[24~   - F12         
<esc>[10~   - F0          <esc>[25~   - F13         
<esc>[11~   - F1          <esc>[26~   - F14         
<esc>[12~   - F2          <esc>[27~   -             
<esc>[13~   - F3          <esc>[28~   - F15         
<esc>[14~   - F4          <esc>[29~   - F16         
<esc>[15~   - F5          <esc>[30~   -

xterm sequences:
<esc>[A     - Up          <esc>[K     -             <esc>[U     -
<esc>[B     - Down        <esc>[L     -             <esc>[V     -
<esc>[C     - Right       <esc>[M     -             <esc>[W     -
<esc>[D     - Left        <esc>[N     -             <esc>[X     -
<esc>[E     -             <esc>[O     -             <esc>[Y     -
<esc>[F     - End         <esc>[1P    - F1          <esc>[Z     -
<esc>[G     - Keypad 5    <esc>[1Q    - F2       
<esc>[H     - Home        <esc>[1R    - F3       
<esc>[I     -             <esc>[1S    - F4       
<esc>[J     -             <esc>[T     - 

<esc> [A a <esc> [D são iguais às sequências de saída ANSI. O <num> normalmente é omitido se nenhuma tecla modificadora for pressionada, mas a maioria das implementações sempre emite o <num> para F1-F4. (seção de rascunho)

O Xterm tem uma página de documentação abrangente sobre as várias teclas de função e esquemas de sequência de entrada de mouse dos terminais VT do DEC e vários outros terminais que ele emula. Thomas Dickey adicionou muito suporte a ele ao longo do tempo; ele também mantém uma lista de chaves padrão usadas por outros emuladores de terminal para comparação.

• No console do Linux, certas teclas de função geram sequências do formulário . A sequência CSI deve terminar no .CSI [ char[
• Versões antigas do Terminator são geradas quando F1 – F4 são pressionados com modificadores. O comportamento defeituoso foi copiado do Terminal GNOME .SS3 1; modifiers char
• O xterm responde se for solicitado a posição do cursor e se a tecla F3 for pressionada com modificadores, que colidem no caso da linha == 1. Isso pode ser evitado usando o ? modificador privado como , que será refletido na resposta como .CSI row ; column RCSI 1 ; modifiers RCSI ? 6 nCSI ? row ; column R
• muitos terminais precedem ESCqualquer caractere digitado com a tecla alt pressionada. Isso cria ambigüidade para letras maiúsculas e símbolos @[\]^_, que formariam códigos C1.
• O Konsole é gerado quando F1 – F4 são pressionados com modificadores.SS3 modifiers char

Veja também

• Arte ANSI
• Personagem de controle
• Advanced Video Attribute Terminal Assembler and Recreator (AVATAR)
• ISO / IEC JTC 1 / SC 2
• Códigos de controle C0 e C1

Notas

Referências

links externos

• Padrão ECMA-48, Funções de controle para conjuntos de caracteres codificados . ( 5ª edição, junho de 1991 ), European Computer Manufacturers Association, Genebra 1991 (também publicado pela ISO e IEC como padrão ISO / IEC 6429)
• Documentos DEC vt100.net
• "ANSI.SYS - sequências de escape de emulação de terminal ansi" . Arquivado do original em 6 de fevereiro de 2006 . Página visitada em 22 de fevereiro de 2007 .
• Sequências Xterm / Escape
• AIXterm / Escape Sequences
• Uma coleção de sequências de escape para terminais que são vagamente compatíveis com ECMA-48 e amigos.
• "Sequências de escape ANSI" . Arquivado do original em 25 de maio de 2011.
• ITU-T Rec. T.416 (03/93) Tecnologia da informação - Open Document Architecture (ODA) e formato de intercâmbio: arquiteturas de conteúdo de caracteres