Documentazione mIRC

alias

alias

Indice

mIRC

Comandi e identificatori

Nozioni di base

Eventi

Strumenti di corrispondenza

Archiviazione dati

Strutture di controllo

Scripting GUI

Socket

Scripting avanzato

Risorse aggiuntive

Sicurezza

Altro

In molti casi, è più facile scrivere un programma grande lavorando su una singola, piccola unità logica alla volta. Gli alias, più comunemente noti in altri linguaggi come funzioni, sono blocchi di codice che eseguono un compito specifico e possono essere relativamente indipendenti dal resto dello script. La maggior parte degli alias viene creata per essere usata più volte da script diversi. Oltre al loro utilizzo normale, gli alias possono anche essere usati per creare operazioni personalizzate di scorciatoie e tasti funzione.

Contenuto

Sintassi:

Gli alias hanno la seguente sintassi di base:

;single-line alias
alias aliasName /commands
 
;multi-line alias
alias aliasName {
  /commands
}

Un semplice alias hello world apparirebbe così:

Alias hello {
  echo -a Hello World!
}

La parola chiave “alias” è necessaria per dire a mIRC che il codice seguente è un alias. “hello” è il nome dell’alias. Tutto ciò che si trova all’interno della coppia di parentesi graffe ({ e }) verrà eseguito quando questo alias viene chiamato. Per chiamare quell’alias, basta chiamarne il nome:

//hello

Questo stamperà:

Hello World!

Argomenti degli alias

I dati possono essere passati agli alias tramite la lista degli argomenti. La lista degli argomenti viene sempre valutata da sinistra a destra. Gli argomenti vengono passati all’alias tramite gli identificatori $N, dove N è un valore numerico che parte da uno.

Se chiamassimo un alias chiamato “example” in questo modo:

/example A B C D
; or
... $example(A, B, C, D)

L’alias example avrà $1 che restituisce ‘A’, $2 che restituisce ‘B’, $3 che restituisce ‘C’ e $4 che restituisce ‘D’. Il numero totale di token disponibili può essere recuperato tramite l’identificatore $0. In questo caso $0 restituirà 4.

Le regole esatte su come funziona $N sono identiche a quelle del comando /tokenize. Maggiori informazioni su $1- qui

Scheda Aliases

La scheda aliases è progettata specificamente solo per gli alias. Nota che, poiché può essere usata solo per gli alias, il prefisso “alias” deve essere omesso:

aliasName {
  ; commands
}

Nota: Gli alias della scheda aliases possono chiamare liberamente gli alias della scheda remote e viceversa.

Comandi vs. Identificatori

In mSL, gli alias possono fungere sia da identifiers sia da commands. Questi due termini vengono usati per descrivere il tipo di alias. In generale, un command di solito non restituisce nulla, ma elabora semplicemente un certo tipo di dati. Un Identifier, invece, in genere restituisce un qualche valore.

Prefissi degli alias

Prefissi dei comandi

prefisso . (silenzia)

Puoi anteporre un punto ’.’ alla chiamata del comando per impedire a mIRC di mostrare il suo tipico messaggio, come ad esempio .timer.

prefisso ! (chiamata built-in)

Per impostazione predefinita, una chiamata a un comando invocherà qualsiasi alias personalizzato tu abbia definito; puoi forzare la chiamata a un comando integrato di mIRC usando il prefisso ’!’, quindi /!join assicura che venga chiamato il comando join integrato di mIRC invece dell’eventuale alias personalizzato join che hai definito.

Prefissi degli identificatori

costrutto speciale $$ (valore richiesto)

Puoi usare $$identifier per interrompere una routine se il valore restituito dall’identificatore è $null; in genere questo permette di fermarsi rapidamente se manca un parametro.

prefisso / e . (chiamata personalizzata)

Per impostazione predefinita, una chiamata a un identificatore invocherà l’identificatore built-in di mIRC; puoi forzare la chiamata al tuo identificatore personalizzato usando il prefisso ’/’ o ’.’, quindi $/me assicura che venga chiamato il tuo identificatore personalizzato. Se non hai definito l’alias, mIRC lo considererà una chiamata a un alias con nome contenente ’/’ o ’.‘.

prefisso ~ (chiamata built-in)

In sostanza, una chiamata di questo tipo a un identificatore cercherà solo gli identificatori built-in; gli alias personalizzati non verranno cercati. Questo aggirerà il messaggio di avviso Identifier Warning, ma non è del tutto chiaro perché sia utile; può permettere di verificare se un identificatore esiste nel linguaggio interno di mIRC e ha un valore, ma non puoi usarlo per controllare i built-in che restituirebbero $null, e devi comunque eseguire la funzione: controllare “$findfile” o “$zip” sarebbe problematico.

prefisso ! (ritardo della valutazione)

Puoi usare $!identifier per restituire l’identificatore come testo semplice invece di valutarlo; il resto della riga viene valutato normalmente, e $!+( $me ) non ritarda la valutazione di $me.

Restrizioni sul nome dell’alias

Dato l’insieme dei prefissi degli alias mostrato sopra, non puoi iniziare il nome di un alias con un prefisso di comando se intendi chiamarlo come comando; stessa idea per un identificatore.

Comandi

Un comando di solito non restituisce alcun valore, ma elabora gli argomenti che riceve. In un comando, ogni argomento è separato da uno spazio. $0 conterrà il numero totale di argomenti passati a quell’alias. $N (dove N è un numero da 1 a $0) conterrà gli argomenti. Per esempio:

alias example {
  echo -a $0 arguments passed
  echo -a The first 3 arguments are:
  echo -a Arg1 = $1
  echo -a Arg2 = $2
  echo -a Arg3 = $3
}

Possiamo eseguire il codice usando la seguente istruzione:

/example A B C D

Questo produrrà il seguente risultato:

4 arguments passed
The first 3 arguments are:
Arg1 = A
Arg2 = B
Arg3 = C

Identificatori

In generale, un identificatore è un alias che restituisce un valore. Questo significa che passiamo alcuni argomenti a quell’alias e ci aspettiamo che restituisca qualcosa. Gli identificatori sono preceduti dal simbolo del dollaro ($). Un identificatore può richiedere o meno argomenti. Se l’identificatore richiede argomenti, essi devono essere racchiusi tra parentesi e separati da virgole.

;This identifier does not need any arguments... echo -a $me
;This identifier requires that we pass it some arguments:
echo -a $calc(1 + 1)

A differenza di un comando, qui gli argomenti sono separati da virgole. Di conseguenza, è possibile passare un singolo argomento contenente spazi. Inoltre, poiché gli identificatori devono restituire un valore, usiamo la parola chiave /return per restituire un valore. Il comando /return consente alla routine chiamante di continuare usando il valore restituito. Ecco un esempio:

alias example {
  return hello there!
}

Possiamo chiamare quell’identificatore in questo modo:

//echo -a $example

Questo stamperà:

hello there!

Per impostazione predefinita, ‘return’ rimuove gli spazi iniziali/finali e quelli consecutivi dal risultato prima di restituirlo. Considera i seguenti alias:

alias example_result   return   $str($chr(32),2) $+ a $+ $str($chr(32),2) $+ a $+ $str($chr(32),2)
alias example_resultex returnex $str($chr(32),2) $+ a $+ $str($chr(32),2) $+ a $+ $str($chr(32),2)

‘return’ rimuove gli spazi extra, mentre returnex li conserva, come mostrato qui:

//echo -a $replace($example_result  ,$chr(32),.)
output: a.a
//echo -a $replace($example_resultex,$chr(32),.)
output: ..a..a..

Proprietà degli identificatori

Le proprietà sono una caratteristica unica degli identificatori con argomenti. Ti permettono di passare un’ulteriore annotazione all’alias. Quell’annotazione può essere recuperata all’interno dell’alias tramite l’identificatore $prop. Le proprietà sono in genere un modo per manipolare gli argomenti che passiamo all’alias.

Considera questo alias di base che restituisce una quantità di gradi in radianti.

; converts degrees to radians
alias convert {...   return $calc($1 * $pi / 180)
}

Per esempio:

//echo -a $convert(1)
0.017453
//echo -a $convert(15.5)
0.270526

Possiamo aggiungere due proprietà per far sì che converta da gradi a radianti e viceversa.

; converts degrees to radians
alias convert {
  if ($prop == deg2rad) return $calc($1 * $pi / 180)
  if ($prop == rad2deg) return $calc($1 * 180 / $pi)
  ; proprietà non valida
  return 0
}

Per esempio:

//echo -a $convert(10).deg2rad
0.174533
//echo -a $convert(0.174533).rad2deg
10.000004
//echo -a $convert($convert(15.5).deg2rad).rad2deg
15.499998

Alias sia come identificatore sia come comando

Sebbene la maggior parte degli alias serva solo come identificatore o come comando, è possibile farli agire come entrambi.

Considera il seguente alias, logfind. Logfind trova la prima riga corrispondente nel log della finestra attiva. Se viene chiamato come identificatore, restituiremo la riga trovata. Se viene chiamato come comando, la stamperemo invece:

; Finds the first matching line from the log for the active window
alias logfind {
  ; find the log file
  var %logfile $window($active).logfile
  var %match = $read(%logfile, nw, $1)
  ; if it was an identifier, return the match
  if ($isid) return %match
  ; print it if it was a command
  echo -agc info * Logfind Match: %match
}

Possiamo chiamare quell’alias come identificatore, per esempio:

//echo -a $logfind(*kicked*)
[12:33] * Foo was kicked by *.example.com (Flooding (Limit is 12 lines per 10 seconds))

Possiamo anche chiamarlo come comando:

/logfind *kicked*
* Logfind Match: [12:33] * Foo was kicked by *.example.com (Flooding (Limit is 12 lines per 10 seconds))

Nota inoltre che quando un alias viene chiamato come comando /my_alias eredita la stringa $parms così come esiste nell’alias padre, ma quando viene chiamato come identificatore $my_alias la stringa $parms viene impostata a $null.

sostituzione dei comandi integrati

Puoi intercettare l’uso di un comando built-in da parte di qualsiasi script, purché non sia stato usato il prefisso ! per forzare l’esecuzione del comando built-in senza cercare corrispondenze tra tutti gli alias. Per esempio, ecco qualcosa che intercetta i comandi echo e rimuove colori, grassetto ecc. dalla stringa visualizzata:

alias echo {
  if ($1 isnum 0-) var %text $strip($2-)...   else             var %text $strip($1-)
  echo %text
}

Poiché un alias non è rientrante, usare ‘echo’ all’interno di un alias con lo stesso nome non può essere intercettato da quell’alias stesso, anche se può essere intercettato da un altro alias chiamato echo, a meno che questo alias non lo invochi come !echo. Questo non intercetta completamente tutti i colori, perché non rimuove il colore da “/echo -c ctcp message”.

Soprattutto se il tuo alias non è locale, fai attenzione a intercettare comandi built-in senza supportare TUTTE le varianti della loro sintassi. Per esempio, il comando /server ha comportamenti diversi per scopi differenti. Esistono insiemi di switch che consentono di entrare in un server e altra sintassi per modificare il file servers.txt.

L’intercettazione errata dei comandi built-in è una fonte di bug facile da trascurare, quindi potresti dover usare $isalias(built_in_command) per verificare se uno dei tuoi script lo ha intercettato; e anche così non vedrai gli alias locali a meno che $isalias non venga usato dall’interno di quello stesso script.

Un’altra cosa che potrebbe dover essere preservata è lo stato di $v1 e $v2. Considera il seguente esempio mentre il precedente ‘alias echo’ sta intercettando:

//if (var1 != var2) echo -a $ $+ v1 is $v1 and $ $+ v2 is $v2 | echo test | !echo and now $ $+ v1 is $v1 and $ $+ v2 is $v2
output:
$v1 is var1 and $v2 is var2
test
and now $v1 is test and $v2 is 0-

Nota come il primo echo interpreti $v1 e $v2 prima di inviarli all’alias echo, quindi i valori non vengono alterati. Ma osserva ora come il messaggio identico venga modificato dall’istruzione if() dentro alias echo, a causa del fatto che $v1 e $v2 creati in un alias possono essere visti nell’editbox o in un altro alias. Nel caso questo possa interferire con gli script chiamanti, puoi salvare i valori di $v1 e $v2 prima di alterarli, quindi ripristinarli dopo:

alias echo {
  var -p %v1 $v1 , %v2 $v2
  if ($1 isnum 0-) var %text $strip($2-)
  else             var %text $strip($1-)
  echo %text
  if (%v1 == %v2) noop
}

Questo salva $v1 e $v2 così come esistono al momento dell’ingresso nell’alias. Poi, prima dell’uscita, crea una finta istruzione if() che ha l’effetto di ripristinarli.

Alias per altri utenti

Una considerazione nella creazione di alias che potrebbero essere eseguiti da altri utenti è tenere conto del fatto che altri utenti non useranno gli stessi colori che usi tu. Esistono grandi basi di utenti che usano sfondi neri oppure bianchi, e ci sono molti colori che contrastano bene con uno ma male con l’altro. Nel set colori predefinito “mIRC Classic”, il colore 8 “Yellow” e l’11 “LightCyan” si vedono male su sfondo bianco, ma bene su sfondo nero. Al contrario, il 2 “NavyBlue” si vede bene sul bianco ma male sul nero. E ovviamente i colori testo bianco e nero non contrastano bene con uno sfondo dello stesso colore…

Una scelta per il tuo script è sovrascrivere lo sfondo mentre imposti il colore del testo, ma anche questo non garantisce che l’utente abbia assegnato a quella coppia di indici colore un buon contrasto reciproco. Per garantire che le effettive tonalità dei colori vengano mostrate come desideri, puoi usare gli indici colore 16-98 purché lo script venga usato su v7.52 o superiore, perché nelle versioni precedenti quegli indici vengono interpretati come nero. Solo poche tonalità del set predefinito 0-15 “mIRC Classic” sono duplicate esattamente nell’intervallo 16-98, quindi per le altre potrebbe essere necessario scegliere l’approssimazione più vicina.

Un’altra scelta è usare lo switch -c di echo per impostare il colore che quell’utente ha assegnato nella sua finestra Alt+K. Per esempio, se il tuo alias vuole imitare un messaggio di errore blu simile a quelli dei comandi built-in di mIRC:

/echo -ac info this displays in the same color as mIRC error messages

Funzionalità aggiuntive degli alias:

Indipendentemente dal fatto che un alias sia stato chiamato come comando o come identificatore, se ha usato il comando /return per restituire qualcosa, puoi ottenere quel valore usando l’identificatore $result.

alias example {
  foo
  echo -a $result
}
alias foo {
  return result!
}

Output:

/example
result!

Inoltre, gli alias possono essere scritti in modo da funzionare in modalità verbose oppure no. Se il comando è stato preceduto dal simbolo punto (.), $show restituirà $false, altrimenti restituirà $true. Per esempio:

alias example {
  if ($show) {
    ;Indicate we are doing something
    echo -a we are doing something
    ;Show more debug info.
  }
  ;do something
}

Output:

/example
we are doing something
/.example

Nota: /echo -q è un’alternativa built-in per fare questo; l’echo verrà visualizzato o meno in base al valore di $show.

Scorciatoie e tasti funzione

Gli alias possono essere usati per ridefinire i tasti funzione e le scorciatoie semplicemente rinominandoli con il tasto reale o con la combinazione di tasti. Per i tasti funzione basta assegnare all’alias il nome effettivo da F1 a F12. C e S possono essere usati rispettivamente per Shift e Ctrl. Per esempio SF1 indica i tasti Shift+F1.

Per esempio:

alias SF1 {
  echo -a Shift+F1 was pressed!
}

Alias locali

Per impostazione predefinita, ogni alias è pubblico. Questo significa che qualunque script in qualunque file può chiamare quell’alias (anche dall’editbox). Un alias può essere reso locale usando lo switch -l. Un alias locale è visibile solo agli script locali, cioè agli script presenti nello stesso file dell’alias. Questo è particolarmente utile quando i tuoi alias hanno nomi comuni e non vuoi causare conflitti quando distribuisci il tuo script ad altre persone.

Alias -l <name> {
  ;code
}

Esposizione di funzionalità private e pubbliche

È possibile consentire più funzionalità agli alias locali e nasconderle agli script esterni.

alias -l example {
  echo -a Local code called me!
}
alias example {
  echo -a Non-local script called me!
}

Se del codice locale a quel file di script chiama example, verrà eseguito l’alias locale. Se del codice esterno a quel file di script lo chiama, verrà eseguito invece il secondo alias. Nota che l’alias locale deve stare sopra, altrimenti gli altri alias dentro quello script vedranno solo l’alias non locale posto sopra di esso.

Ordine degli alias

L’ordine usato da mIRC per trovare il tuo alias è il seguente:

  • i file vengono letti dall’alto verso il basso e viene usato solo il primo alias trovato nel file
  • se la chiamata viene fatta da uno script e in quel file di script esiste un alias con quel nome, viene usato quell’alias (indipendentemente dal fatto che l’alias sia locale o meno)
  • se nessuna delle condizioni precedenti è vera, allora viene usato l’ordine con cui hai caricato lo script. mIRC cerca il primo alias non locale seguendo l’ordine di uno o più file aliases nella scheda Alt+D dell’editor di script, seguiti dagli script della scheda Alt+R nell’ordine in cui sono stati caricati. Se hai definito due volte lo stesso nome alias nello stesso file, il secondo non può essere eseguito.
  • se non viene trovato nulla, allora mIRC controlla se si tratta del nome di un comando built-in
  • se ancora non c’è corrispondenza e si trattava di una chiamata a comando, allora invia il comando al server, che restituirà il RAW numerico 421 se si tratta di un comando server non valido

Nota: la riga di comando di un timer si comporta come se fosse all’interno dello script da cui è stato lanciato: eseguirà prima gli alias trovati in quel file.

Vedi anche