comterp - Online în cloud

PROGRAM:

NUME

comterp - demonstrator interpret de comandă distribuită

REZUMAT

comterp
comterp la distanta
comterp server "portnum"
comterp logger "portnum"
comterp client „gazdă” „portnum” [„fișier”]
comterp telcat „gazdă” „portnum” [„fișier”]
comterp rula "fisier"
comterp "expr"

DESCRIERE

comterp demonstrează interpretul de comenzi încorporat în ivtools. Un utilizator (sau client
program) poate interacționa cu comterp prin stdin și stdout sau telnet (când ACE este încorporat).
Sintaxa comenzii este o listă de comenzi separate prin punct și virgulă, cu un număr arbitrar de
parametrii încadrați în paranteză, cu suport pentru parametri opționali și cuvinte cheie
argumente, adică:

comanda2(arg1 arg2 arg3 :key1 val1 :key2 val2);
comandă1(arg1 arg2 arg3:key1 val1:key2 val2)

Expresiile binare asemănătoare C pot fi încorporate oriunde în limbajul de comandă, folosind
operatori din tabelul de mai jos. Variabilele pot fi create din mers cu o sarcină
operator (adică „ball=1” creează o variabilă întreagă „ball” setată la 1). Neterminat
expresiile cauzează o extensie automată a liniei de comandă (până când analizatorul determină
expresia este completă). „(), „{}” și „[]” pot fi folosite interschimbabil.

COMMAND OPŢIUNI

comterp

Invocați un singur interpret de comandă cu care să interacționați prin stdin și stdout.

telecomanda comterp

Invocați un singur interpret de comandă, ca implicit, și includeți o comandă de la distanță pentru
accesarea altor computere în modul server.

server comterp "portnum"

Ascultă și acceptă conexiuni pe portnum, apoi setează un interpret de comandă pentru a aștepta
pentru și procesează comenzile din acea conexiune.

logger computer "portnum"

Ascultă și acceptă conexiuni pe portnum, apoi pur și simplu redirecționează mesajele primite
la stdout, în timp ce ack'ing înapoi cu linii noi. În scopuri de depanare, nu chiar o utilizare a
interpretul.

client comterp "gazdă" "portnum" ["fișier"]

Conectați-vă la un portnum pe o gazdă și trimiteți/primiți buffer-uri de text terminate cu linia nouă. Pentru
scopuri de depanare, nu chiar o utilizare a interpretului.

comterp telcat "gazdă" "portnum" ["fișier"]

Conectați-vă la un portnum pe o gazdă, închideți fișierul, apoi închideți conexiunea. Nu chiar o utilizare
fie al interpretului.

comterp rulează „fișier”

Rulați conținutul fișierului, apoi ieșiți.

comterp "expr"

Evaluați o singură expresie, apoi ieșiți.

OPERATOR TABEL

Operatori Nume comandă Prioritate Tip comandă
--------- ------------ -------- ----- ----
. punct 130 binar R-la-L
` bquot 125 R-to-L unary-prefix
! anulează 110 prefix unar R-to-L
~ bit_not 110 R-to-L unary-prefix
++ incr 110 R-to-L unar-prefix
++ incr_after 110 R-to-L unary-postfix
- minus 110 R-to-L unar-prefix
-- decr 110 R-to-L unary-prefix
-- decr_after 110 R-to-L unary-postfix
** repetați 90 binar L-la-R
.. repetați 80 binar L-to-R
% mod 70 L-to-R binar
* mpy 70 L-to-R binar
/ div 70 L-to-R binar
+ adăugați 60 binar L-la-R
- sub 60 binar L-to-R
<< lshift 55 binar L-la-R
>> rshift 55 binar L-la-R
< lt 50 binar de la L la R
<= lt_or_eq 50 binar L-la-R
> gt 50 binar de la L la R
>= gt_or_eq 50 binar L-la-R
!= not_eq 45 binar L-la-R
== eq 45 binar L-la-R
& bit_și 44 binar L-to-R
^ bit_xor 43 binar L-la-R
| bit_sau 42 binar L-la-R
&& și 41 binar L-la-R
|| sau 40 L-to-R binar
, tuplu 35 binar L-la-R
,, flux concat 33 binar L-la-R
$ stream 32 R-to-L unary-prefix
$$ lista 32 R-to-L unary-prefix
%= mod_assign 30 binar R-to-L
*= mpy_assign 30 binar R-to-L
+= add_assign 30 binar R-to-L
-= sub_assign 30 binar R-to-L
/= div_assign 30 binar R-to-L
= atribuiți 30 binar R-la-L
; secv 10 binar L-la-R

MATEMATIC COMANDI:

n=min(ab) -- returnează minimul a și b

n=max(ab) -- returnează maximul a și b

n=abs(a) -- returnează valoarea absolută a lui a

dbl=exp(x) -- returnează valoarea e ridicată la puterea lui x

dbl=log(x) -- returnează logaritmul natural al lui x

dbl=log10(x) -- returnează logaritmul de bază 10 al lui x

dbl=log2(x) -- returnează logaritmul de bază 2 al lui x

dbl=pow(xy) -- returnează valoarea lui x ridicată la puterea lui y

dbl=acos(x) -- returnează arcul cosinus al lui x în radiani

dbl=asin(x) -- returnează arcul sinus al lui x în radiani

dbl=atan(x) -- returnează arc-tangenta lui x în radiani

dbl=atan2(yx) -- returnează arc-tangenta lui y peste x

dbl=cos(x) -- returnează cosinusul lui x radiani

dbl=sin(x) -- returnează sinusul lui x radiani

dbl=tan(x) -- returnează tangenta de x radiani

dbl=sqrt(x) -- returnează rădăcina pătrată a lui x

dbl=pi() -- returnează valoarea lui pi

dbl=radtodeg(dbl) -- convertiți radianii în grade

dbl=degtorad(dbl) -- convertește grade în radiani

num=floor(num) -- returnează cea mai apropiată valoare întreagă mai mică sau egală cu argumentul

num=ceil(num) -- returnează cea mai apropiată valoare întreagă mai mare sau egală cu argumentul

num=round(num) -- returnează cea mai apropiată valoare întreagă

AFFINĂ TRANSFORMA AND MATRIX COMANDI:

point=xform(x,y a00,a01,a10,a11,a20,a21) -- transformarea afină a coordonatelor x,y

afin=invert(a00,a01,a10,a11,a20,a21) -- inversează transformarea afină

matrice=xpose(matrice) -- transpune o matrice arbitrară

matrice=matrice*matrice -- înmulțirea matricei

STATISTIC/ALEATOARE COMANDI:

sum(val1[,val2[,...,valn]]) -- returnează suma valorilor

mean(val1[,val2[,...,valn]]) -- returnează media valorilor

var(val1[,val2[,...,valn]]) -- returnează variația valorilor

stddev(val1[,val2[,...,valn]]) -- returnează abaterea standard a valorilor

rand([minval,maxval]) -- returnează un număr aleator între 0 și 1 sau minval,maxval

srand(seedval) -- generator de numere aleatoare de semințe

LISTA COMANDI:

lst=list([olst|strm|val] :strmlst :attr :size n) -- creați o listă, copiați lista sau convertiți
curent

val=at(list|attrlist|str n :set val :ins val) -- returnează (sau setează sau inserează după) al-lea element
într-o listă sau șir

num=size(list|attrlist|str) -- returnează dimensiunea unei liste (sau șir)

val=index(listă|str val|char|str :last :all :substr) -- returnează indicele valorii (sau char sau
șir) în listă (sau șir), nul dacă nu este găsit.

CURENT COMANDI:

val=next(stream) -- returnează următoarea valoare din flux

strm=stream(ostrm|list|attrlist|val) -- copiază fluxul sau convertește lista

cnt=each(strm) -- traversează fluxul care returnează lungimea acestuia

comp=filter(comps classid) -- filtrează fluxul de comps pentru potrivirea classid

CONTROL COMANDE (folosind post evaluare):

val=cond(exprtest trueexpr falseexpr) -- evaluați testexpr, iar dacă este adevărat, evaluați și
returnează trueexpr, în caz contrar evaluează și returnează falseexpr

val=if(expr test :then expr :else expr) -- evaluați testexpr și executați :then
expresie dacă este adevărată, expresia :else dacă este falsă.

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

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

val=switch(val key-body-pares) -- instrucțiune de comutare (:case pentru poz., :case_n pentru neg.,
altfel :simbol)

continua -- săriți la următoarea iterație a buclei for sau while

break([retval]) -- iese din bucla for sau while

ALTE COMANDE

help(cmdname [cmdname ...] :all :posteval) -- ajutor pentru comenzi

val=trace([flag] :get) -- comutați sau setați modul de urmărire

pauză([msgstr]) -- întrerupe execuția scriptului până la C/R

step() -- comută execuția scriptului în pas

fileobj|pipeobj=open([nume fișier [modestr]] :pipe :in :out :err) -- comanda de deschidere a fișierului

close(fileobj|pipeobj) -- comanda de închidere a fișierului

[str]=print([fmtstr] [val [val1 [... valn]]] :string|:str :out :err :fișier fileobj|pipeobj
:prefix str) -- imprimați valoarea cu șir de format opțional

str=gets(fileobj|pipeobj) -- primește un șir terminat de linie nouă dintr-un fișier

val=global(simbol)|global(simbol)=val|global(simbol :clear)|global(:cnt) -- face simbol
global

int|lst=symid(simbol [simbol ...] | :max) -- returnează id(urile) întreg asociat(e) cu
simbol(e)

sym|lst=simbol(simid [simid ...]) -- returnează simbol(e) asociat(e) cu id(uri) întreg

val|lst=symval(simbol [simbol ...]) -- returnează valoarea (valorile) asociată cu simbolul
variabile(e)

sym|lst=symadd(sym|str [sym|str ...]) -- creează simbol(e) și revine fără căutare.

sym=symvar(sym) -- returnează simbolul așa cum este

str=symstr(sym) -- returnează versiunea șir a simbolului

n=strref(str|symid) -- returnează numărul de referințe șir

lst=split(simbol|șir :tokstr [delim] :tokval [delim] :keep :reverse) -- simbol împărțit
sau șir în lista de caractere (sau jetoane).

str=join(clist :sym) -- unește lista de caractere în șir

str=substr(str n|str :după :nonil) -- extrage caractere dintr-un șir (:nonil returnează
șir dacă nu se potrivește)

bool=eq(str1 str2 :n len) -- comparație parțială de șiruri

bool=eq(sym1 sym2 :sym) -- comparație simbol

postfix(arg1 [arg2 [arg3 ... [argn]]]) -- ecou argumente postfix neevaluate (cu
[narg|nkey] după comenzi definite, {narg|nkey} după comenzi nedefinite, (narg) după
taste și un * după comenzile post-evaluare)

parse(fileobj) -- analizează o singură expresie dintr-un fișier

arr=posteval(arg1 [arg2 [arg3 ... [argn]]]) -- post-evaluează fiecare argument fix (până la
nil) și returnează matrice
sym=attrname(atribut) -- returnează câmpul de nume al perechii punctate
val=attrval(atribut) -- returnează câmpul de valoare al perechii punctate
dotlst=punct(nume) -- construiește o listă de perechi cu puncte goale

quit() -- iese din interpret

exit() -- iese din întreaga aplicație

empty() -- instrucțiune goală

val=run(nume fișier :str :popen) -- rulați comenzi din fișier (sau șir)

val=remote(hoststr portnum cmdstr:nowait) -- apoi evaluează de la distanță șirul de comandă
evaluează local șirul de rezultate

val=eval(cmdstr|funcobj [cmdstr|funcobj ...] :symret ) -- evaluează șirul (sau funcobj) ca
comenzi, opțional returnează simbolul în loc de nil

funcobj=func(body :echo) -- încapsulează un corp de comenzi într-un obiect executabil

val=shell(cmdstr) -- evaluează comanda în shell

tu dormi(msec) -- microsecunde de somn

mute([flag]) -- setează sau comută semnalul de sunet

nil([...]) -- acceptă orice argument și returnează nil

c=char(num :u) -- converti orice numere într-un caracter

s=short(num :u) -- converti orice numere într-un scurt

i=int(num :u) -- converti orice numere într-un int

l=long(num :u) -- converti orice numere într-un lung

f=float(num) -- convertește orice numere într-un float

d=double(num) -- converti orice numere într-un dublu

sym|lst=type(val [val ...]) -- returnează simboluri de tip pentru valoare (valori)

sym|lst=class(val [val ...]) -- returnează simbolul (simbolurile) de clasă pentru valoarea (valorile) de tip obiect

int=ctoi(char) -- convertește caracterul în întreg

flag=isspace(char) -- returnează adevărat dacă caracterul este spațiu alb

flag=isdigit(char) -- returnează adevărat dacă caracterul este o cifră numerică

flag=isspace(char) -- returnează adevărat dacă caracterul este alfabetic

str=arg(n) -- returnează argumentul liniei de comandă

n=narg(n) -- returnează numărul de argumente ale liniei de comandă

num=nand(ab) -- NAND pe biți (ȘI negat)

num=nor(ab) -- NOR pe biți (SAU negat)

num=xnor(ab) -- XNOR pe biți (XOR negat)

NUMAI IN SERVER MODE

str=timeexpr(comstr :sec n) -- șir de comandă de executat la intervale

Utilizați comterp online folosind serviciile onworks.net