comterp - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

comterp - വിതരണം ചെയ്ത കമാൻഡ് ഇന്റർപ്രെറ്റർ ഡെമോൺസ്‌ട്രേറ്റർ

സിനോപ്സിസ്

comterp
comterp വിദൂര
comterp സെർവർ "പോർട്ട്നം"
comterp ലോഗർ "പോർട്ട്നം"
comterp ക്ലയന്റ് "ഹോസ്റ്റ്" "പോർട്ട്നം" ["ഫയൽ"]
comterp ടെൽകാറ്റ് "ഹോസ്റ്റ്" "പോർട്ട്നം" ["ഫയൽ"]
comterp "ഫയൽ" പ്രവർത്തിപ്പിക്കുക
comterp "expr"

വിവരണം

ivtools-ൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന കമാൻഡ് ഇന്റർപ്രെറ്റർ comterp കാണിക്കുന്നു. ഒരു ഉപയോക്താവ് (അല്ലെങ്കിൽ ക്ലയന്റ്
പ്രോഗ്രാം) stdin, stdout അല്ലെങ്കിൽ telnet വഴി comterp-മായി സംവദിക്കാൻ കഴിയും (ACE ബിൽറ്റ് ഇൻ ചെയ്യുമ്പോൾ).
കമാൻഡ് സിന്റാക്സ് എന്നത് അർബിട്രറി നമ്പറുള്ള കമാൻഡുകളുടെ ഒരു സെമി-കോളൺ വേർതിരിക്കുന്ന ലിസ്റ്റാണ്
ഓപ്‌ഷണൽ പാരാമീറ്ററുകൾക്കും കീവേഡുകൾക്കുമുള്ള പിന്തുണയോടെ പരാൻതീസിസിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പാരാമീറ്ററുകൾ
വാദങ്ങൾ, അതായത്:

കമാന്ഡ്ല 2 (ARG1 ARG2 അര്ഗ്൩: കെയ്൧ വല്൧: കെയ്൨ വല്൨);
command1(arg1 arg2 arg3 :key1 val1 :key2 val2)

C-പോലുള്ള ബൈനറി എക്സ്പ്രഷനുകൾ കമാൻഡ് ഭാഷയിൽ എവിടെയും ഉൾച്ചേർക്കാവുന്നതാണ്
താഴെയുള്ള പട്ടികയിലെ ഓപ്പറേറ്റർമാർ. ഒരു അസൈൻമെന്റ് ഉപയോഗിച്ച് ഈച്ചയിൽ വേരിയബിളുകൾ സൃഷ്ടിക്കാൻ കഴിയും
ഓപ്പറേറ്റർ (അതായത് "ബോൾ=1" ഒരു പൂർണ്ണസംഖ്യ "ബോൾ" വേരിയബിൾ 1 ആയി സജ്ജമാക്കുന്നു). അവസാനിപ്പിക്കാത്തത്
പാഴ്സർ നിർണ്ണയിക്കുന്നു വരെ പദപ്രയോഗങ്ങൾ ഓട്ടോമാറ്റിക് കമാൻഡ് ലൈൻ വിപുലീകരണം കാരണമാകും (
ആവിഷ്കാരം പൂർത്തിയായി). "(), "{}", "[]" എന്നിവയെല്ലാം പരസ്പരം മാറ്റി ഉപയോഗിക്കാവുന്നതാണ്.

കമാൻറ് ഓപ്ഷനുകൾ

comterp

stdin, stdout എന്നിവ വഴി സംവദിക്കാൻ ഒരൊറ്റ കമാൻഡ് ഇന്റർപ്രെറ്ററെ വിളിക്കുക.

comterp റിമോട്ട്

ഡിഫോൾട്ട് പോലെ ഒരൊറ്റ കമാൻഡ് ഇന്റർപ്രെറ്ററിനെ അഭ്യർത്ഥിക്കുക, ഇതിനായി ഒരു റിമോട്ട് കമാൻഡ് ഉൾപ്പെടുത്തുക
സെർവർ മോഡിൽ മറ്റ് comterp-കൾ ആക്സസ് ചെയ്യുന്നു.

comterp സെർവർ "portnum"

പോർട്ട്നത്തിൽ കണക്ഷനുകൾ ശ്രദ്ധിക്കുകയും സ്വീകരിക്കുകയും ചെയ്യുന്നു, തുടർന്ന് കാത്തിരിക്കാൻ ഒരു കമാൻഡ് ഇന്റർപ്രെറ്റർ സജ്ജീകരിക്കുക
ആ കണക്ഷനിൽ നിന്നുള്ള കമാൻഡുകൾക്കായി, പ്രോസസ്സ് ചെയ്യുക.

comterp logger "portnum"

പോർട്ട്നത്തിൽ കണക്ഷനുകൾ ശ്രദ്ധിക്കുകയും സ്വീകരിക്കുകയും ചെയ്യുന്നു, തുടർന്ന് ഇൻകമിംഗ് സന്ദേശങ്ങൾ കൈമാറുക
stdout-ലേക്ക്, പുതിയ ലൈനുകളുമായി തിരികെ വരുമ്പോൾ. ഡീബഗ്ഗിംഗ് ആവശ്യങ്ങൾക്ക്, ശരിക്കും ഒരു ഉപയോഗമല്ല
വ്യാഖ്യാതാവ്.

comterp ക്ലയന്റ് "ഹോസ്റ്റ്" "പോർട്ട്നം" ["ഫയൽ"]

ഒരു ഹോസ്റ്റിലെ ഒരു പോർട്ട്നത്തിലേക്ക് കണക്റ്റുചെയ്‌ത് പുതിയ-ലൈൻ ടെർമിനേറ്റഡ് ടെക്‌സ്‌റ്റ് ബഫറുകൾ അയയ്‌ക്കുക/സ്വീകരിക്കുക. വേണ്ടി
ഡീബഗ്ഗിംഗ് ഉദ്ദേശ്യങ്ങൾ, യഥാർത്ഥത്തിൽ വ്യാഖ്യാതാവിന്റെ ഉപയോഗമല്ല.

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

ഒരു ഹോസ്റ്റിലെ ഒരു പോർട്ട്നത്തിലേക്ക് കണക്റ്റുചെയ്യുക, ഫയൽ ക്യാറ്റ് ചെയ്യുക, തുടർന്ന് കണക്ഷൻ അടയ്ക്കുക. ശരിക്കും ഒരു ഉപയോഗമല്ല
ഒന്നുകിൽ വ്യാഖ്യാതാവിന്റെ.

comterp റൺ "ഫയൽ"

ഫയലിന്റെ ഉള്ളടക്കങ്ങൾ പ്രവർത്തിപ്പിച്ച് പുറത്തുകടക്കുക.

comterp "expr"

സിംഗിൾ എക്‌സ്‌പ്രഷൻ വിലയിരുത്തി പുറത്തുകടക്കുക.

ഓപ്പറേറ്റർ മേശ

ഓപ്പറേറ്റർമാരുടെ കമാൻഡ് നാമം മുൻഗണനാ ക്രമം തരം
----------------------------------------
. ഡോട്ട് 130 ആർ-ടു-എൽ ബൈനറി
` 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 ബൈനറി ആവർത്തിക്കുക
% മോഡ് 70 എൽ-ടു-ആർ ബൈനറി
* mpy 70 L-to-R ബൈനറി
/ div 70 L-to-R ബൈനറി
+ 60 L-ടു-R ബൈനറി ചേർക്കുക
- സബ് 60 എൽ-ടു-ആർ ബൈനറി
<< 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 ബൈനറി
& ബിറ്റ്_ആൻഡ് 44 എൽ-ടു-ആർ ബൈനറി
↑ bit_xor 43 L-to-R ബൈനറി
| ബിറ്റ്_അല്ലെങ്കിൽ 42 എൽ-ടു-ആർ ബൈനറി
&& കൂടാതെ 41 എൽ-ടു-ആർ ബൈനറി
|| അല്ലെങ്കിൽ 40 എൽ-ടു-ആർ ബൈനറി
, ട്യൂപ്പിൾ 35 എൽ-ടു-ആർ ബൈനറി
,, സ്ട്രീം കോൺകാറ്റ് 33 എൽ-ടു-ആർ ബൈനറി
$ സ്ട്രീം 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) -- റിട്ടേൺ മിനിമം എ, ബി

n=max(ab) -- റിട്ടേൺ പരമാവധി a, b

n=abs(a) -- a യുടെ കേവല മൂല്യം തിരികെ നൽകുക

dbl=exp(x) -- x-ന്റെ ശക്തിയിലേക്ക് ഉയർത്തിയ മൂല്യം e നൽകുന്നു

dbl=log(x) -- x ന്റെ സ്വാഭാവിക ലോഗരിതം നൽകുന്നു

dbl=log10(x) -- x ന്റെ അടിസ്ഥാന-10 ലോഗരിതം നൽകുന്നു

dbl=log2(x) -- x ന്റെ അടിസ്ഥാന-2 ലോഗരിതം നൽകുന്നു

dbl=pow(xy) -- x ന്റെ മൂല്യം y യുടെ ശക്തിയിലേക്ക് ഉയർത്തുന്നു

dbl=acos(x) -- x ന്റെ ആർക്ക് കോസൈൻ റേഡിയൻസിൽ നൽകുന്നു

dbl=asin(x) -- റേഡിയനുകളിൽ x ന്റെ ആർക്ക് സൈൻ നൽകുന്നു

dbl=atan(x) -- റേഡിയനുകളിൽ x ന്റെ ആർക്ക് ടാൻജെന്റ് നൽകുന്നു

dbl=atan2(yx) -- x-നേക്കാൾ y യുടെ ആർക്ക് ടാൻജെന്റ് നൽകുന്നു

dbl=cos(x) -- x റേഡിയൻസിന്റെ കോസൈൻ നൽകുന്നു

dbl=sin(x) -- x റേഡിയൻസിന്റെ സൈൻ നൽകുന്നു

dbl=tan(x) -- x റേഡിയനുകളുടെ ടാൻജെന്റ് നൽകുന്നു

dbl=sqrt(x) -- x ന്റെ വർഗ്ഗമൂല്യം നൽകുന്നു

dbl=pi() -- പൈയുടെ മൂല്യം നൽകുന്നു

dbl=radtodeg(dbl) -- റേഡിയനുകളെ ഡിഗ്രികളാക്കി മാറ്റുക

dbl=degtorad(dbl) -- ഡിഗ്രികളെ റേഡിയനുകളാക്കി മാറ്റുക

num=floor(num) -- ഏറ്റവും അടുത്തുള്ള പൂർണ്ണസംഖ്യ മൂല്യം ആർഗ്യുമെന്റിനേക്കാൾ കുറവോ തുല്യമോ നൽകുക

num=ceil(num) -- ആർഗ്യുമെന്റിനേക്കാൾ വലുതോ തുല്യമോ ആയ ഏറ്റവും അടുത്തുള്ള പൂർണ്ണസംഖ്യ മൂല്യം തിരികെ നൽകുക

num=round(num) -- ഏറ്റവും അടുത്തുള്ള പൂർണ്ണസംഖ്യ മൂല്യം തിരികെ നൽകുക

AFFINE ട്രാൻസ്ഫോർം ഒപ്പം മാട്രിക്സ് കമാൻഡുകൾ:

പോയിന്റ്=xform(x,y a00,a01,a10,a11,a20,a21) -- x,y കോർഡിനേറ്റുകളുടെ അഫൈൻ പരിവർത്തനം

affine=invert(a00,a01,a10,a11,a20,a21) -- വിപരീത രൂപാന്തരം

മാട്രിക്സ്=വെളിപ്പെടുത്തുക(മാട്രിക്സ്) -- ഒരു അനിയന്ത്രിതമായ മാട്രിക്സ് ട്രാൻസ്പോസ് ചെയ്യുക

മാട്രിക്സ്=മാട്രിക്സ്*മാട്രിക്സ് -- മാട്രിക്സ് ഗുണനം

സ്റ്റാറ്റിസ്റ്റിക്കൽ/റാൻഡം കമാൻഡുകൾ:

തുക(val1[,val2[,...,valn]]) -- മൂല്യങ്ങളുടെ ആകെത്തുക

ശരാശരി(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 :സെറ്റ് val:ins val) -- തിരികെ (അല്ലെങ്കിൽ സജ്ജീകരിക്കുക അല്ലെങ്കിൽ തിരുകുക) nth ഇനം
ഒരു ലിസ്റ്റിലോ സ്ട്രിംഗിലോ

num=size(list|attrlist|str) -- ഒരു ലിസ്റ്റിന്റെ റിട്ടേൺ സൈസ് (അല്ലെങ്കിൽ സ്ട്രിംഗ്)

val=index(list|str val|char|str :അവസാനം :എല്ലാം:substr) -- മൂല്യത്തിന്റെ റിട്ടേൺ സൂചിക (അല്ലെങ്കിൽ പ്രതീകം അല്ലെങ്കിൽ
സ്ട്രിംഗ്) പട്ടികയിൽ (അല്ലെങ്കിൽ സ്ട്രിംഗ്), കണ്ടെത്തിയില്ലെങ്കിൽ ഇല്ല.

സ്ട്രീം കമാൻഡുകൾ:

val=next(stream) -- സ്ട്രീമിൽ നിന്ന് അടുത്ത മൂല്യം തിരികെ നൽകുക

strm=stream(ostrm|list|attrlist|val) -- സ്ട്രീം പകർത്തുക അല്ലെങ്കിൽ ലിസ്റ്റ് പരിവർത്തനം ചെയ്യുക

cnt=each(strm) -- ട്രാവേഴ്സ് സ്ട്രീം അതിന്റെ ദൈർഘ്യം നൽകുന്നു

comp=filter(comps classid) -- പൊരുത്തപ്പെടുന്ന ക്ലാസ്സിഡിനുള്ള കോമ്പുകളുടെ ഫിൽട്ടർ സ്ട്രീം

നിയന്ത്രണം കമാൻഡുകൾ (ഉപയോഗിക്കുന്നത് സ്ഥാനം മൂല്യനിർണ്ണയം):

val=cond(testexpr trueexpr falseexpr) -- testexpr വിലയിരുത്തുക, ശരിയാണെങ്കിൽ, വിലയിരുത്തുക
trueexpr തിരികെ നൽകുക

val=if(testexpr :പിന്നെ expr :else expr) -- testexpr മൂല്യനിർണ്ണയം നടത്തി :അപ്പോൾ എക്സിക്യൂട്ട് ചെയ്യുക
പദപ്രയോഗം ശരിയാണെങ്കിൽ, :else പദപ്രയോഗം തെറ്റാണെങ്കിൽ.

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

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

val=switch(val key-body-pairs) -- സ്വിച്ച് സ്റ്റേറ്റ്‌മെന്റ് (:pos-നുള്ള casen., :case_n for neg.,
അല്ലെങ്കിൽ: ചിഹ്നം)

തുടരുക -- ഫോർ അല്ലെങ്കിൽ ലൂപ്പിന്റെ അടുത്ത ആവർത്തനത്തിലേക്ക് പോകുക

ബ്രേക്ക് ([retval]) -- ലൂപ്പിന് വേണ്ടി അല്ലെങ്കിൽ സമയത്ത് ബ്രേക്ക് ഔട്ട്

മറ്റുള്ളവ കമാൻഡുകൾ

സഹായം(cmdname [cmdname ...] :എല്ലാം :posteval) -- കമാൻഡുകൾക്കുള്ള സഹായം

val=trace([flag] :get) -- ടോഗിൾ ചെയ്യുക അല്ലെങ്കിൽ ട്രെയ്സ് മോഡ് സജ്ജമാക്കുക

pause([msgstr]) -- C/R വരെ സ്‌ക്രിപ്റ്റ് എക്‌സിക്യൂഷൻ താൽക്കാലികമായി നിർത്തുക

step() -- സ്റ്റെപ്പ്വൈസ് സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ ടോഗിൾ ചെയ്യുക

fileobj|pipeobj=open([filename [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=ആഗോള(ചിഹ്നം)|ആഗോള(ചിഹ്നം)=val|ആഗോള(ചിഹ്നം:വ്യക്തം)|global(:cnt) -- ചിഹ്നം ഉണ്ടാക്കുക
ഗ്ലോബൽ

int|lst=symid(ചിഹ്നം [ചിഹ്നം ...] | :max) -- ഇതുമായി ബന്ധപ്പെട്ട പൂർണ്ണസംഖ്യ ഐഡി(കൾ) തിരികെ നൽകുക
ചിഹ്നം(കൾ)

sym|lst=symbol(symid [symid ...]) -- Integer id(s)മായി ബന്ധപ്പെട്ട റിട്ടേൺ ചിഹ്നം(കൾ)

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] :കീപ്പ്:റിവേഴ്സ്) -- സ്പ്ലിറ്റ് ചിഹ്നം
അല്ലെങ്കിൽ പ്രതീകങ്ങളുടെ പട്ടികയിലേക്ക് (അല്ലെങ്കിൽ ടോക്കണുകൾ) സ്ട്രിംഗ് ചെയ്യുക.

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]]]) -- മൂല്യനിർണ്ണയം ചെയ്യാത്ത പോസ്റ്റ്ഫിക്സ് ആർഗ്യുമെന്റുകൾ (കൂടാതെ
നിർവചിക്കപ്പെട്ട കമാൻഡുകൾക്ക് ശേഷം [narg|nkey], നിർവചിക്കാത്ത കമാൻഡുകൾക്ക് ശേഷം {narg|nkey}, (narg) ശേഷം
കീകൾ, ഒരു * ഇനിപ്പറയുന്ന പോസ്റ്റ്-മൂല്യനിർണ്ണയ കമാൻഡുകൾ)

parse(fileobj) -- ഒരു ഫയലിൽ നിന്ന് ഒരൊറ്റ എക്സ്പ്രഷൻ പാഴ്സ് ചെയ്യുക

arr=posteval(arg1 [arg2 [arg3 ... [argn]]]) -- ഓരോ നിശ്ചിത ആർഗ്യുമെന്റിനും ശേഷം വിലയിരുത്തുക (വരെ
nil) കൂടാതെ റിട്ടേൺ അറേയും
sym=attrname(attribute) -- ഡോട്ടഡ് ജോഡിയുടെ റിട്ടേൺ നെയിം ഫീൽഡ്
val=attrval(ആട്രിബ്യൂട്ട്) -- ഡോട്ട് ഇട്ട ജോഡിയുടെ മൂല്യ ഫീൽഡ് തിരികെ നൽകുക
dotlst=dot(name) -- ശൂന്യമായ ഡോട്ടുള്ള ജോഡി ലിസ്റ്റ് നിർമ്മിക്കുക

quit() -- വ്യാഖ്യാതാവിനെ ഉപേക്ഷിക്കുക

exit() -- മുഴുവൻ ആപ്ലിക്കേഷനും പുറത്തുകടക്കുക

ശൂന്യമായ () -- ശൂന്യമായ പ്രസ്താവന

val=run(ഫയലിന്റെ പേര്:str:popen) -- ഫയലിൽ നിന്ന് കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുക (അല്ലെങ്കിൽ സ്ട്രിംഗ്)

val=remote(hoststr portnum cmdstr :nowait) -- കമാൻഡ് സ്ട്രിംഗ് വിദൂരമായി വിലയിരുത്തുക
ഫല സ്ട്രിംഗ് പ്രാദേശികമായി വിലയിരുത്തുക

val=eval(cmdstr|funcobj [cmdstr|funcobj ...] :symret ) -- സ്ട്രിംഗ് (അല്ലെങ്കിൽ funcobj) ആയി വിലയിരുത്തുക
കമാൻഡുകൾ, nil എന്നതിന് പകരം ഓപ്ഷണലായി റിട്ടേൺ ചിഹ്നം നൽകുക

funcobj=func(body:echo) -- ഒരു എക്സിക്യൂട്ടബിൾ ഒബ്‌ജക്റ്റിലേക്ക് ഒരു കമാൻഡ് ബോഡി കൂട്ടിച്ചേർക്കുക

val=shell(cmdstr) -- ഷെല്ലിലെ കമാൻഡ് വിലയിരുത്തുക

ഉറങ്ങുക(msec) -- മൈക്രോസെക്കൻഡ് ഉറങ്ങുക

നിശബ്ദമാക്കുക ([പതാക]) -- നിശബ്ദ ഫ്ലാഗ് സജ്ജമാക്കുക അല്ലെങ്കിൽ ടോഗിൾ ചെയ്യുക

nil([...]) -- ഏതെങ്കിലും ആർഗ്യുമെന്റുകൾ സ്വീകരിച്ച് nil തിരികെ നൽകുക

c=char(num :u) -- ഏതെങ്കിലും സംഖ്യയെ ഒരു പ്രതീകമാക്കി മാറ്റുക

s=short(num :u) -- ഏത് സംഖ്യയും ഹ്രസ്വമാക്കി മാറ്റുക

i=int(num :u) -- ഏത് സംഖ്യയും ഒരു int ആക്കി മാറ്റുക

l=long(num :u) -- ഏതെങ്കിലും സംഖ്യയെ ദൈർഘ്യത്തിലേക്ക് പരിവർത്തനം ചെയ്യുക

f=float(num) -- ഏതെങ്കിലും സംഖ്യയെ ഫ്ലോട്ടാക്കി മാറ്റുക

d=double(num) -- ഏത് സംഖ്യയും ഇരട്ടയാക്കി മാറ്റുക

sym|lst=type(val [val ...]) -- മൂല്യം(കൾ)ക്കുള്ള റിട്ടേൺ ടൈപ്പ് ചിഹ്നം(കൾ)

sym|lst=class(val [val ...]) -- ഒബ്‌ജക്റ്റ് തരത്തിന്റെ മൂല്യത്തിന്(കൾ) ക്ലാസ് ചിഹ്നം(കൾ) തിരികെ നൽകുക

int=ctoi(char) -- പ്രതീകം പൂർണ്ണസംഖ്യയിലേക്ക് മാറ്റുക

ഫ്ലാഗ്=ഇസ്‌സ്‌പെയ്‌സ്(ചാർ) -- പ്രതീകം വൈറ്റ്‌സ്‌പെയ്‌സ് ആണെങ്കിൽ ശരി എന്ന് തിരികെ നൽകുക

ഫ്ലാഗ്=ഇസ്ഡിജിറ്റ്(ചാർ) -- പ്രതീകം ഒരു സംഖ്യാ അക്കമാണെങ്കിൽ ശരി തിരികെ നൽകുക

ഫ്ലാഗ്=ഇസ്‌സ്‌പേസ്(ചാർ) -- പ്രതീകം അക്ഷരമാലാക്രമമാണെങ്കിൽ ശരി എന്ന് തിരികെ നൽകുക

str=arg(n) -- റിട്ടേൺ കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ്

n=narg(n) -- കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റുകളുടെ റിട്ടേൺ നമ്പർ

num=nand(ab) -- ബിറ്റ്‌വൈസ് NAND(നിഷേധിച്ചു AND)

സംഖ്യ=nor(ab) -- ബിറ്റ്‌വൈസ് NOR (നിഷേധിച്ച OR)

num=xnor(ab) -- ബിറ്റ്‌വൈസ് XNOR (നിഷേധിച്ച XOR)

മാത്രം IN സെർവർ MODE

str=timeexpr(comstr:sec n) -- ഇടവേളകളിൽ എക്സിക്യൂട്ട് ചെയ്യാനുള്ള കമാൻഡ് സ്ട്രിംഗ്

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് comterp ഓൺലൈനിൽ ഉപയോഗിക്കുക