argine - Online nel cloud

PROGRAMMA:

NOME

argine - Un editor orientato allo schermo.

SINOSSI

argine [+indirizzo] [filetto ...]

DESCRIZIONE

Levee è un editor orientato allo schermo basato sull'editor Unix "vi". Fornisce un conciso,
modo potente per inserire e modificare il testo (tuttavia, se vuoi un elaboratore di testi, sei
meglio con WordStar.)

Levee è un editor modificato. Funziona in 3 modalità: visuale, comando e inserimento. La maggior parte
il lavoro di modifica viene eseguito in modalità visuale, la lettura e la scrittura dei file vengono eseguite a comando
mode e la modalità di inserimento fa ciò che ti aspetteresti.

Quando entri in Levee, puoi specificare un indirizzo da cui iniziare a modificare. Questi indirizzi
sono nello stesso formato degli indirizzi in modalità comando, tranne per il fatto che un + nudo ti metterà a
la fine del file.

Levee è copyright (c) 1982-2008 di David L. Parsons. (vedi l'avviso alla fine di questo
documento per le condizioni di distribuzione)

COMANDO MODE COMANDI

Questi comandi sono usati per modificare nuovi file, scrivere file modificati, cambiare
opzioni, sostituzioni e un sottoinsieme dei comandi visivi. Prendono come input
righe intere, terminate da return (per eseguire), o escape (per abortire.)

La modalità di comando si raggiunge digitando ":" o "Q" dalla modalità visuale. Se entri in modalità di comando
digitando ":", Levee eseguirà un comando, quindi tornerà alla modalità visiva dopo
chiedendoti "[altro]". Se digiti qualcosa tranne uno spazio o un ritorno, Levee lo farà
accettare un altro comando e così via. Se, tuttavia, si accede alla modalità di comando tramite "Q",
Levee rimarrà in modalità di comando finché non si immette il comando "visivo".

A NOTA ON COMANDO SINTASSI
Un comando può essere preceduto da un intervallo di righe opzionale. Se non fornisci un intervallo di linee,
Levee utilizzerà l'intervallo di linee predefinito mostrato dal comando. Un intervallo di linee è uno o due
le specifiche dell'indirizzo nel seguente formato:

(.|$|'x|#) [ (+|-) (/patt/|?patt?|#)]

. linea corrente.

$ ultima linea.

'x la linea con il segno x su di essa.

# linea #.

Ad esempio, ".-5,.+5p" stamperà ogni riga entro dieci righe dalla riga corrente. "$-5"
è la quinta riga dalla fine del file e "/end/+2" è la seconda riga dopo
occorrenza successiva del pattern "end". I modelli possono essere espressioni regolari (vedi
sotto.)

Inoltre, un intervallo di linee nudo imposterà la linea corrente sulla prima linea dell'intervallo e
stampa tutte le righe in quell'intervallo. "1,10" imposta la riga corrente su 1, quindi stampa le righe 1
a 10.

Se specifichi una riga inesistente in un intervallo, il comando
si interromperà e Levee ti dirà "indirizzo errato".

Comando modo comandi
args mostra l'elenco di argomenti corrente, se ne esiste uno. Il file che sei attualmente
la modifica sarà incorniciata da '[' e ']'.

(.,.)il cambiamento
eliminare le righe, quindi accedere alla modalità di inserimento.

(.,.)delete
eliminare le righe. Le righe cancellate vengono memorizzate in uno Yank Buffer per un successivo riposizionamento con
"mettere".

modificare[!] [file]
Elimina il file corrente e inizia a modificarne uno nuovo. Se sono state apportate modifiche al
file corrente, devi inserire "modifica!" per forzare Levee a scartare le modifiche. Se tu
non specificare un nome file, Levee proverà a modificare nuovamente il nome file corrente.

Quando Levee legge un nuovo file, ti dirà in quanti byte ha letto, oppure
[overflow] se il file è più grande del buffer interno (256000 byte sulla maggior parte
piattaforme; 20k su USCD Pascal.)

Execmode
Rimanere in modalità di comando finché non si utilizza il comando "visivo".

filetto[nome]
Echo qual è il nome del file corrente, il suo stato e la riga corrente. Se fornisci
con un nome, cambierà il nome del file in quello.

(.)insert
Inserisci il testo sopra la riga corrente. Se specifichi un numero di riga, Levee farà
che la riga corrente, quindi inserire sopra di essa.

inserire modo comandi
^W indietro sull'ultima parola che hai inserito.

^H indietro su un carattere.

^U indietro su tutti gli input su questa linea.

^V sfuggire al carattere digitato successivo. (Per esempio, ^V^H metterà un ^H nel file.)

ESC uscire dalla modalità di inserimento.

^D Se all'inizio della riga, riduci il rientro delle colonne 'shiftwidth'.

^T Se all'inizio della riga, aumentare le colonne 'shiftwidth' di rientro.

In modalità di inserimento, Levee non ti consentirà di inserire alcun carattere di controllo tranne
ritorno e tab. Return termina l'input su questa riga e apre una nuova riga per l'input.

carta geografica[!][chiave[testo]]
Definire/elencare le macro. Ci sono 3 forme di mappa:

Mappa. Elenca tutte le macro attive.

carta geografica(chiave).
Questo mostra la macro associata a (chiave), se presente.

carta geografica(chiave) (testo)
Questo associa (chiave) a (testo). Puoi mappare qualsiasi chiave tranne ":" e escape. Nella normalità
form (mappa), la macro sarà effettiva in modalità visuale, ma nella forma alternativa,
(mappa!), la macro sarà effettiva nelle modalità di inserimento e comando.

Ad esempio, se mappi!ped ritorna a "ciao mondo", ogni volta che inserisci un ritorno in
comando o in modalità visuale, comparirebbe la stringa "ciao mondo".

GENERAZIONE[file...]
Modifica il file successivo nell'arglist o modifica un nuovo arglist. Levee prende la sua iniziale
arglist dalla riga di comando quando lo esegui. Se è impostato "autowrite", Levee
scriverà le modifiche al file corrente prima di modificare quello successivo.

(.)aprire
Inserisci sotto la riga corrente. Altrimenti proprio come inserire.

precedente
Modifica il file precedente nell'arglist. Altrimenti, come il prossimo.

(.,.)stampare
Visualizza le righe senza modificare la riga corrente.

(.)metti Rimetti il ​​contenuto del buffer yank sulla riga sotto la riga corrente. Se tu
specifica una riga, reimposta la riga corrente, quindi reinserisce lo yank buffer. Il
yank buffer è riempito dai comandi delete, change o yank. Mettere non distrugge
lo yank buffer, quindi puoi rimettere il testo più volte.

uscire[!]
Esci dall'argine. Se vuoi annullare le modifiche, usa "quit!"

(.)read[file]
inserisci il contenuto di 'file' dopo la riga corrente.

rmfiletto Elimina "file" dal disco.

set[opzione=valore]
Imposta una variabile sintonizzabile. Levee ha una dozzina di variabili definibili dall'utente che tu
può giocherellare tramite questo comando. Ci sono variabili booleane, intere e stringa che
puoi impostare. Una variabile stringa o intera è impostata da "set xxx=yyy", un valore booleano
la variabile viene impostata tramite "set xxx" o "set noxxx".

Ecco le variabili impostabili (e le abbreviazioni):

dimensione della scheda(t)
tabulazione.

ampiezza di spostamento(SO)
colonne da spostare su ^D, ^T, >> o <

scorrere numero di righe su cui scorrere ^D, ^U

rientro automatico(ai)
fornire indentazione durante la modalità di inserimento.

scrittura automatica(oh)
scrivere le modifiche prima di :next, :prev

autocopia(AC)
eseguire copie di backup prima di scrivere le modifiche.

stratagemma visualizza le schede come ^I, la fine della riga come $.

magia utilizzare le espressioni regolari nelle ricerche.

suffisso se il nome del file non ha . in esso, fornire il suffisso. (questo è l'unico
variabile stringa.)

sovrascrivere(come)
prima distruggi il vecchio file, quindi scrivi.

abbellire(essere)
Quando impostato, Levee non consentirà l'inserimento di alcun carattere di controllo eccetto tab e
return a meno che non lo esca con ctrl-V.

avvolgere
le ricerche avvolgono la fine del buffer.

ignoracaso(circuito integrato)
Ignora il caso dei caratteri alfabetici durante le ricerche.

maplash
(Solo versione ST) Mappare "/" nei nomi di file su "\". Se l'ambiente contiene
`mapslash' quando viene chiamato levee, questa variabile verrà impostata su true, altrimenti
il valore predefinito è falso. (Vedi la documentazione per il Teeny-shell su come il teeny-
shell interpreta `mapslash')

Linee(Li)
(Solo versione ST) Quante righe sul display. Questo è principalmente per la corsa
argine attraverso la porta seriale - metti set li=xx nel tuo LVRC per una linea xx
terminale.

cols(CO)
(solo versione ST) Quante colonne sul display. Come la variabile linee, è
per l'esecuzione di levee attraverso la porta seriale.

Puoi impostare più variabili su una riga, come in 'set ws noai'. Per vedere la corrente
le impostazioni di queste variabili, :set -- senza alcun argomento -- mostrerà la corrente
e socievole.

All'avvio, Levee cerca nella variabile d'ambiente LVRC un elenco di variabili da impostare
(GEMDOS/MS-DOS). LVRC è una riga della forma 'opzione=valore ...'. Se hai un LVRC
definito che è 'ts=4 ow nows', Levee imposterà tabsize su 4, attiverà la sovrascrittura e
fuori wrapscan.

Se stai usando RMX, Levee cerca nel file ":home:r?lvrc" per l'inizializzazione. Se tu
stanno usando Osy/SWO, Levee cerca nel file "*.lvrc". Il formato di questi file è
diverso dalla variabile LVRC -- vedere "fonte" per maggiori informazioni.

sourcefiletto
Prendi i comandi della modalità di comando da 'file'. Questi comandi possono essere qualsiasi comando legale,
tranne "visiva". Se si verifica un errore durante l'esecuzione di 'file', Levee lo abbandona
livello di provenienza.

In Osy/SWO, ci sono alcune differenze nella modalità di inserimento dall'interno di un file di origine.
Nessun carattere ha un significato speciale tranne una riga che non contiene altro che un punto,
che termina la modalità di inserimento. Per esempio:

:comandi
:inserire
bla bla bla bla bla bla
bla bla bla bla bla bla
bla bla bla bla bla bla
:più comandi

Se stai eseguendo Levee con qualsiasi altro sistema operativo, non puoi eseguire un inserimento da a
:file sorgente.

(.,.)sostituisci(elimina)patt(elimina)repl(elimina)[qcpg]

(.,.)sostituto&

Cerca patt e sostituiscilo con repl. Levee cercherà patt una volta su ciascuno
linea e sostituirla con repl. Il delimitatore può essere qualsiasi carattere ascii.

Il modello è un'espressione regolare, proprio come un modello di ricerca.

Puoi includere parti del modello nella stringa di sostituzione; Un '&' nel
il modello sostitutivo copia l'intero modello sorgente, quindi se fai un 'sub/this/&
e quello/g', ogni istanza di 'questo' sarà sostituita con 'questo e quello'. Anche,
puoi estrarre parti del modello usando l'argomento \( e \) meta-
caratteri. Gli argomenti ottenuti da \( & ​​\) vengono inseriti nella stringa di sostituzione
ovunque fai un \1..\9 [ \1 è il primo argomento che imposti con \( & ​​\) ].
Quindi, se vuoi invertire l'ordine di due sottostringhe, puoi farlo
'sub/\(stringa1\)\(stringa2\)/\2\1/'.

sostituisci& ripete l'ultima sostituzione.

Opzioni:

q, c prima di eseguire la sostituzione, visualizza la riga interessata e attendi di digitare a
carattere. Se digiti "y", verrà eseguita la sostituzione. 'q' interrompe il sostituto,
'a' esegue il resto della modifica senza chiedere conferma e 'n' non lo fa.

p stampare le righe interessate dopo la modifica.

g fare il cambiamento a livello globale. Cioè, fallo per ogni occorrenza di patt su una linea,
piuttosto che una volta sola.

disfare Annulla l'ultima modifica al file (eccetto :edit, :next, :rm o :write).
può solo annullare l'ultima modifica a un file: l'annullamento conta come una modifica. :annulla seguito
by :undo non fa nulla al file.

annulla mappa(chiave)
Annulla definizione di una macro (vedi mappa).

visivo[Elenco]
Se sei entrato nella modalità di comando con "Q" o "execmode", torna alla modalità visuale. Se tu
fornisce un elenco di argomenti, esegue anche un `:next' su tale elenco.

versione
Mostra di quale versione di argine si tratta.

(.,.)scrivere [file]
Scrivi righe in un file. Se scrivi tutto su "file", il nome del file è impostato
in 'file', e se non specifichi un file, Levee scriverà il nome del file.

(.,.)wq [file]
Scrivi su un file, quindi esci.

(.,.)strattone
Yank righe dal file nel buffer yank, per il successivo riposizionamento con "put".

esci[!] Scrivi le modifiche al file corrente, quindi esci. Se ci sono più file nel
arglist, usa "xit!"

![comando]
Esegui comando.

Esempio:

!ls => fa un 'ls'.

Questo comando è disponibile solo in GEMDOS, MSDOS, RMX e Unix.

($)= Indicare il numero di linea della linea indirizzata. /end/= ti dà il numero di riga del
riga successiva con una "fine".

VISIVO MODE COMANDI

I comandi della modalità visuale ti spostano e modificano il file. Ci sono comandi di movimento per
spostare il cursore da una varietà di oggetti.

Nella descrizione, un (#) indica un conteggio opzionale. Se un comando ha un conteggio opzionale,
ti dirà cosa fa il conteggio tra parentesi. Un (*) significa che il comando può essere
utilizzato nei comandi delete, yank e change.

I conteggi si effettuano immettendo cifre. Se si digita '45', il conteggio sarà impostato su 45. Per
annullare un conteggio, digitare ESC.

Questa sezione discute occasionalmente degli "spazi bianchi". Gli spazi bianchi sono tabulazioni, spazi e fine di
linea.

Come , il dalla visualizzazione lavori
I caratteri vengono visualizzati sullo schermo come ci si aspetterebbe, tranne che
i caratteri non stampabili vengono mostrati come ^x e le tabulazioni si espandono in spazi (a meno che non imposti il
elenco di opzioni, quindi vengono visualizzati come ^I.) Quando si è seduti su un carattere di controllo o una scheda, il
il cursore è posizionato sul PRIMO carattere visualizzato. Se sposti il ​​cursore su un altro
parte di essi (tramite j o k -- vedi sotto), eventuali modifiche inizieranno dal carattere successivo.

Levee non mostra un marcatore di fine file, ma le righe oltre la fine del file lo sono
indicato da linee ~.

Se l'elenco è impostato, le schede vengono visualizzate come ^I e la fine della riga viene visualizzata come $.

Se una linea è troppo lunga per lo schermo, scomparirà dalla fine dello schermo.

Levee gestirà qualsiasi risoluzione dello schermo e qualsiasi carattere a spaziatura fissa che gli passi (se lo sei
in esecuzione a bassa risoluzione, Levee ti darà una finestra 25x40, ad esempio.)

Visivo modo comandi
^A Mostra un messaggio di debug nella parte inferiore dello schermo. Questo non è per niente utile
a meno che tu non stia eseguendo il debug dell'editor. Ignoralo.

(#)^D Scorri lo schermo verso il basso di metà schermo. Se viene specificato un conteggio, scorrere verso il basso il
numero di righe specificato.

^E Scorri verso il basso di 1 riga (abbreviazione di 1^D )

^G Mostra le statistiche del file. Esattamente come ':file'.

(*)(#)^H
Sposta il cursore a sinistra di uno (conta) caratteri.

^I Ridisegna lo schermo.

(*)(#)^J
Scendi di una (conta) righe. Quando usi ^J e ^K (sotto) per spostarti in alto o in basso
righe, il cursore rimarrà nella stessa colonna, anche se si trova nel mezzo di a
tabstop o oltre la fine di una riga.

(*)(#)^K
Aumenta di una (conta) le righe.

(*)(#)^L
Sposta a destra di uno (conta) caratteri.

(*)(#)^M
Passa al primo spazio non bianco sulla riga successiva. Se viene specificato un conteggio, passare a
il primo conteggio non bianco si allinea verso il basso.

(#)^U Scorri lo schermo di mezza pagina verso l'alto. Se viene specificato un conteggio, scorrere verso l'alto le righe di conteggio.

^Y Scorri lo schermo verso l'alto di 1 riga (abbreviazione di 1^U.)

(#)un Inserisci il testo DOPO il cursore. Se dai un conteggio, l'inserimento verrà ripetuto
contare i tempi (40i-ESC ti darà una linea di 40 trattini).

I comandi in modalità di inserimento sono gli stessi per la modalità visuale e comando.

(*)(#)B
Spostati all'inizio dell'ultima parola (la parola del conteggio all'indietro). Una parola è a
raccolta di caratteri alfanumerici (a-z0-9$_#) o qualsiasi altro carattere non bianco
(cioè tutto tranne spazio, tab, eoln).

c Cambia un oggetto. Modifica elimina un oggetto, quindi entra in modalità di inserimento senza
ridisegnare lo schermo. Quando gli dici l'oggetto da cambiare, Levee mette un '$'
sull'ultimo carattere dell'oggetto. Non puoi cambiare all'indietro.

L'oggetto può essere qualsiasi comando in modalità visuale contrassegnato da un '(*) '. Ad esempio, 'c4l'
cambierà i successivi 4 caratteri sulla riga in qualcos'altro. (4cl fa lo stesso
cosa -- 4c4l cambia i successivi 16 caratteri su questa riga.)

'cc' cambierà intere righe.

Quando si modifica, si elimina o si strappa un oggetto, questo verrà inserito in un buffer di strappo,
dove può essere recuperato dai comandi 'p' o 'P'.

(#)D Elimina un oggetto. Come 'cc', 'dd' ha effetto su intere righe.

(*)(#) e
Sposta alla fine della parola corrente.

(*)(#)f(x)
Trova l'occorrenza successiva (count'th) di un carattere sulla riga corrente. Per
esempio, se il cursore si trova sul primo carattere della riga 'abcdef',
digitando "ff" il cursore verrà posizionato sulla "f".

(*)(#)H
Sposta a sinistra di uno (conta) caratteri. Esattamente come ^H.

(#)io Inizia a inserire i caratteri in corrispondenza del cursore. Se specifichi un conteggio, l'inserimento
sarà duplicato conteggio volte.

(*)(#)J
Scendi di una (conta) righe. Esattamente come ^J.

(*)(#)K
Aumenta di una (conta) le righe. Esattamente come ^K.

,B (*) (#)l
Sposta a destra di un carattere (conta). Esattamente come ^L.

m(x) Imposta l'indicatore (x). Ci sono 26 marcatori disponibili (az). Puoi spostarti su un marcatore
utilizzando i comandi ' o `.

(*)n Trova la prossima occorrenza di un modello di ricerca. Quando fai una ricerca con un / o ?
comando, Levee ricorderà lo schema e la direzione in cui hai cercato. 'n'
cercherà il pattern nella stessa direzione, 'N' cerca nell'opposto
direzione.

o Apre una riga sotto la riga corrente per l'inserimento.

p Rimetti il ​​testo strappato/cancellato dopo il cursore. Il testo viene strappato dall'eliminazione
(d,x,X,D), cambia (c,C,s,S) e yank (y,Y).

(#)r(x)
Sostituisci i caratteri (fino alla fine della riga) con (x). '4ra' cambierà il prossimo 4
caratteri dopo il cursore in 'aaaa'.

(#)S cambia uno (conta) caratteri. Scorciatoia per (#)cl.

(*)(#)t(x)
Sposta su un carattere sulla riga corrente. Se sei sul primo carattere di
la riga 'abcdef' e digiti 'tf', ti ritroverai seduto sulla 'e'.

u Annulla l'ultima modifica. Puoi annullare QUALSIASI comando di modifica eccetto :edit, :next,
:rm o :write. (Proprio come: annulla).

(*)(#) v
Torna indietro alla fine della parola precedente (conta). Vedere 'b' per il
definizione di una parola.

(*)(#)w
Spostati fino all'inizio della parola successiva (count'th).

(#)X Elimina un (conteggio) caratteri in avanti. Scorciatoia per (#)dl.

y Tira un oggetto per un uso successivo mettendolo. 'yy' strappa intere righe.

A Aggiungi testo alla fine della riga. Scorciatoia per $a.

(*)(#)B
Passa all'inizio della parola corrente. Esattamente come 'b'.

NOTA: questo non è corretto. i comandi di movimento delle parole in maiuscolo dovrebbero e lo faranno in
il futuro, essere utilizzato per il movimento da parole delimitate dallo spazio.

C Passa alla fine della riga. Scorciatoia per c$.

D Elimina fino alla fine della riga. Scorciatoia per d$.

(*)(#)FA(x)
Passa alla prima (conta) occorrenza precedente di un carattere sulla riga corrente.
Se sei seduto alla fine della riga 'abcdef', digitando "Fa" ti sposterai indietro
alla 'a' all'inizio della riga.

(*)(#)G
Vai alla linea. Se specifichi un conteggio, Levee si sposterà su quella linea e se non c'è
count, Levee si sposta alla fine assoluta del file.

Per andare all'inizio del file, digita "1G". Alla fine, solo "G".

(*)H Passa al primo carattere non bianco nella parte superiore dello schermo.

I Inserisci alla fine della riga corrente. Scorciatoia per $i.

(#)J Unisci due (conta+1) linee insieme. Joining aggiunge la seconda riga alla fine di
il primo, mettendo uno spazio tra di loro. Se la prima riga termina con uno spazio bianco,
Levee non metterà in uno spazio.

(*)L Passa all'ultimo carattere non bianco sull'ultima riga dello schermo.

(*)M Passa al primo carattere non bianco al centro dello schermo.

O Apre una riga sopra la riga corrente. Altrimenti funziona proprio come 'o'.

P Rimetti lo yank buffer sul cursore. Altrimenti funziona proprio come 'p'.

Q Entra e resta in modalità di comando. Proprio come il comando :exec. Per tornare a
modalità visuale, è necessario immettere il comando ':visual'.

R Sostituisci modalità. Un sottoinsieme limitato della modalità di inserimento che sovrascrive i caratteri fino alla fine
di linea. Si applicano tutti i normali comandi della modalità di inserimento. Se sovrascrivi a
carattere, quindi tornaci sopra con ^H,^U o ^W, riapparirà dopo l'uscita
Sostituisci modalità.

Esci dalla modalità di sostituzione.

NOTA: a causa di un bug, inserendo a in modalità Sostituisci ti riporterà in
modalità visiva con un errore. Le sostituzioni che hai fatto rimarranno.

S Cambia i caratteri all'indietro. Scorciatoia per (#) ch.

(*)(#)V(x)
Torna al carattere sulla riga corrente. Se sei sull'ultimo carattere del
riga 'abcdef', digitando "Ta" tornerai alla 'b'.

(*)(#)W
Sposta alla fine della parola. Esattamente come "e".

(#)X Elimina i caratteri all'indietro. Scorciatoia per (#)dh.

Y Yank a fine linea. Scorciatoia per y$.

ZZ Scrivi le modifiche al file corrente ed esci se è l'ultimo file in arglist. Esattamente come :xit.

(*)(#)$
Sposta alla fine della riga. Se dai un conteggio, spostati alla fine della riga (count-1)
in basso (quindi 2$ ti sposta alla fine della riga successiva).

0 Spostarsi all'inizio della riga corrente. Scorciatoia per 0|.

(#)! Convogliare un oggetto tramite un programma esterno. Come 'cc', '!!' interessa intere righe.

(*)% Trova la parentesi corrispondente, la parentesi o la parentesi ondulata. Se non sei seduto
a '[]{}()', Levee cercherà in avanti uno di essi sulla riga corrente, quindi
corrisponde a ciò che trova.

[spazio]
Passa al primo carattere non bianco sulla riga corrente.

& Ripeti l'ultimo comando di sostituzione.

(*)(#){
Torna all'inizio del conte-esimo paragrafo indietro. Un paragrafo è delimitato da a
riga vuota.

(*)(#)}
Vai alla fine del conte-esimo paragrafo in avanti.

(*)(#)(
Torna all'inizio della frase conte-esima. Una frase è delimitata da a
., un ! o un ? seguito da uno spazio, una tabulazione o la fine della riga.

(*)(#))
Spostati alla fine della frase conte-esima in avanti.

(*)(#)-
Passa alla (conta) riga precedente, la prima non bianca.

(*)(#)+
Passa alla (conta) riga successiva, la prima non bianca.

(#)~ Modificare il caso dei caratteri di conteggio successivi. Le maiuscole diventano minuscole,
minuscolo diventa maiuscolo.

(*)"(x)
Spostarsi nella posizione esatta del segno (x). C'è un marchio speciale per alcuni dei
visual mode move significava comandi -- '' ti sposterà dove eri prima del
ultimo comando (,),',`,G,/,?,n,N.

: Esegue un comando in modalità comando. Al termine del comando, tornerà a
modalità visuale se produce una riga di output, ma se scorre lo schermo, Levee
chiederà [altro] prima di tornare alla modalità visuale. Se digiti un : in risposta a
al prompt [more], Levee rimarrà in modalità comando per un altro comando.

(#)<(#)
Sposta uno (conta) oggetti a sinistra. Se specifichi un secondo conteggio, Levee sposterà il
l'oggetto ha lasciato quel numero di colonne - se non lo fai, saranno sh shiftwidth
colonne.

Questo è un cambiamento non distruttivo. Se lo spostamento dovesse portare oltre il margine sinistro, il
gli oggetti verranno spostati fino al margine sinistro ma non oltre.

Come gli altri comandi di spostamento dell'oggetto, '<<' influenzerà intere linee.

(#)>(#)
Sposta uno (conta) oggetti a destra. Proprio come <, tranne per il fatto che non sposterà gli oggetti oltre
il margine destro dello schermo. Se sposti un oggetto oltre il margine destro di
lo schermo, tutto il suo rientro verrà rimosso e finirà a sinistra
margine.

. Ripetere l'ultimo comando di modifica. (tranne Annulla)

(*)? Cerca il motivo all'indietro. Escape interrompe il modello di ricerca e un modello vuoto
significa cercare di nuovo l'ultimo modello.

(*)/ Cerca il modello in avanti. Altrimenti come ?.

(#)| Sposta nella colonna specificata. Se non hai un conteggio, passa alla colonna 0.

REGOLARE ESPRESSIONI

Levee dà significati speciali ad alcuni caratteri durante un pattern match. Il personaggio
"." corrisponderà a qualsiasi carattere, il carattere "*" corrisponderà a zero o più occorrenze del
carattere precedente ( quindi, a* corrisponderà a 'a','aa','aaa', ecc., oppure non corrisponderà a nulla).
Se un modello inizia con "^", corrisponderà solo all'inizio di una riga e
i modelli che terminano con "$" corrisponderanno solo alla fine di una riga.

Anche le parentesi quadre ('[]') hanno un significato speciale. Significano corrispondere a uno qualsiasi dei caratteri
all'interno delle parentesi. '[abc]' corrisponderà a 'a', 'b' o 'c'. È possibile specificare un intervallo di
caratteri tra parentesi utilizzando un trattino (-). '[az]' corrisponderà a qualsiasi minuscolo
carattere alfabetico. Se ^ è il primo carattere tra parentesi, significa che corrisponde a qualsiasi
carattere tranne quelli tra parentesi. '[^abc]' corrisponderà a qualsiasi cosa tranne 'a','b' o
'C'.

La barra rovesciata toglie un significato speciale a questi caratteri, ma '\t' specifica una scheda e
\( & \) delimita gli argomenti all'interno di un pattern (usato solo da :substitute.) I pattern
\< e \> hanno anche un significato speciale; corrispondono all'inizio e alla fine dei caratteri alfanumerici
gettoni.

Se disattivi la variabile dell'editor 'magic', nessuno dei caratteri sopra avrà
significato speciale all'interno di un pattern (vedi 'set').

Alcuni modelli di esempio:

^fine$ Trova una linea che sia solo "fine".

[E][Nn][Dd]
Trova una 'fine', ignorando il caso.

[A-Za-z][A-Za-z0-9]*
Trova il prossimo identificatore.

([*].*[*])
Trova il prossimo commento pascal di una riga.

Trova la prossima occorrenza di "the".

LIMITAZIONI

Levee può modificare solo file lunghi fino a 256000 caratteri. ^M è usato come sua linea interna
separator, quindi l'inserimento di ^M avrà conseguenze interessanti.

Usa levee online utilizzando i servizi onworks.net