Interfaccia terminale Unix della settima edizione - Seventh Edition Unix terminal interface

L' interfaccia terminale Unix della Settima Edizione è l'astrazione generalizzata, che comprende sia un'interfaccia di programmazione di applicazioni per programmi che un insieme di aspettative comportamentali per gli utenti, di un terminale storicamente disponibile nella Settima Edizione Unix . È stato ampiamente sostituito dall'interfaccia del terminale POSIX .

Concetti e panoramica

L'interfaccia del terminale fornita da Seventh Edition Unix e UNIX / 32V , e presentata anche dalla versione 4 di BSD come il vecchio driver del terminale , era semplice, in gran parte orientata verso le telescriventi come terminali. L'input è stato inserito una riga alla volta, con il driver del terminale nel sistema operativo (e non i terminali stessi) che fornisce semplici funzionalità di modifica della riga. Un buffer è stato mantenuto dal kernel in cui è avvenuta la modifica. Le applicazioni che leggono l'input del terminale riceveranno il contenuto del buffer solo quando return si preme il tasto sul terminale per terminare la modifica della riga. La @ chiave inviata dal terminale al sistema cancellerebbe ("ucciderà") l'intero contenuto corrente del buffer di modifica, e verrebbe normalmente visualizzato come un @ simbolo " " seguito da una sequenza di nuova riga per spostare la posizione di stampa su una nuova riga vuota . La # chiave inviata dal terminale al sistema cancellerebbe l'ultimo carattere dalla fine del buffer di modifica e verrebbe normalmente visualizzato come un # simbolo ' ', che gli utenti dovrebbero riconoscere come denotante una "cancellazione" del carattere precedente ( le telescriventi non sono fisicamente in grado di cancellare i caratteri una volta che sono stati stampati sulla carta).

Dal punto di vista della programmazione, un dispositivo terminale aveva trasmesso e ricevuto velocità di trasmissione , caratteri "cancella" e "kill" (che eseguiva l'editing di riga, come spiegato), caratteri "interrupt" e "quit" (generando segnali a tutti i processi per i quali il terminale era un terminale di controllo), caratteri "start" e "stop" (usati per il controllo del flusso del software ), un carattere "end of file" (che agisce come un ritorno a capo tranne che scartato dal buffer dalla read() chiamata di sistema e quindi potenzialmente causando la restituzione di un risultato di lunghezza zero) e vari flag di modalità che determinano se l'eco locale è stato emulato dal driver del terminale del kernel, se il controllo del flusso del modem è stato abilitato, le lunghezze dei vari ritardi di output, la mappatura per il carattere di ritorno a capo, e le tre modalità di input.

Modalità di input

Le tre modalità di input per i terminali in Seventh Edition Unix erano:

modalità linea (chiamata anche modalità "cotto")

In modalità linea la disciplina di linea esegue tutte le funzioni di modifica della linea e riconosce i caratteri di controllo "interrupt" e "quit" e li trasforma in segnali inviati ai processi. I programmi applicativi che leggono dal terminale ricevono intere righe, dopo che la modifica della riga è stata completata dall'utente premendo Invio.

modalità cbreak

La modalità cbreak è una delle due modalità carattere alla volta. ( Stephen R. Bourne lo chiamava scherzosamente ( Bourne 1983 , p. 288) come una modalità "semicotta" e quindi "rara".) La disciplina di linea non esegue l'editing di riga e le sequenze di controllo per le funzioni di editing di riga vengono trattate come normale immissione di caratteri. I programmi applicativi che leggono dal terminale ricevono i caratteri immediatamente, non appena sono disponibili nella coda di input per essere letti. Tuttavia, i caratteri di controllo "interrupt" e "quit", così come i caratteri di controllo del flusso del modem, vengono ancora gestiti in modo speciale e rimossi dal flusso di input.

modalità raw

la modalità raw è l'altra delle due modalità carattere alla volta. La disciplina di riga non esegue la modifica della riga e le sequenze di controllo per entrambe le funzioni di modifica della riga e per i vari caratteri speciali ("interruzione", "esci" e controllo del flusso) vengono trattate come un normale input di caratteri. I programmi applicativi che leggono dal terminale ricevono immediatamente i caratteri e ricevono l'intero flusso di caratteri inalterato, proprio come proveniva dal dispositivo terminale stesso.

Nell'interfaccia del terminale POSIX, queste modalità sono state sostituite da un sistema di due sole modalità di input: canonica e non canonica . La gestione dei caratteri speciali che generano segnali nell'interfaccia del terminale POSIX è indipendente dalla modalità di ingresso ed è controllabile separatamente.

Terminali di controllo

Nella settima edizione Unix non c'era il controllo del lavoro del terminale e un gruppo di processi non era considerato quello che è considerato oggi.

Ogni processo nel sistema aveva un singolo terminale di controllo o nessun terminale di controllo. Un processo eredita il suo terminale di controllo dal suo genitore. Un terminale di controllo è stato acquisito quando un processo senza terminale di controllo open() è un file di dispositivo terminale che non è già il terminale di controllo per qualche altro processo. Tutti i processi che avevano lo stesso terminale di controllo facevano parte di un unico gruppo di processi .

Interfaccia di programmazione applicazioni

L'interfaccia programmatica per l'interrogazione e la modifica di tutte queste modalità e caratteri di controllo era la ioctl() chiamata di sistema . (Questo ha sostituito le chiamate di sistema stty() e gtty() di Sixth Edition Unix.) Sebbene i caratteri "cancella" e "kill" fossero modificabili dai loro valori predefiniti # e @ , per molti anni dopo l'inerzia dello sviluppo della settima edizione, significava che erano i valori predefiniti nella driver del dispositivo terminale e su molti sistemi Unix, che modificavano le impostazioni del dispositivo terminale solo come parte del processo di accesso, negli script di accesso del sistema eseguiti dopo che l'utente aveva immesso nome utente e password, eventuali errori nelle richieste di accesso e password dovevano essere corretti utilizzando i caratteri chiave di editing storico ereditati dai terminali della telescrivente.

Le costanti simboliche, i cui valori erano fissi e definiti, e le definizioni della struttura dei dati dell'interfaccia programmatica sono state definite nell'intestazione del sgtty.h sistema.

ioctl() operazioni

Le ioctl() operazioni sono state le seguenti:

La sgttyb struttura dei dati

Una struttura dati utilizzata dalle chiamate di sistema del terminale è la sgttyb struttura, la cui definizione del linguaggio di programmazione C è la seguente:

struct sgttyb {
    char sg_ispeed ;    // Input speed
    char sg_ospeed ;    // Output speed
    char sg_erase ;     // Erase character
    char sg_kill ;      // Kill character
    char sg_flags ;     // Control flags
} ;

A differenza dell'interfaccia del terminale POSIX, l'interfaccia del terminale Unix della settima edizione registrava le velocità di trasmissione in ingresso e in uscita direttamente nella struttura dei dati.

L'ingresso e velocità in uscita nel sg_ispeed e sg_ospeed campi erano quelle del dicembre DH-11 , ed erano i numeri da 0 a 15, rappresentato dalle costanti simboliche (in ordine ascendente) B0 , B50 , B75 , B110 , B134 , B150 , B200 , B300 , B600 , B1200 , B1800 , B2400 , B4800 , B9600 , EXTA e EXTB , dove il baud rate era come nel nome (con gli ultimi due "esterno A" e "esterno B"). L'impostazione di una velocità di trasmissione pari a zero obbligava il driver del terminale a riagganciare un modem (se il terminale era un dispositivo modem).

I campi sg_erase e sg_kill erano semplicemente i valori dei caratteri dei caratteri "cancella" e "kill", rispettivamente, predefiniti ai valori (ASCII) per ' # ' e ' @ ' rispettivamente.

Il sg_flags campo specificava vari flag di controllo di input e output, come nella tabella seguente.

La tchars struttura dei dati

Una struttura dati utilizzata dalle chiamate di sistema del terminale è la tchars struttura, la cui definizione del linguaggio di programmazione C è la seguente:

struct tchars {
    char t_intrc ;      // Interrupt
    char t_quitc ;      // Quit
    char t_startc ;     // Start
    char t_stopc ;      // Stop
    char t_eofc ;       // End of File
    char t_brkc ;       // Break (alternative to hardwired LF character with same effect)
} ;

I valori di questi campi erano i valori dei vari caratteri speciali configurabili a livello di codice. Un valore -1 in qualsiasi campo ha disabilitato il suo riconoscimento da parte del driver del terminale.

Riferimenti

Bibliografia