זהו הפקודה comterp שניתן להפעיל בספק האירוח החינמי של OnWorks באמצעות אחת מתחנות העבודה המקוונות המרובות שלנו, כגון Ubuntu Online, Fedora Online, אמולטור מקוון של Windows או אמולטור מקוון של MAC OS
תָכְנִית:
שֵׁם
comterp - מפגן מתורגמן פיקוד מבוזר
תַקצִיר
קומטרפ
קומטרפ מרחוק
קומטרפ שרת "פורטנום"
קומטרפ לוגר "פורטנום"
קומטרפ לקוח "מארח" "פורטנום" ["קובץ"]
קומטרפ telcat "host" "portnum" ["קובץ"]
קומטרפ הרץ "קובץ"
קומטרפ "expr"
תיאור
comterp מדגים את מתורגמן הפקודות המשולב ב-ivtools. משתמש (או לקוח
תוכנית) יכולה לקיים אינטראקציה עם comterp באמצעות stdin ו-stdout או telnet (כאשר ACE מובנה).
תחביר הפקודות הוא רשימה מופרדת בנקודה-פסיק של פקודות עם מספר שרירותי של
פרמטרים סגורים בסוגריים, עם תמיכה בפרמטרים אופציונליים ובמילת מפתח
טיעונים, כלומר:
command2(arg1 arg2 arg3 :key1 val1 :key2 val2);
command1(arg1 arg2 arg3 :key1 val1 :key2 val2)
ניתן להטמיע ביטויים בינאריים דמויי C בכל מקום בשפת הפקודה, באמצעות ה-
מפעילים בטבלה למטה. ניתן ליצור משתנים תוך כדי תנועה עם מטלה
אופרטור (כלומר "ball=1" יוצר משתנה "כדור" במספר שלם שהוגדר ל-1). ללא הפסקה
ביטויים גורמים לסיומת שורת פקודה אוטומטית (עד שהמנתח יקבע את
הביטוי הושלם). ניתן להשתמש ב-"(), "{}", ו-"[]" כולם לסירוגין.
פקודה אפשרויות
קומטרפ
הפעל מתורגמן פקודה יחידה לאינטראקציה באמצעות stdin ו-stdout.
שלט קומטרפ
הפעל מתורגמן פקודה בודדת, כמו ברירת המחדל, וכלול פקודה מרחוק עבור
גישה ל-comterp אחרים במצב שרת.
שרת קומטרפ "פורטנום"
מאזין ומקבל חיבורים ב-portnum, ולאחר מכן הגדר מתורגמן פקודות להמתין
עבור ומעבד פקודות מאותו חיבור.
comterp logger "portnum"
מאזין ומקבל חיבורים ב-portnum, ואז פשוט מעביר את ההודעות הנכנסות
ל-stdout, תוך החזרה בשורות חדשות. למטרות ניפוי באגים, לא ממש שימוש ב
המתורגמן.
comterp client "host" "portnum" ["קובץ"]
התחבר ל-portnum במארח ושלח/קבל מאגרי טקסט שהסתיימו בשורה חדשה. ל
למטרות ניפוי באגים, לא ממש שימוש במתורגמן.
comterp telcat "host" "portnum" ["קובץ"]
התחבר ל-portnum במארח, צור את הקובץ ואז סגור את החיבור. לא ממש שימוש
גם של המתורגמן.
comterp הרץ "קובץ"
הפעל את תוכן הקובץ ואז צא.
comterp "expr"
הערך ביטוי בודד ואז צא.
מַפעִיל טבלה
שם פקודת מפעילים סוג סדר עדיפות
---------- -------------------- ----- ----
. נקודה 130 R-to-L בינארי
` bquote 125 R-to-L unary-prefix
! לשלול 110 R-to-L unary-prefix
~ bit_not 110 R-to-L unary-prefix
++ incr 110 R-to-L unary-prefix
++ incr_after 110 R-to-L unary-postfix
- מינוס 110 R-to-L unary-prefix
-- decr 110 R-to-L unary-prefix
-- decr_after 110 R-to-L unary-postfix
** חזור על 90 L-to-R בינארי
.. לחזור על 80 L-to-R בינאריים
% mod 70 L-to-R בינארי
* mpy 70 L-to-R בינארי
/ div 70 L-to-R בינארי
+ הוסף 60 L-to-R בינארי
- תת 60 L-to-R בינארי
<< lshift 55 L-to-R בינארי
>> rshift 55 L-to-R בינארי
< lt 50 L-to-R בינארי
<= lt_or_eq 50 L-to-R בינארי
> gt 50 L-to-R בינארי
>= gt_or_eq 50 L-to-R בינארי
!= not_eq 45 L-to-R בינארי
== eq 45 L-to-R בינארי
& bit_and 44 L-to-R בינארי
^ bit_xor 43 L-to-R בינארי
| bit_or 42 L-to-R בינארי
&& ו-41 L-to-R בינארי
|| או 40 L-to-R בינארי
, tuple 35 L-to-R בינארי
,, זרם קונצרט 33 L-to-R בינארי
$ זרם 32 R-to-L unary-prefix
$$ רשימת 32 R-to-L unary-prefix
%= mod_assign 30 R-to-L בינארי
*= mpy_assign 30 R-to-L בינארי
+= add_assign 30 R-to-L בינארי
-= sub_assign 30 R-to-L בינארי
/= div_assign 30 R-to-L בינארי
= הקצה 30 R-to-L בינארי
; seq 10 L-to-R בינארי
מָתֵימָטִי פקודות:
n=min(ab) -- החזר מינימום של a ו-b
n=max(ab) -- החזר מקסימום של a ו-b
n=abs(a) -- החזרת ערך מוחלט של a
dbl=exp(x) -- מחזירה את הערך e שהועלה בחזקת x
dbl=log(x) -- מחזיר את הלוגריתם הטבעי של x
dbl=log10(x) -- מחזיר את הלוגריתם בסיס-10 של x
dbl=log2(x) -- מחזיר את הלוגריתם בסיס-2 של x
dbl=pow(xy) -- מחזיר את הערך של x שהועלה בחזקת y
dbl=acos(x) -- מחזיר את קוסינוס הקשת של x ברדיאנים
dbl=asin(x) -- מחזיר את סינוס הקשת של x ברדיאנים
dbl=atan(x) -- מחזיר את טנגנס הקשת של x ברדיאנים
dbl=atan2(yx) -- מחזיר את טנגנס הקשת של y מעל x
dbl=cos(x) -- מחזירה את הקוסינוס של x רדיאנים
dbl=sin(x) -- מחזירה את הסינוס של x רדיאנים
dbl=tan(x) -- מחזיר את הטנגנס של x רדיאנים
dbl=sqrt(x) -- מחזירה שורש ריבועי של x
dbl=pi() -- מחזיר את הערך של pi
dbl=radtodeg(dbl) -- המרת רדיאנים למעלות
dbl=degtorad(dbl) -- המרת מעלות לרדיאנים
num=floor(num) -- החזר את הערך השלם הקרוב ביותר קטן או שווה לארגומנט
num=ceil(num) -- החזר את הערך השלם הקרוב ביותר גדול או שווה לארגומנט
num=round(num) -- החזר את הערך השלם הקרוב ביותר
AFFINE טרנספורמציה ו MATRIX פקודות:
point=xform(x,y a00,a01,a10,a11,a20,a21) -- טרנספורמציה קשורה של קואורדינטות x,y
affine=invert(a00,a01,a10,a11,a20,a21) -- הפוך טרנספורמציה אפינית
מטריצה=xpose(מטריקס) -- תמיר מטריצה שרירותית
מטריצה=מטריקס*מטריקס -- כפל מטריצה
סטטיסטי/אקראי פקודות:
sum(val1[,val2[,...,valn]]) -- החזר סכום של ערכים
mean(val1[,val2[,...,valn]]) -- החזר ממוצע של ערכים
var(val1[,val2[,...,valn]]) -- החזרת שונות של ערכים
stddev(val1[,val2[,...,valn]]) -- החזר סטיית תקן של ערכים
rand([minval,maxval]) -- החזר מספר אקראי בין 0 ל-1 או minval,maxval
srand(seedval) -- מחולל מספרים אקראיים זרעים
רשימה פקודות:
lst=list([olst|strm|val] :strmlst :attr :size n) -- צור רשימה, העתק רשימה או המר
זרם
val=at(list|attrlist|str n :set val :ins val) -- החזר (או קבע או הוסף אחרי) פריט nth
ברשימה או מחרוזת
num=size(list|attrlist|str) -- החזר גודל של רשימה (או מחרוזת)
val=index(list|str val|char|str :last :all :substr) -- החזרת אינדקס של ערך (או char או
מחרוזת) ברשימה (או מחרוזת), אפס אם לא נמצא.
זרם פקודות:
val=next(stream) -- החזר את הערך הבא מהזרם
strm=stream(ostrm|list|attrlist|val) -- העתק זרם או המר רשימה
cnt=each(strm) -- חוצה זרם המחזיר את אורכו
comp=filter(comps classid) -- סינון זרם של comps להתאמה של classid
בקרה לפני ואחרי הטיפול פקודות (באמצעות פוסט הַעֲרָכָה):
val=cond(testexpr trueexpr falseexpr) -- הערך testexpr, ואם נכון, הערך ו
החזר trueexpr, אחרת הערך והחזר falseexpr
val=if(testexpr :then expr :else expr) -- הערך testexpr והפעל את :then
ביטוי אם נכון, הביטוי :else אם שקר.
val=for(initexpr whileexpr [nextexpr [bodyexpr]] :body expr) -- עבור לולאה
val=while([testexpr [bodyexpr]] :nilchk :until :body expr ) -- while loop
val=switch(val key-body-pairs) -- הצהרת switch (:casen for pos., :case_n for neg.,
אחרת :סמל)
המשך -- דלג לאיטרציה הבאה של לולאה for או while
break([retval]) -- פריצה מתוך לולאת for או while
אחר פקודות
help(cmdname [cmdname ...] :all :posteval) -- עזרה עבור פקודות
val=trace([flag] :get) -- החלף או הגדר מצב מעקב
pause([msgstr]) -- השהה את ביצוע הסקריפט עד ל-C/R
step() -- החלף את ביצוע הסקריפט בהדרגה
fileobj|pipeobj=open([שם קובץ [modestr]] :pipe :in :out :err) -- פקודת פתח קובץ
close(fileobj|pipeobj) -- פקודת סגור קובץ
[str]=print([fmtstr] [val [val1 [... valn]]] :string|:str :out :err :file fileobj|pipeobj
:prefix str) -- ערך הדפסה עם מחרוזת פורמט אופציונלי
str=gets(fileobj|pipeobj) -- מקבל מחרוזת שנסגרה בשורה חדשה מקובץ
val=global(סמל)|global(סמל)=val|global(סמל :clear)|global(:cnt) -- הפוך סמל
גלוֹבָּלִי
int|lst=symid(סמל [סמל ...] | :max) -- החזר מזהים שלמים המשויכים ל
סמל(ים)
sym|lst=symbol(symid [symid ...]) -- החזרת סמל(ים) המשויכים למזהים שלמים
val|lst=symval(סמל [סמל ...]) -- החזר ערכים המשויכים לסמל
משתנים
sym|lst=symadd(sym|str [sym|str ...]) -- צור סמל(ים) והחזר ללא חיפוש.
sym=symvar(sym) -- החזרת סמל כפי שהוא
str=symstr(sym) -- החזרת גרסת מחרוזת של סמל
n=strref(str|symid) -- החזרת ספירת הפניות למחרוזת
lst=split(סמל|מחרוזת :tokstr [delim] :tokval [delim] :keep :reverse) -- סמל מפוצל
או מחרוזת לרשימת תווים (או אסימונים).
str=join(clist :sym) -- חבר רשימת תווים למחרוזת
str=substr(str n|str :after :nonil) -- חלץ תווים ממחרוזת (:nonil מחזירה
מחרוזת אם אין התאמה)
bool=eq(str1 str2 :n len) -- השוואת מחרוזת חלקית
bool=eq(sym1 sym2 :sym) -- השוואת סמלים
postfix(arg1 [arg2 [arg3 ... [argn]]]) -- הד ארגומנטים של postfix לא מוערכים (עם
[narg|nkey] אחרי פקודות מוגדרות, {narg|nkey} אחרי פקודות לא מוגדרות, (narg) אחרי
מפתחות, ו-* בעקבות פקודות לאחר הערכה)
parse(fileobj) -- נתח ביטוי בודד מקובץ
arr=posteval(arg1 [arg2 [arg3 ... [argn]]]) -- ערך לאחר הערכה של כל ארגומנט קבוע (עד
אפס) ומערך החזרה
sym=attrname(attribute) -- החזרת שדה שם של זוג מנוקד
val=attrval(תכונה) -- שדה ערך החזרה של זוג מנוקד
dotlst=dot(name) -- בנה רשימה ריקה של זוגות מנוקדים
quit() -- צא מהמתורגמן
exit() -- צא מהיישום כולו
empty() -- הצהרה ריקה
val=run (שם קובץ :str :popen) -- הפעל פקודות מהקובץ (או מחרוזת)
val=remote(hoststr portnum cmdstr :nowait) -- הערך מרחוק את מחרוזת הפקודה ואז
להעריך מקומית מחרוזת תוצאות
val=eval(cmdstr|funcobj [cmdstr|funcobj ...] :symret ) -- הערך מחרוזת (או funcobj) בתור
פקודות, אופציונלי להחזיר סמל במקום אפס
funcobj=func(body :echo) -- הכנס גוף של פקודות לאובייקט בר הפעלה
val=shell(cmdstr) -- הערכת הפקודה במעטפת
אתה ישן(msec) -- מיקרו-שניות שינה
mute([flag]) -- הגדר או החלף את דגל השתקה
nil([...]) -- קבל כל טיעון והחזר אפס
c=char(num :u) -- המר כל מספרי ל-char
s=short(num :u) -- המר כל מספרי לקצר
i=int(num :u) -- המר כל מספרי ל-int
l=long(num :u) -- המר כל מספרי ללונג
f=float(num) -- המר כל מספרי ל-float
d=double(num) -- המר כל מספרי לכפולה
sym|lst=type(val [val ...]) -- החזרת סמל(ים) מסוג עבור ערכים
sym|lst=class(val [val ...]) -- החזרת סמל(ים) מחלקה עבור ערכים של סוג אובייקט
int=ctoi(char) -- המרת תו למספר שלם
flag=isspace(char) -- החזר true אם התו הוא רווח לבן
flag=isdigit(char) -- החזר true אם התו הוא ספרה מספרית
flag=isspace(char) -- החזר true אם התו הוא אלפביתי
str=arg(n) -- החזר ארגומנט שורת הפקודה
n=narg(n) -- החזר מספר ארגומנטים של שורת הפקודה
num=nand(ab) -- NAND (מבוטל AND)
num=nor(ab) -- NOR (שלילה OR)
num=xnor(ab) -- XNOR בשיטת סיביות (שלילה XOR)
רק IN שרת MODE
str=timeexpr(comstr :sec n) -- מחרוזת פקודה לביצוע במרווחים
השתמש ב-comterp באינטרנט באמצעות שירותי onworks.net
