comterp - Online nel cloud

PROGRAMMA:

NOME

comterp - dimostratore di interpreti di comandi distribuiti

SINOSSI

comp
comp a distanza
comp server "portnum"
comp logger "portnum"
comp client "host" "portnum" ["file"]
comp telcat "host" "portnum" ["file"]
comp eseguire "file"
comp "espr"

DESCRIZIONE

comterp mostra l'interprete dei comandi incorporato in ivtools. Un utente (o cliente
programma) può interagire con comterp tramite stdin e stdout o telnet (quando ACE è integrato).
La sintassi del comando è un elenco di comandi separati da punto e virgola con un numero arbitrario di
parametri racchiusi tra parentesi, con supporto per parametri opzionali e parole chiave
argomenti, ovvero:

comando2(arg1 arg2 arg3: tasto1 val1: tasto2 val2);
comando1(arg1 arg2 arg3 :key1 val1 :key2 val2)

Le espressioni binarie di tipo C possono essere incorporate ovunque nel linguaggio di comando, usando il
operatori nella tabella sottostante. Le variabili possono essere create al volo con un'assegnazione
(cioè "ball=1" crea una variabile intera "ball" impostata su 1). non terminato
espressioni causano un'estensione automatica della riga di comando (fino a quando il parser non determina il
espressione è completa). "(), "{}" e "[]" possono essere usati in modo intercambiabile.

COMANDO VERSIONI

comp

Richiama un singolo interprete di comandi con cui interagire tramite stdin e stdout.

telecomando

Richiama un singolo interprete di comandi, come quello predefinito, e includi un comando remoto per
accedere ad altri comterp in modalità server.

comterp server "portnum"

Ascolta e accetta connessioni su portnum, quindi imposta un interprete di comandi per attendere
per ed elaborare i comandi da quella connessione.

logger comterp "portnum"

Ascolta e accetta connessioni su portnum, quindi inoltra semplicemente i messaggi in arrivo
a stdout, mentre rispondi con le nuove righe. Per scopi di debug, non proprio un uso di
l'interprete.

comterp client "host" "portnum" ["file"]

Connettiti a un portnum su un host e invia/ricevi buffer di testo con terminazione di nuova riga. Per
scopi di debug, non proprio un uso dell'interprete.

comterp telcat "host" "portnum" ["file"]

Connettiti a un portnum su un host, cat il file, quindi chiudi la connessione. Non è proprio utile
anche dell'interprete.

comterp esegui "file"

Esegui il contenuto del file, quindi esci.

conterp "espr"

Valuta la singola espressione quindi esci.

OPERATORE TABELLA

Operatori Nome comando Priorità Tipo di ordine
--------- ------------ -------- ----- ----
. punto 130 binario da R a L
` bquote 125 R-to-L prefisso unario
! negare 110 R-to-L prefisso unario
~ bit_not 110 R-to-L prefisso unario
++ incr 110 R-to-L prefisso unario
++ incr_after 110 R-a-L unary-postfix
- meno 110 prefisso unario da R a L
-- decr 110 R-to-L prefisso unario
-- decr_after 110 R-a-L unario-postfisso
** ripeti 90 binario da sinistra a destra
.. itera 80 binario da L a R
% mod 70 binario da sinistra a destra
* mpy 70 binario da sinistra a destra
/ div 70 binario da sinistra a destra
+ aggiungi 60 binari da L a R
- binario sub 60 da sinistra a destra
<< lshift 55 binario da sinistra a destra
>> rshift 55 binario da sinistra a destra
< lt 50 binario da sinistra a destra
<= lt_or_eq 50 L-to-R binario
> gt 50 binario da sinistra a destra
>= gt_or_eq 50 binario da sinistra a destra
!= not_eq 45 binario L-R
== eq 45 binario da L a R
& bit_e 44 binario da sinistra a destra
^ bit_xor 43 binario L-R
| bit_o 42 binario da L a R
&& e 41 binario L-R
|| o 40 binario L-R
, tupla 35 binario da L a R
,, flusso concat 33 binario da L a R
$ stream 32 R-to-L prefisso unario
$$ list 32 R-to-L prefisso unario
%= mod_assign 30 binario R-to-L
*= mpy_assign 30 binari da R a L
+= add_assign 30 binari R-to-L
-= sub_assegna 30 binari da R a L
/= div_assign 30 binario R-to-L
= assegnare 30 binari R-to-L
; seq 10 binario da L a R

MATEMATICO COMANDI:

n=min(ab) -- restituisce il minimo di a e b

n=max(ab) -- restituisce il massimo di a e b

n=abs(a) -- restituisce il valore assoluto di a

dbl=exp(x) -- restituisce il valore e elevato alla potenza di x

dbl=log(x) -- restituisce il logaritmo naturale di x

dbl=log10(x) -- restituisce il logaritmo in base 10 di x

dbl=log2(x) -- restituisce il logaritmo in base 2 di x

dbl=pow(xy) -- restituisce il valore di x elevato alla potenza di y

dbl=acos(x) -- restituisce l'arcocoseno di x in radianti

dbl=asin(x) -- restituisce l'arcoseno di x in radianti

dbl=atan(x) -- restituisce l'arcotangente di x in radianti

dbl=atan2(yx) -- restituisce l'arcotangente di y su x

dbl=cos(x) -- restituisce il coseno di x radianti

dbl=sin(x) -- restituisce il seno di x radianti

dbl=tan(x) -- restituisce la tangente di x radianti

dbl=sqrt(x) -- restituisce la radice quadrata di x

dbl=pi() -- restituisce il valore di pi

dbl=radtodeg(dbl) -- converte i radianti in gradi

dbl=degtorad(dbl) -- converte i gradi in radianti

num=floor(num) -- restituisce il valore intero più vicino minore o uguale all'argomento

num=ceil(num) -- restituisce il valore intero più vicino maggiore o uguale all'argomento

num=round(num) -- restituisce il valore intero più vicino

AFFINATO TRASFORMARE E MATRIX COMANDI:

point=xform(x,y a00,a01,a10,a11,a20,a21) -- trasformazione affine delle coordinate x,y

affine=invert(a00,a01,a10,a11,a20,a21) -- inverte la trasformazione affine

matrice=xpose(matrice) -- traspone una matrice arbitraria

matrice=matrice*matrice -- moltiplicazione di matrici

STATISTICA/CASUALE COMANDI:

sum(val1[,val2[,...,valn]]) -- restituisce la somma dei valori

mean(val1[,val2[,...,valn]]) -- restituisce la media dei valori

var(val1[,val2[,...,valn]]) -- restituisce la varianza dei valori

stddev(val1[,val2[,...,valn]]) -- restituisce la deviazione standard dei valori

rand([minval,maxval]) -- restituisce un numero casuale compreso tra 0 e 1 o minval,maxval

srand(seedval) -- generatore di numeri casuali seed

ELENCO COMANDI:

lst=list([olst|strm|val] :strmlst :attr :size n) -- crea un elenco, copia un elenco o converti
ruscello

val=at(list|attrlist|str n :set val :ins val) -- return (o set o inserisci dopo) l'ennesimo elemento
in una lista o stringa

num=size(list|attrlist|str) -- restituisce la dimensione di una lista (o stringa)

val=index(list|str val|char|str :last :all :substr) -- restituisce l'indice del valore (o char o
stringa) in elenco (o stringa), nullo se non trovato.

STREAM COMANDI:

val=next(stream) -- restituisce il valore successivo dallo stream

strm=stream(ostrm|list|attrlist|val) -- copia lo stream o converti la lista

cnt=each(strm) -- attraversa il flusso restituendo la sua lunghezza

comp=filter(comps classid) -- filtra il flusso di comps per la corrispondenza di classid

CONTROLLO COMANDI (usando settimana valutazione):

val=cond(testexpr trueexpr falseexpr) -- valuta testexpr e, se vero, valuta e
restituisce trueexpr, altrimenti valuta e restituisce falseexpr

val=if(testexpr :then expr :else expr) -- valuta testexpr ed esegue :then
espressione se vera, l'espressione :else se falsa.

val=for(initexpr whileexpr [nextexpr [bodyexpr]] :body expr) -- ciclo for

val=while([testexpr [bodyexpr]] :nilchk :until :body expr ) -- ciclo while

val=switch(val key-body-pairs) -- istruzione switch (:casen per pos., :case_n per neg.,
altrimenti :simbolo)

continue -- passa all'iterazione successiva del ciclo for o while

break([retval]) -- interrompe il ciclo for o while

ALTRO COMANDI

help(cmdname [cmdname ...] :all :posteval) -- aiuto per i comandi

val=trace([flag] :get) -- attiva o disattiva la modalità di traccia

pause([msgstr]) -- mette in pausa l'esecuzione dello script fino a C/R

step() -- attiva e disattiva l'esecuzione dello script passo passo

fileobj|pipeobj=open([filename [modestr]] :pipe :in :out :err) -- comando open file

close(fileobj|pipeobj) -- comando di chiusura del file

[str]=print([fmtstr] [val [val1 [... valn]]] :string|:str :out :err :file fileobj|pipeobj
:prefix str) -- stampa il valore con una stringa di formato opzionale

str=gets(fileobj|pipeobj) -- ottiene una stringa terminata da una nuova riga da un file

val=global(symbol)|global(symbol)=val|global(symbol :clear)|global(:cnt) -- crea simbolo
globale

int|lst=symid(symbol [symbol ...] | :max) -- restituisce gli id ​​interi associati a
simbolo/i

sym|lst=symbol(symid [symid ...]) -- restituisce il/i simbolo/i associato/i agli id ​​interi

val|lst=symval(symbol [symbol ...]) -- valore di ritorno associato al simbolo
variabile/i

sym|lst=symadd(sym|str [sym|str ...]) -- crea uno o più simboli e ritorna senza cercare.

sym=symvar(sym) -- restituisce il simbolo così com'è

str=symstr(sym) -- restituisce la versione stringa del simbolo

n=strref(str|symid) -- restituisce il conteggio dei riferimenti alla stringa

lst=split(symbol|string :tokstr [delim] :tokval [delim] :keep :reverse) -- simbolo di divisione
o stringa in un elenco di caratteri (o token).

str=join(clist :sym) -- unisce l'elenco di caratteri in una stringa

str=substr(str n|str :after :nonil) -- estrae i caratteri da una stringa (:nonil restituisce
stringa se nessuna corrispondenza)

bool=eq(str1 str2 :n len) -- confronto parziale di stringhe

bool=eq(sym1 sym2 :sym) -- confronto di simboli

postfix(arg1 [arg2 [arg3 ... [argn]]]) -- echo argomenti postfissi non valutati (con
[narg|nkey] dopo comandi definiti, {narg|nkey} dopo comandi non definiti, (narg) dopo
chiavi e un * dopo i comandi post-valutazione)

parse(fileobj) -- analizza una singola espressione da un file

arr=posteval(arg1 [arg2 [arg3 ... [argn]]]) -- post-valuta ogni argomento fisso (fino a
nil) e restituisce array
sym=attrname(attributo) -- restituisce il campo del nome della coppia puntata
val=attrval(attributo) -- campo del valore di ritorno della coppia puntata
dotlst=dot(name) -- costruisce un elenco di coppie tratteggiate vuoto

quit() -- chiude l'interprete

exit() -- esci dall'intera applicazione

empty() -- istruzione vuota

val=run(filename :str :popen) -- esegue comandi da file (o stringa)

val=remote(hoststr portnum cmdstr :nowait) -- valuta in remoto la stringa di comando allora
valuta localmente la stringa del risultato

val=eval(cmdstr|funcobj [cmdstr|funcobj ...] :symret ) -- valuta la stringa (o funcobj) come
comandi, facoltativamente restituisce il simbolo invece di nil

funcobj=func(body :echo) -- incapsula un corpo di comandi in un oggetto eseguibile

val=shell(cmdstr) -- valuta il comando nella shell

dormi(msec) -- microsecondi di sospensione

mute([flag]) -- imposta o attiva il flag mute

nil([...]) -- accetta qualsiasi argomento e restituisce nil

c=char(num :u) -- converte qualsiasi numero in un carattere

s=short(num :u) -- converte qualsiasi numero in uno short

i=int(num :u) -- converte qualsiasi numero in un int

l=long(num :u) -- converte qualsiasi numero in un long

f=float(num) -- converte qualsiasi numero in un float

d=double(num) -- converte qualsiasi numero in un double

sym|lst=type(val [val ...]) -- restituisce il tipo di simbolo(i) per valore(i)

sym|lst=class(val [val ...]) -- restituisce il/i simbolo/i di classe per il/i valore/i del tipo di oggetto

int=ctoi(char) -- converte il carattere in intero

flag=isspace(char) -- restituisce true se il carattere è uno spazio bianco

flag=isdigit(char) -- restituisce vero se il carattere è una cifra numerica

flag=isspace(char) -- restituisce true se il carattere è alfabetico

str=arg(n) -- restituisce l'argomento della riga di comando

n=narg(n) -- restituisce il numero di argomenti della riga di comando

num=nand(ab) -- NAND bit per bit (AND negato)

num=nor(ab) -- NOR bit per bit (OR negato)

num=xnor(ab) -- XNOR bit per bit (XOR negato)

SOLO IN SERVER MODE

str=timeexpr(comstr :sec n) -- stringa di comando da eseguire a intervalli

Usa comterp online utilizzando i servizi onworks.net