comterp - En ligne dans le Cloud

PROGRAMME:

Nom

comterp - démonstrateur d'interpréteur de commandes distribué

SYNOPSIS

comter
comter éloigné
comter serveur "numéro de port"
comter enregistreur "portnum"
comter client "hôte" "portnum" ["fichier"]
comter telcat "hôte" "numéro de port" ["fichier"]
comter exécuter "fichier"
comter "expr"

DESCRIPTION

comterp montre l'interpréteur de commandes intégré à ivtools. Un utilisateur (ou client
programme) peut interagir avec comterp via stdin et stdout ou telnet (lorsque ACE est intégré).
La syntaxe de la commande est une liste de commandes séparées par des points-virgules avec un nombre arbitraire de
paramètres entre parenthèses, avec prise en charge des paramètres facultatifs et du mot-clé
arguments, c'est-à-dire :

command2(arg1 arg2 arg3 :key1 val1 :key2 val2) ;
command1(arg1 arg2 arg3 :clé1 val1 :clé2 val2)

Les expressions binaires de type C peuvent être intégrées n'importe où dans le langage de commande, en utilisant le
opérateurs dans le tableau ci-dessous. Les variables peuvent être créées à la volée avec une affectation
opérateur (c'est-à-dire que "ball=1" crée une variable entière "ball" définie sur 1). Non terminé
expressions provoquent une extension de ligne de commande automatique (jusqu'à ce que l'analyseur détermine le
expression est terminée). "(), "{}" et "[]" peuvent tous être utilisés de manière interchangeable.

COMMAND OPTIONS

comter

Appelez un interpréteur de commandes unique avec lequel interagir via stdin et stdout.

télécommande

Invoquez un interpréteur de commandes unique, comme celui par défaut, et incluez une commande à distance pour
accéder à d'autres pays en mode serveur.

serveur comterp "portnum"

Écoute et accepte les connexions sur portnum, puis configure un interpréteur de commandes pour attendre
pour et traiter les commandes de cette connexion.

comterp logger "portnum"

Écoute et accepte les connexions sur portnum, puis transfère simplement les messages entrants
à stdout, tout en accusant retour avec des nouvelles lignes. À des fins de débogage, pas vraiment une utilisation de
l'interprète.

client comterp "hôte" "portnum" ["fichier"]

Connectez-vous à un portnum sur un hôte et envoyez/recevez des tampons de texte terminés par une nouvelle ligne. Pour
à des fins de débogage, pas vraiment une utilisation de l'interpréteur.

comterp telcat "hôte" "portnum" ["fichier"]

Connectez-vous à un portnum sur un hôte, cat le fichier, puis fermez la connexion. Pas vraiment utile
de l'interprète non plus.

comterp exécuter "fichier"

Exécutez le contenu du fichier puis quittez.

comterp "expr"

Évaluez l'expression unique, puis quittez.

OPÉRATEUR TABLE

Opérateurs Nom de la commande Priorité Type d'ordre
--------- ------------ -------- ----- ----
. point 130 R-vers-L binaire
` bquote 125 R-to-L préfixe-unaire
! annuler 110 préfixe unaire R-to-L
~ bit_not 110 R-to-L unaire-préfixe
++ incr 110 R-to-L unaire-préfixe
++ incr_after 110 suffixe unaire R à L
- moins 110 préfixe unaire R-to-L
-- decr 110 R-to-L unaire-préfixe
-- decr_after 110 suffixe unaire R à L
** répéter 90 binaire L-à-R
.. itérer 80 binaire L-to-R
% mod 70 binaire G à D
* mpy 70 binaire L-à-R
/ div 70 binaire G à D
+ ajouter 60 binaires L-à-R
- sous 60 binaire L-à-R
<< lshift 55 binaire G à D
>> rshift 55 binaire G à D
< lt 50 binaire G à D
<= lt_or_eq 50 binaire L-à-R
> gt 50 binaire G à D
>= gt_or_eq 50 binaire L-à-R
!= not_eq 45 binaire L-à-R
== eq 45 binaire G à D
& bit_and 44 binaire L-à-R
^ bit_xor 43 binaire L-à-R
| bit_or 42 binaire L-à-R
&& et 41 binaire L-à-R
|| ou 40 binaire L-à-R
, tuple 35 binaire L-à-R
,, stream concat 33 binaire L-à-R
$ stream 32 R-to-L unaire-préfixe
$$ list 32 R-to-L unaire-préfixe
%= mod_assign 30 binaire R-à-L
*= mpy_assign 30 binaire R-to-L
+= add_assign 30 binaire R-to-L
-= sub_assign 30 binaire R-to-L
/= div_assign 30 binaire R-to-L
= affecter 30 binaires R à L
; seq 10 binaire G à D

MATHÉMATIQUE COMMANDES

n=min(ab) -- renvoie le minimum de a et b

n=max(ab) -- renvoie le maximum de a et b

n=abs(a) -- renvoie la valeur absolue d'un

dbl=exp(x) -- renvoie la valeur e élevée à la puissance x

dbl=log(x) -- renvoie le logarithme népérien de x

dbl=log10(x) -- renvoie le logarithme en base 10 de x

dbl=log2(x) -- renvoie le logarithme en base 2 de x

dbl=pow(xy) -- renvoie la valeur de x élevée à la puissance y

dbl=acos(x) -- renvoie l'arc cosinus de x en radians

dbl=asin(x) -- renvoie l'arc sinus de x en radians

dbl=atan(x) -- renvoie l'arc tangent de x en radians

dbl=atan2(yx) -- renvoie l'arc tangent de y sur x

dbl=cos(x) -- renvoie le cosinus de x radians

dbl=sin(x) -- renvoie le sinus de x radians

dbl=tan(x) -- renvoie la tangente de x radians

dbl=sqrt(x) -- renvoie la racine carrée de x

dbl=pi() -- renvoie la valeur de pi

dbl=radtodeg(dbl) -- convertit les radians en degrés

dbl=degtorad(dbl) -- convertir les degrés en radians

num=floor(num) -- renvoie la valeur entière la plus proche inférieure ou égale à l'argument

num=ceil(num) -- renvoie la valeur entière la plus proche supérieure ou égale à l'argument

num=round(num) -- renvoie la valeur entière la plus proche

AFFINÉ TRANSFORMER ET MATRIX COMMANDES

point=xform(x,y a00,a01,a10,a11,a20,a21) -- transformée affine des coordonnées x,y

affine=invert(a00,a01,a10,a11,a20,a21) -- inverser la transformation affine

matrice=exposer(matrice) -- transpose une matrice arbitraire

matrice=matrice*matrice -- multiplication matricielle

STATISTIQUE/ALÉATOIRE COMMANDES

sum(val1[,val2[,...,valn]]) -- renvoie la somme des valeurs

moyenne(val1[,val2[,...,valn]]) -- renvoie la moyenne des valeurs

var(val1[,val2[,...,valn]]) -- renvoie la variance des valeurs

stddev(val1[,val2[,...,valn]]) -- renvoie l'écart type des valeurs

rand([minval,maxval]) -- renvoie un nombre aléatoire entre 0 et 1 ou minval,maxval

srand(seedval) -- générateur de nombres aléatoires

LISTE COMMANDES

lst=list([olst|strm|val] :strmlst :attr :size n) -- créer une liste, copier une liste ou convertir
courant

val=at(list|attrlist|str n :set val :ins val) -- retourne (ou définit ou insère après) le nième élément
dans une liste ou une chaîne

num=size(list|attrlist|str) -- renvoie la taille d'une liste (ou chaîne)

val=index(list|str val|char|str :last :all :substr) -- renvoie l'index de la valeur (ou char ou
chaîne) dans la liste (ou chaîne), nil s'il n'est pas trouvé.

FLUX COMMANDES

val=next(stream) -- renvoie la valeur suivante du flux

strm=stream(ostrm|list|attrlist|val) -- copier le flux ou convertir la liste

cnt=each(strm) -- traverse le flux renvoyant sa longueur

comp=filter(comps classid) -- filtre le flux de compositions pour le classid correspondant

CONTRÔLE COMMANDES (À L'Aide De poster évaluation):

val=cond(testexpr trueexpr falseexpr) -- évalue testexpr, et si vrai, évalue et
renvoie trueexpr, sinon évalue et renvoie falseexpr

val=if(testexpr :then expr :else expr) -- évalue testexpr et exécute le :then
expression si vraie, l'expression :else si fausse.

val=for(initexpr whileexpr [nextexpr [bodyexpr]] :body expr) -- pour la boucle

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

val=switch(val key-body-pairs) -- instruction switch (:casen pour pos., :case_n pour neg.,
sinon :symbole)

continue -- passer à l'itération suivante de la boucle for ou while

break([retval]) -- rupture de la boucle for ou while

AUTRES COMMANDES

help(cmdname [cmdname ...] :all :posteval) -- aide pour les commandes

val=trace([flag] :get) -- bascule ou définit le mode de trace

pause([msgstr]) -- suspendre l'exécution du script jusqu'à C/R

step() -- bascule l'exécution du script pas à pas

fileobj|pipeobj=open([filename [modestr]] :pipe :in :out :err) -- commande d'ouverture de fichier

close(fileobj|pipeobj) -- commande de fermeture de fichier

[str]=print([fmtstr] [val [val1 [... valn]]] :string|:str :out :err :file fileobj|pipeobj
:prefix str) -- affiche la valeur avec une chaîne de format facultative

str=gets(fileobj|pipeobj) -- obtient une chaîne terminée par une nouvelle ligne à partir d'un fichier

val=global(symbol)|global(symbol)=val|global(symbol :clear)|global(:cnt) -- créer un symbole
de défis

int|lst=symid(symbole [symbole ...] | :max) -- renvoie le ou les entiers associés à
symbole(s)

sym|lst=symbol(symid [symid ...]) -- renvoie le(s) symbole(s) associé(s) à un ou plusieurs identifiants entiers

val|lst=symval(symbole [symbole ...]) -- valeur(s) de retour associée(s) au symbole
variable(s)

sym|lst=symadd(sym|str [sym|str ...]) -- crée le(s) symbole(s) et retourne sans recherche.

sym=symvar(sym) -- renvoie le symbole tel quel

str=symstr(sym) -- renvoie la version chaîne du symbole

n=strref(str|symid) -- renvoie le nombre de références de chaîne

lst=split(symbol|string :tokstr [delim] :tokval [delim] :keep :reverse) -- symbole de division
ou chaîne dans une liste de caractères (ou jetons).

str=join(clist :sym) -- joint la liste de caractères dans la chaîne

str=substr(str n|str :after :nonil) -- extrait les caractères d'une chaîne (:nonil renvoie
chaîne si aucune correspondance)

bool=eq(str1 str2 :n len) -- comparaison partielle de chaînes

bool=eq(sym1 sym2 :sym) -- comparaison de symboles

postfix(arg1 [arg2 [arg3 ... [argn]]]) -- echo arguments postfix non évalués (avec
[narg|nkey] après les commandes définies, {narg|nkey} après les commandes non définies, (narg) après
touches, et un * suivant les commandes de post-évaluation)

parse(fileobj) -- analyse une seule expression à partir d'un fichier

arr=posteval(arg1 [arg2 [arg3 ... [argn]]]) -- post-évalue chaque argument fixe (jusqu'à
nil) et renvoie le tableau
sym=attrname(attribut) -- renvoie le champ de nom de la paire en pointillés
val=attrval(attribut) -- champ de valeur de retour de la paire en pointillés
dotlst=dot(name) -- construction d'une liste de paires en pointillés vide

quit() -- quitte l'interpréteur

exit() -- quitter toute l'application

empty() -- instruction vide

val=run(filename :str :popen) -- exécuter des commandes à partir d'un fichier (ou d'une chaîne)

val=remote(hoststr portnum cmdstr :nowait) -- évaluer à distance la chaîne de commande puis
évaluer localement la chaîne de résultat

val=eval(cmdstr|funcobj [cmdstr|funcobj ...] :symret ) -- évalue la chaîne (ou funcobj) comme
commandes, renvoient éventuellement un symbole au lieu de nil

funcobj=func(body :echo) -- encapsule un corps de commandes dans un objet exécutable

val=shell(cmdstr) -- évalue la commande dans le shell

tu dors(msec) -- microsecondes de sommeil

muet([drapeau]) -- définit ou bascule le drapeau muet

nil([...]) -- accepte tous les arguments et renvoie nil

c=char(num :u) -- convertit n'importe quel nombre en caractère

s=short(num :u) -- convertit n'importe quel nombre en un court

i=int(num :u) -- convertit n'importe quel nombre en entier

l=long(num :u) -- convertit n'importe quel nombre en long

f=float(num) -- convertit n'importe quel nombre en flottant

d=double(num) -- convertit n'importe quel nombre en double

sym|lst=type(val [val ...]) -- renvoie le(s) symbole(s) de type pour la(les) valeur(s)

sym|lst=class(val [val ...]) -- renvoie le(s) symbole(s) de classe pour la(les) valeur(s) du type d'objet

int=ctoi(char) -- convertit le caractère en entier

flag=isspace(char) -- retourne vrai si le caractère est un espace

flag=isdigit(char) -- renvoie true si le caractère est un chiffre numérique

flag=isspace(char) -- retourne vrai si le caractère est alphabétique

str=arg(n) -- renvoie l'argument de la ligne de commande

n=narg(n) -- renvoie le nombre d'arguments de ligne de commande

num=nand(ab) -- NAND au niveau du bit (ET inversé)

num=nor(ab) -- NOR bit à bit (OU nié)

num=xnor(ab) -- XNOR bit à bit (XOR nié)

UNIQUEMENT IN SERVEUR MODE

str=timeexpr(comstr :sec n) -- chaîne de commande à exécuter à intervalles

Utilisez comrp en ligne en utilisant les services onworks.net