Erlang 21

shell




erlang

shell

मॉड्यूल

खोल

मॉड्यूल सारांश

एर्लांग खोल।

विवरण

यह मॉड्यूल एक एरलैंग शेल प्रदान करता है।

शेल अभिव्यक्ति अनुक्रमों में प्रवेश करने के लिए एक उपयोगकर्ता इंटरफ़ेस प्रोग्राम है। भावों का मूल्यांकन किया जाता है और एक मान लौटाया जाता है। एक इतिहास तंत्र पिछले आदेशों और उनके मूल्यों को बचाता है, जिसे बाद के आदेशों में शामिल किया जा सकता है। सहेजने के लिए कितने आदेश और परिणाम उपयोगकर्ता द्वारा निर्धारित किए जा सकते हैं, या तो history/1 और results/1 को कॉल करके, या shell_history_length अनुप्रयोग के लिए एप्लिकेशन कॉन्फ़िगरेशन पैरामीटर shell_history_length और shell_saved_results सेट करके।

शेल अपवादों से इतिहास तंत्र की सुरक्षा के लिए कमांड के मूल्यांकन के लिए एक सहायक प्रक्रिया का उपयोग करता है। डिफ़ॉल्ट रूप से मूल्यांकनकर्ता प्रक्रिया तब होती है जब कोई अपवाद होता है, लेकिन catch_exception/1 कॉल catch_exception/1 या STDLIB अनुप्रयोग के लिए एप्लिकेशन कॉन्फ़िगरेशन पैरामीटर shell_catch_exception सेट करके इस व्यवहार को बदला जा सकता है। नीचे उदाहरण भी देखें।

परिवर्तनीय बाइंडिंग और स्थानीय प्रक्रिया शब्दकोश परिवर्तन जो उपयोगकर्ता अभिव्यक्तियों में उत्पन्न होते हैं, संरक्षित होते हैं, और चर का उपयोग बाद के आदेशों में उनके मूल्यों तक पहुंचने के लिए किया जा सकता है। बाइंडिंग को भी भुलाया जा सकता है ताकि चर का पुन: उपयोग किया जा सके।

विशेष शेल कमांड में सभी (स्थानीय) फ़ंक्शन कॉल का सिंटैक्स होता है। उनका मूल्यांकन सामान्य फ़ंक्शन कॉल के रूप में किया जाता है और कई कमांड एक अभिव्यक्ति अनुक्रम में उपयोग किए जा सकते हैं।

यदि कोई कमांड (स्थानीय फ़ंक्शन कॉल) शेल द्वारा मान्यता प्राप्त नहीं है, तो सबसे पहले मॉड्यूल user_default में फ़ंक्शन को खोजने का प्रयास किया जाता है, जहां अनुकूलित स्थानीय कमांड को रखा जा सकता है। यदि पाया जाता है, तो फ़ंक्शन का मूल्यांकन किया जाता है, अन्यथा मॉड्यूल shell_default में फ़ंक्शन का मूल्यांकन करने का प्रयास किया जाता है। मॉड्यूल user_default स्पष्ट रूप से लोड होना चाहिए।

शेल उपयोगकर्ता को कई समवर्ती नौकरियों को शुरू करने की अनुमति भी देता है। एक नौकरी को प्रक्रियाओं का एक सेट माना जा सकता है जो शेल के साथ संचार कर सकता है।

खोल में रिकॉर्ड पढ़ने और मुद्रण के लिए कुछ समर्थन है। संकलन के रिकॉर्ड के दौरान अभिव्यक्तियों का अनुवाद टपल भाव से किया जाता है। रनटाइम में यह ज्ञात नहीं है कि क्या एक ट्यूपल रिकॉर्ड का प्रतिनिधित्व करता है, और संकलक द्वारा उपयोग किए गए रिकॉर्ड परिभाषा रनटाइम पर अनुपलब्ध हैं। इसलिए, रिकॉर्ड सिंटैक्स को पढ़ने और जब संभव हो तो रिकॉर्ड के रूप में ट्यूपल्स को प्रिंट करने के लिए, रिकॉर्ड परिभाषाओं को शेल द्वारा ही बनाए रखा जाना चाहिए।

शेल पढ़ने, परिभाषित करने, भूलने, लिस्टिंग और मुद्रण रिकॉर्ड के लिए आदेश नीचे वर्णित हैं। ध्यान दें कि प्रत्येक कार्य का रिकॉर्ड परिभाषाओं का अपना सेट होता है। मामलों को सुविधाजनक बनाने के लिए, प्रत्येक बार एक नई नौकरी शुरू होने पर मॉड्यूल shell_default और user_default (यदि लोड किया गया है) में रिकॉर्ड परिभाषाएं पढ़ी जाती हैं। उदाहरण के लिए, user_default में निम्न लाइन जोड़ने से शेल में file_info की परिभाषा आसानी से उपलब्ध हो जाती है:

-include_lib("kernel/include/file.hrl").

शेल दो मोड में चलता है:

  • Normal (possibly restricted) मोड, जिसमें कमांड को संपादित किया जा सकता है और अभिव्यक्ति का मूल्यांकन किया जा सकता है

  • जॉब कंट्रोल मोड, JCL , जिसमें नौकरी शुरू की जा सकती है, मारे जा सकते हैं, अलग हो सकते हैं और जुड़े रह सकते हैं

केवल वर्तमान में जुड़ी नौकरी शेल के लिए 'बात' कर सकती है।

शेल कमांड्स

b()

वर्तमान चर बाइंडिंग प्रिंट करता है।

f()

सभी परिवर्तनशील बाइंडिंग को निकालता है।

f(X)

चर X के बंधन को हटाता है।

h()

इतिहास सूची प्रिंट करता है।

history(N)

इतिहास सूची में N रखने के लिए पिछले आदेशों की संख्या निर्धारित करता है। पिछला नंबर वापस आ गया है। 20 की कमी।

results(N)

इतिहास सूची में N को रखने के लिए पिछले आदेशों से परिणामों की संख्या निर्धारित करता है। पिछला नंबर वापस आ गया है। 20 की कमी।

e(N)

दोहराता है कमांड N , अगर N पॉजिटिव है। यदि यह नकारात्मक है, तो N वें पिछले कमांड को दोहराया जाता है (अर्थात, e(-1) को पिछले कमांड को दोहराता है)।

v(N)

यदि वर्तमान सकारात्मक है, तो कमांड N में कमांड N के रिटर्न वैल्यू का उपयोग करता है। यदि यह नकारात्मक है, तो N वें पिछले कमांड का रिटर्न वैल्यू उपयोग किया जाता है (अर्थात, v(-1) पिछले कमांड के मूल्य का उपयोग करता है)।

help()

shell_default:help() मूल्यांकन shell_default:help()

c(Mod)

shell_default:c(Mod) मूल्यांकन shell_default:c(Mod) । यह मॉड्यूल को संकलित और लोड करता है और यदि आवश्यक हो तो कोड के पुराने संस्करणों को शुद्ध करता है। Mod या तो एक मॉड्यूल नाम या आ स्रोत फ़ाइल पथ के साथ या बिना .erl एक्सटेंशन के हो सकता है।

catch_exception(Bool)

मूल्यांकनकर्ता प्रक्रिया के अपवाद हैंडलिंग सेट करता है। पिछला अपवाद हैंडलिंग वापस आ गया है। डिफ़ॉल्ट ( false ) एक अपवाद होने पर मूल्यांकनकर्ता प्रक्रिया को मारने के लिए है, जो शेल को एक नया मूल्यांकनकर्ता प्रक्रिया बनाने का कारण बनता है। जब अपवाद हैंडलिंग सही पर सेट होती true , तो मूल्यांकनकर्ता प्रक्रिया चालू रहती है। इसका मतलब है, उदाहरण के लिए, कि पोर्ट और ईटीएस टेबल के साथ-साथ मूल्यांकनकर्ता प्रक्रिया से जुड़ी प्रक्रियाएं अपवाद से बचती हैं।

rd(RecordName, RecordDefinition)

खोल में एक रिकॉर्ड को परिभाषित करता है। RecordName एक परमाणु है और RecordDefinition फ़ील्ड नामों और डिफ़ॉल्ट मानों को सूचीबद्ध करता है। आमतौर पर रिकॉर्ड परिभाषाओं को नीचे वर्णित rr/1,2,3 कमांड के उपयोग से शेल के लिए जाना जाता है, लेकिन कभी-कभी यह मक्खी पर रिकॉर्ड को परिभाषित करना आसान होता है।

rf()

सभी रिकॉर्ड परिभाषाओं को हटाता है, फिर मॉड्यूल shell_default और user_default (यदि लोड किया गया है) से रिकॉर्ड परिभाषा पढ़ता है। परिभाषित अभिलेखों के नाम लौटाता है।

rf(RecordNames)

चयनित रिकॉर्ड परिभाषाएँ निकालता है। RecordNames एक रिकॉर्ड नाम या रिकॉर्ड नामों की एक सूची है। सभी रिकॉर्ड परिभाषाओं को हटाने के लिए, '_' उपयोग करें।

rl()

प्रिंट सभी परिभाषाएँ रिकॉर्ड करते हैं।

rl(RecordNames)

प्रिंट ने रिकॉर्ड परिभाषाएँ चुनीं। RecordNames एक रिकॉर्ड नाम या रिकॉर्ड नामों की एक सूची है।

rp(Term)

शेल में ज्ञात रिकॉर्ड परिभाषाओं का उपयोग करके एक शब्द प्रिंट करता है। सभी Term मुद्रित हैं; गहराई तब तक सीमित नहीं होती है, जब रिटर्न वैल्यू प्रिंट की जाती है।

rr(Module)

मॉड्यूल की BEAM फ़ाइल से रिकॉर्ड परिभाषाएँ पढ़ता है। यदि BEAM फ़ाइल में कोई रिकॉर्ड परिभाषाएँ नहीं हैं, तो स्रोत फ़ाइल स्थित है और इसके बजाय पढ़ें। पढ़ी गई रिकॉर्ड परिभाषाओं के नाम लौटाता है। Module एक परमाणु है।

rr(Wildcard)

फ़ाइलों से रिकॉर्ड परिभाषाएँ पढ़ता है। किसी भी रिकॉर्ड नाम की मौजूदा परिभाषा को बदल दिया गया है। Wildcard एक वाइल्डकार्ड स्ट्रिंग है जैसा कि filelib(3) में परिभाषित किया गया है, लेकिन एक परमाणु नहीं।

rr(WildcardOrModule, RecordNames)

फ़ाइलों से रिकॉर्ड परिभाषाएँ पढ़ता है, लेकिन रिकॉर्ड नामों में RecordNames (रिकॉर्ड नाम या रिकॉर्ड नामों की सूची) में उल्लेख नहीं किया जाता है।

rr(WildcardOrModule, RecordNames, Options)

फ़ाइलों से रिकॉर्ड परिभाषाएँ पढ़ता है। संकलक विकल्प {i, Dir} , {d, Macro} , और {d, Macro, Value} को पहचाना और शामिल पथ और मैक्रो परिभाषाओं को सेट करने के लिए उपयोग किया जाता है। सभी रिकॉर्ड परिभाषाओं को पढ़ने के लिए '_' उपयोग RecordNames मान के रूप में RecordNames

उदाहरण

निम्नलिखित उदाहरण शेल के साथ एक लंबा संवाद है। > साथ शुरू होने वाले कमांड शेल में इनपुट होते हैं। अन्य सभी लाइनें शेल से आउटपुट हैं।

strider 1> erl
Erlang (BEAM) emulator version 5.3 [hipe] [threads:0]

Eshell V5.3  (abort with ^G)
1> Str = "abcd".
"abcd"

कमांड 1 सेट चर स्ट्रिंग टू स्ट्रिंग "abcd"

2> L = length(Str).
4

कमांड 2 सेट स्ट्रिंग की लंबाई के लिए L

3> Descriptor = {L, list_to_atom(Str)}.
{4,abcd}

कमांड 3 टपल list_to_atom/1 बनाता है, BIF list_to_atom/1 मूल्यांकन करता है।

4> L. 
4

कमांड 4 वेरिएबल L के मान को प्रिंट करता है।

5> b().
Descriptor = {4,abcd}
L = 4
Str = "abcd"
ok

कमांड 5 आंतरिक शेल कमांड b() मूल्यांकन करता है, जो "बाइंडिंग" का संक्षिप्त नाम है। यह वर्तमान शेल चरों और उनके बाइंडिंग को प्रिंट करता है। अंत में फ़ंक्शन b() का वापसी मान है b()

6> f(L). 
ok

कमांड 6 आंतरिक शेल कमांड f(L) ("भूल" का संक्षिप्त नाम f(L) मूल्यांकन करता है। चर L का मान हटा दिया जाता है।

7> b().
Descriptor = {4,abcd}
Str = "abcd"
ok

कमांड 7 नए बाइंडिंग प्रिंट करता है।

8> f(L).
ok

कमांड 8 का कोई प्रभाव नहीं है, क्योंकि L का कोई मूल्य नहीं है।

9> {L, _} = Descriptor.
{4,abcd}

कमांड 9, Descriptor पर एक पैटर्न मैचिंग ऑपरेशन करता है, जो L को एक नया मान देता है।

10> L.
4

कमांड 10 L के वर्तमान मूल्य को प्रिंट करता है।

11> {P, Q, R} = Descriptor.
** exception error: no match of right hand side value {4,abcd}

कमांड 11 Descriptor खिलाफ {P, Q, R} से मेल करने की कोशिश करता है, जो कि {4, abc} । मैच विफल हो जाता है और कोई भी नया चर बाध्य नहीं होता है। " ** exception error: " के साथ शुरू होने वाला प्रिंटआउट अभिव्यक्ति का मूल्य नहीं है (अभिव्यक्ति का कोई मूल्य नहीं था क्योंकि इसका मूल्यांकन विफल रहा), लेकिन सिस्टम द्वारा उपयोगकर्ता को सूचित करने के लिए छपी एक चेतावनी कि एक त्रुटि हुई है। अन्य चर ( L , Str , और इसी तरह) के मूल्य अपरिवर्तित हैं।

12> P.
* 1: variable 'P' is unbound
13> Descriptor.
{4,abcd}

कमांड 12 और 13 दिखाते हैं कि P अनबाउंड है क्योंकि पिछली कमांड विफल हो गई थी, और यह कि Descriptor नहीं बदला है।

14>{P, Q} = Descriptor.
{4,abcd}
15> P.
4

14 और 15 कमांड एक सही मैच दिखाते हैं जहां P और Q बंधे हैं।

16> f().
ok

आदेश 16 सभी बाइंडिंग को साफ़ करता है।

अगले कुछ आदेश मानते हैं कि test1:demo(X) को निम्नानुसार परिभाषित किया गया है:

demo(X) ->
put(aa, worked),
X = 1,
X + 10.

17> put(aa, hello).
undefined
18> get(aa).
hello

17 और 18 सेट करता है और प्रक्रिया शब्दकोश में आइटम aa के मूल्य का निरीक्षण करता है।

19> Y = test1:demo(1).
11

कमांड 19 test1:demo(1) 1 का मूल्यांकन करता है test1:demo(1) । मूल्यांकन सफल होता है और प्रक्रिया शब्दकोश में किए गए परिवर्तन शेल के लिए दृश्यमान हो जाते हैं। शब्दकोश आइटम aa का नया मान कमांड 20 में देखा जा सकता है।

20> get().
[{aa,worked}]
21> put(aa, hello).
worked
22> Z = test1:demo(2).
** exception error: no match of right hand side value 1
     in function  test1:demo/1

कमांड 21 और 22 शब्दकोश आइटम के मूल्य को hello और कॉल test1:demo(2) । मूल्यांकन विफल हो जाता है और त्रुटि 1 होने से पहले test1:demo(2) में शब्दकोश में किए गए परिवर्तन को छोड़ दिया जाता है।

23> Z.
* 1: variable 'Z' is unbound
24> get(aa).
hello

23 और 24 कमांड्स बताते हैं कि Z बाध्य नहीं था और यह शब्दकोश आइटम aa ने अपने मूल मूल्य को बरकरार रखा है।

25> erase(), put(aa, hello).
undefined
26> spawn(test1, demo, [1]).
<0.57.0>
27> get(aa).
hello

25, 26, और 27 कमांड्स test1:demo(1) के मूल्यांकन के प्रभाव को दिखाते हैं test1:demo(1) पृष्ठभूमि में test1:demo(1) । इस मामले में, अभिव्यक्ति का मूल्यांकन एक नव स्पंदित प्रक्रिया में किया जाता है। प्रक्रिया शब्दकोश में किए गए कोई भी परिवर्तन नव-प्रायोजित प्रक्रिया के लिए स्थानीय हैं और इसलिए शेल के लिए दृश्यमान नहीं हैं।

28> io:format("hello hello\n").
hello hello
ok
29> e(28).
hello hello
ok
30> v(28).
ok

28, 29 और 30 कमांड शेल की इतिहास सुविधाओं का उपयोग करते हैं। कमांड 29 कमांड 28 का पुनर्मूल्यांकन करता है। कमांड 30 कमांड 28 के मूल्य (परिणाम) का उपयोग करता है। शुद्ध कार्य (बिना किसी साइड इफेक्ट के एक फ़ंक्शन) के मामलों में, परिणाम समान होता है। साइड इफेक्ट्स वाले फ़ंक्शन के लिए, परिणाम अलग हो सकता है।

अगले कुछ आदेश कुछ रिकॉर्ड हेरफेर दिखाते हैं। यह माना जाता है कि ex.erl एक रिकॉर्ड को निम्नानुसार परिभाषित करता है:

-record(rec, {a, b = val()}).

val() ->
3.

31> c(ex).
{ok,ex}
32> rr(ex).
[rec]

31 और 32 संकलन फ़ाइल को ex.erl और ex.erl में रिकॉर्ड परिभाषाएँ ex.beam । यदि कंपाइलर ने BEAM फ़ाइल पर कोई रिकॉर्ड परिभाषा नहीं बनाई है, तो rr(ex) इसके बजाय स्रोत फ़ाइल से रिकॉर्ड परिभाषा पढ़ने की कोशिश करता है।

33> rl(rec).
-record(rec,{a,b = val()}).
ok

आदेश 33 रिकॉर्ड rec नाम की परिभाषा प्रिंट करता है।

34> #rec{}.
** exception error: undefined shell command val/0

कमांड 34 एक rec रिकॉर्ड बनाने की कोशिश करता है, लेकिन फ़ंक्शन val/0 अपरिभाषित होने पर विफल रहता है।

35> #rec{b = 3}.
#rec{a = undefined,b = 3}

कमांड 35 वर्कअराउंड दिखाता है: स्पष्ट रूप से उन फ़ील्ड्स को रिकॉर्ड करने के लिए मान असाइन करें जो अन्यथा आरंभीकृत नहीं किए जा सकते हैं।

36> rp(v(-1)).
#rec{a = undefined,b = 3}
ok

कमांड 36 शेल द्वारा बनाए रिकॉर्ड परिभाषाओं का उपयोग करके नए बनाए गए रिकॉर्ड को प्रिंट करता है।

37> rd(rec, {f = orddict:new()}).
rec

कमांड 37 सीधे शेल में रिकॉर्ड को परिभाषित करता है। परिभाषा फ़ाइल ex.beam से पढ़ी गई जगह को बदल ex.beam

38> #rec{}.
#rec{f = []}
ok

कमांड 38 नई परिभाषा का उपयोग करके एक रिकॉर्ड बनाता है, और परिणाम प्रिंट करता है।

39> rd(rec, {c}), A.
* 1: variable 'A' is unbound
40> #rec{}.
#rec{c = undefined}
ok

कमांड 39 और 40 दिखाते हैं कि रिकॉर्ड परिभाषाएँ साइड इफेक्ट के रूप में अपडेट की जाती हैं। कमांड का मूल्यांकन विफल हो जाता है, लेकिन rec की परिभाषा को पूरा किया गया है।

अगले आदेश के लिए, यह माना जाता है कि test1:loop(N) को निम्नानुसार परिभाषित किया गया है:

loop(N) ->
io:format("Hello Number: ~w~n", [N]),
loop(N+1).

41> test1:loop(0).
Hello Number: 0
Hello Number: 1
Hello Number: 2
Hello Number: 3

User switch command
 --> i
 --> c
.
.
.
Hello Number: 3374
Hello Number: 3375
Hello Number: 3376
Hello Number: 3377
Hello Number: 3378
** exception exit: killed

कमांड 41 test1:loop(0) 1 का मूल्यांकन करता है test1:loop(0) , जो सिस्टम को अनंत लूप में डालता है। इस बिंदु पर उपयोगकर्ता प्रकार ^G (कंट्रोल जी), जो वर्तमान प्रक्रिया से आउटपुट को निलंबित करता है, जो एक लूप में फंस गया है, और JCL मोड को सक्रिय करता है। JCL मोड में उपयोगकर्ता नौकरियों को शुरू और रोक सकता है।

इस विशेष मामले में, कमांड i ("इंटरप्ट") लूपिंग प्रोग्राम को समाप्त करता है, और कमांड c शेल से फिर से जुड़ता है। जैसा कि प्रक्रिया पृष्ठभूमि में चल रही थी, इससे पहले कि हम इसे मार दें, संदेश " ** exception exit: killed " से पहले अधिक प्रिंटआउट दिखाई देते हैं।

42> E = ets:new(t, []).
#Ref<0.1662103692.2407923716.214192>

आदेश 42 ईटीएस तालिका बनाता है।

43> ets:insert({d,1,2}).
** exception error: undefined function ets:insert/1

कमांड 43 ईटीएस तालिका में एक टपल सम्मिलित करने का प्रयास करता है, लेकिन पहला तर्क (तालिका) गायब है। अपवाद मूल्यांकनकर्ता प्रक्रिया को मारता है।

44> ets:insert(E, {d,1,2}).
** exception error: argument is of wrong type
     in function  ets:insert/2
        called as ets:insert(16,{d,1,2})

आदेश 44 गलती को सुधारता है, लेकिन ईटीएस तालिका को नष्ट कर दिया गया है क्योंकि यह मारे गए मूल्यांकनकर्ता प्रक्रिया के स्वामित्व में था।

45> f(E).
ok
46> catch_exception(true).
false

कमांड 46 मूल्यांकनकर्ता प्रक्रिया के अपवाद हैंडलिंग को true सेट करता true । Erlang को erl -stdlib shell_catch_exception true द्वारा प्रारंभ करते समय अपवाद हैंडलिंग भी सेट किया जा सकता erl -stdlib shell_catch_exception true

47> E = ets:new(t, []).
#Ref<0.1662103692.2407923716.214197>
48> ets:insert({d,1,2}).
* exception error: undefined function ets:insert/1

कमांड 48 कमांड 43 की तरह ही गलती करता है, लेकिन इस समय मूल्यांकनकर्ता प्रक्रिया चालू रहती है। प्रिंटआउट की शुरुआत में एकल स्टार संकेत देता है कि अपवाद पकड़ा गया है।

49> ets:insert(E, {d,1,2}).
true

कमांड 49 सफलतापूर्वक ETS तालिका में टपल को सम्मिलित करता है।

50> ets:insert(#Ref<0.1662103692.2407923716.214197>, {e,3,4}).
true

कमांड 50 ईटीएस तालिका में एक और टपल सम्मिलित करता है। इस बार पहला तर्क तालिका पहचानकर्ता का है। शेल आदेशों को pids ( <0.60.0> ), बंदरगाहों ( #Port<0.536> ), संदर्भों ( #Ref<0.1662103692.2407792644.214210> ), और बाहरी कार्यों ( #Ref<0.1662103692.2407792644.214210> ) के साथ पार्स कर सकता है, लेकिन कमांड विफल रहता है जब तक संबंधित पीआईडी, पोर्ट, संदर्भ, या फ़ंक्शन को रनिंग सिस्टम में बनाया जा सकता है।

51> halt().
strider 2>

कमांड 51 एर्लांग रनटाइम सिस्टम से बाहर निकलता है।

जेसीएल मोड

जब शेल शुरू होता है, तो यह एक एकल मूल्यांकनकर्ता प्रक्रिया शुरू करता है। यह प्रक्रिया, किसी भी स्थानीय प्रक्रिया के साथ होती है, जो इसे पैदा करती है, इसे job रूप में संदर्भित किया जाता है। केवल वर्तमान नौकरी, जिसे connected कहा जाता है, मानक I / O के साथ संचालन कर सकता है। यदि वे मानक I / O का उपयोग करने का प्रयास करते हैं, तो अन्य सभी कार्य, जिन्हें detached कर blocked जाता है, blocked हो जाते हैं।

सभी नौकरियां जो सामान्य तरीके से मानक I / O का उपयोग नहीं करती हैं।

शेल एस्केप कुंजी ^G (कंट्रोल जी) वर्तमान नौकरी को समाप्त कर देता है और JCL मोड को सक्रिय करता है। JCL मोड प्रॉम्प्ट "-->" । अगर "?" प्रॉम्प्ट पर दर्ज किया गया है, निम्न मदद संदेश प्रदर्शित किया जाता है:

--> ?
c [nn]            - connect to job
i [nn]            - interrupt job
k [nn]            - kill job
j                 - list all jobs
s [shell]         - start local shell
r [node [shell]]  - start remote shell
q                 - quit erlang
? | h             - this message

JCL कमांड के निम्नलिखित अर्थ हैं:

c [nn]

नौकरी की संख्या <nn> या वर्तमान नौकरी से जोड़ता है। मानक शेल फिर से शुरू हो गया है। मौजूदा नौकरी द्वारा मानक I / O का उपयोग करने वाले ऑपरेशन शेल के उपयोगकर्ता इनपुट के साथ इंटरलेय किए जाते हैं।

i [nn]

नौकरी नंबर nn या वर्तमान नौकरी के लिए वर्तमान मूल्यांकनकर्ता प्रक्रिया को रोकता है, लेकिन शेल प्रक्रिया को नहीं मारता है। तो, किसी भी चर बाइंडिंग और प्रक्रिया शब्दकोश संरक्षित हैं और नौकरी को फिर से जोड़ा जा सकता है। इस कमांड का उपयोग अंतहीन लूप को बाधित करने के लिए किया जा सकता है।

k [nn]

नौकरी नंबर nn या वर्तमान नौकरी को मारता है। नौकरी में सभी स्पॉन्डेड प्रक्रियाएं मार दी जाती हैं, बशर्ते उन्होंने group_leader/1 BIF का मूल्यांकन न किया हो और स्थानीय मशीन पर स्थित हों। दूरस्थ नोड्स पर स्थित प्रक्रियाओं को नहीं मारा जाता है।

j

सभी नौकरियों की सूची देता है। सभी ज्ञात नौकरियों की एक सूची मुद्रित की जाती है। वर्तमान नौकरी का नाम '*' के साथ उपसर्ग है।

s

एक नया काम शुरू करता है। इसे नया सूचकांक [nn] सौंपा गया है, जिसे संदर्भों में इस्तेमाल किया जा सकता है।

s [shell]

एक नया काम शुरू करता है। इसे नया सूचकांक [nn] सौंपा गया है, जिसे संदर्भों में इस्तेमाल किया जा सकता है। यदि वैकल्पिक तर्क shell निर्दिष्ट किया जाता है, तो इसे एक मॉड्यूल माना जाता है जो वैकल्पिक शेल को लागू करता है।

r [node]

node पर एक दूरस्थ नौकरी शुरू करता node । यह नोड्स के नेटवर्क पर चल रहे कई अनुप्रयोगों को नियंत्रित करने के लिए एक नोड पर चलने वाले शेल को अनुमति देने के लिए वितरित एर्लैंग में उपयोग किया जाता है। यदि वैकल्पिक तर्क shell निर्दिष्ट किया जाता है, तो इसे एक मॉड्यूल माना जाता है जो वैकल्पिक शेल को लागू करता है।

q

एर्लांग को छोड़ देता है। ध्यान दें कि यदि Erlang को अनदेखा ब्रेक, +Bi , सिस्टम फ़्लैग (जो उपयोगी हो सकता है, उदाहरण के लिए प्रतिबंधित शेल चलाते समय उदाहरण के लिए, अगला भाग देखें) के साथ यह विकल्प अक्षम है।

?

ऊपर मदद संदेश प्रदर्शित करता है।

शेल एस्केप के व्यवहार को STDLIB एप्लिकेशन वेरिएबल shell_esc द्वारा बदला जा सकता है। चर का मान या तो jcl ( erl -stdlib shell_esc jcl ) हो सकता है या abort ( erl -stdlib shell_esc abort ) हो सकता है। पहला विकल्प सेट करता है ^G JCL मोड को सक्रिय करने के लिए ^G (जो कि डिफ़ॉल्ट व्यवहार भी है)। उत्तरार्द्ध सेट ^G वर्तमान शेल को समाप्त करने और एक नया शुरू करने के लिए। JCL मोड को तब लागू नहीं किया जा सकता जब shell_esc को abort लिए सेट किया गया हो।

यदि आप चाहते हैं कि एक एरलांग नोड शुरू से ही एक दूरस्थ नौकरी के लिए सक्रिय हो (डिफ़ॉल्ट स्थानीय नौकरी के बजाय), फ्लैग के साथ -remsh शुरू करें, उदाहरण के लिए, erl -sname this_node -remsh [email protected]_host

प्रतिबंधित शैल

शेल को एक प्रतिबंधित मोड में शुरू किया जा सकता है। इस मोड में, शेल केवल फ़ंक्शन कॉल का मूल्यांकन करता है यदि अनुमति दी जाती है। यह सुविधा संभव है, उदाहरण के लिए, किसी उपयोगकर्ता को गलती से एक फ़ंक्शन को प्रॉम्प्ट से कॉल करने से रोकती है जो एक रनिंग सिस्टम (सिस्टम फ्लैग +Bi साथ संयोजन में उपयोगी) को नुकसान पहुंचा सकती है।

जब प्रतिबंधित शेल एक अभिव्यक्ति का मूल्यांकन करता है और एक फ़ंक्शन कॉल या ऑपरेटर एप्लिकेशन का सामना करता है, तो यह कॉलबैक फ़ंक्शन (प्रश्न में फ़ंक्शन कॉल के बारे में जानकारी के साथ) को कॉल करता है। यह कॉलबैक फ़ंक्शन true है कि शेल मूल्यांकन के साथ आगे बढ़े, या इसे निरस्त करने के लिए false है। उपयोगकर्ता को लागू करने के लिए दो संभावित कॉलबैक फ़ंक्शन हैं:

  • local_allowed(Func, ArgList, State) -> {boolean(),NewState}

    इसका उपयोग यह निर्धारित करने के लिए किया जाता है कि तर्क ArgList साथ स्थानीय फ़ंक्शन ArgList को कॉल करने की अनुमति है या नहीं।

  • non_local_allowed(FuncSpec, ArgList, State) -> {boolean(),NewState} | {{redirect,NewFuncSpec,NewArgList},NewState}

    यह निर्धारित करने के लिए उपयोग किया जाता है कि तर्क ArgList साथ गैर-स्थानीय फ़ंक्शन FuncSpec ( {Module,Func} या एक मजेदार) पर ArgList करने की अनुमति है या नहीं। रिटर्न मान {redirect,NewFuncSpec,NewArgList} का उपयोग शेल को FuncSpec और ArgList द्वारा निर्दिष्ट किसी अन्य फ़ंक्शन के मूल्यांकन के लिए किया जा सकता है।

इन कॉलबैक फ़ंक्शंस को स्थानीय और गैर-स्थानीय मूल्यांकन फ़ंक्शन संचालकों से कहा जाता है, जिन्हें erl_eval मैनुअल पेज में वर्णित किया गया है। (कॉलबैक फ़ंक्शन को कॉल करने से पहले ArgList में तर्क का मूल्यांकन किया जाता है।)

तर्क State एक टपल {ShellState,ExprState} । वापसी मूल्य NewState का एक ही रूप है। इसका उपयोग कॉलबैक फ़ंक्शन पर कॉल के बीच एक राज्य को ले जाने के लिए किया जा सकता है। ShellState में सहेजा गया डेटा पूरे शेल सत्र के माध्यम से रहता है। ExprState में सहेजा गया डेटा केवल वर्तमान अभिव्यक्ति के मूल्यांकन के माध्यम से रहता है।

प्रतिबंधित शेल सत्र शुरू करने के दो तरीके हैं:

  • STDLIB एप्लिकेशन वैरिएबल restricted_shell shell का उपयोग करें और निर्दिष्ट करें, इसके मूल्य के रूप में, कॉलबैक मॉड्यूल का नाम। उदाहरण (कॉलबैक कार्यों में लागू $ erl -stdlib restricted_shell callback_mod ): $ erl -stdlib restricted_shell callback_mod

  • एक सामान्य शेल सत्र से, कॉल फ़ंक्शन start_restricted/1 । यह वर्तमान मूल्यांकनकर्ता से बाहर निकलता है और प्रतिबंधित मोड में एक नया शुरू करता है।

टिप्पणियाँ:

  • जब प्रतिबंधित शेल मोड सक्रिय या निष्क्रिय होता है, तो क्रमशः या सामान्य मोड में नोड रन पर नए कार्य शुरू होते हैं।

  • यदि किसी विशेष नोड पर प्रतिबंधित मोड सक्षम किया गया है, तो इस नोड से कनेक्ट होने वाले दूरस्थ शेल भी प्रतिबंधित मोड में चलते हैं।

  • कॉलबैक फ़ंक्शन का उपयोग संकलित कोड (केवल शेल प्रॉम्प्ट में दर्ज किए गए एक्सप्रेशन से कॉल किए गए फ़ंक्शंस से किए गए कार्यों को निष्पादित करने या अनुमति देने के लिए नहीं किया जा सकता)।

कॉलबैक मॉड्यूल को लोड करते समय त्रुटियां अलग-अलग तरीकों से नियंत्रित की जाती हैं, यह इस बात पर निर्भर करता है कि प्रतिबंधित शेल कैसे सक्रिय होता है:

  • यदि एमुलेटर स्टार्टअप के दौरान एसटीडीएलआईबी चर सेट करके प्रतिबंधित शेल सक्रिय है, और कॉलबैक मॉड्यूल लोड नहीं किया जा सकता है, तो केवल कमांड q() और init:stop() अनुमति देने वाले डिफ़ॉल्ट प्रतिबंधित शेल को फॉलबैक के रूप में उपयोग किया जाता है।

  • यदि प्रतिबंधित शेल start_restricted/1 का उपयोग करके सक्रिय किया गया है और कॉलबैक मॉड्यूल लोड नहीं किया जा सकता है, तो एक त्रुटि रिपोर्ट त्रुटि लकड़हारा को भेजी जाती है और कॉल {error,Reason} वापस आती है।

उत्साह

डिफ़ॉल्ट शेल प्रॉम्प्ट फ़ंक्शन नोड का नाम प्रदर्शित करता है (यदि नोड वितरित सिस्टम का हिस्सा हो सकता है) और वर्तमान कमांड संख्या। उपयोगकर्ता प्रॉम्प्ट फ़ंक्शन को prompt_func/1 कॉल prompt_func/1 या STDLIB एप्लिकेशन के लिए एप्लिकेशन कॉन्फ़िगरेशन पैरामीटर shell_prompt_func सेट करके अनुकूलित कर सकता है।

एक कस्टमाइज्ड प्रॉम्प्ट फंक्शन को टपल {Mod, Func} कहा जाता है। फ़ंक्शन को Mod:Func(L) रूप में कहा जाता है, जहां L शेल द्वारा बनाई गई कुंजी-मूल्य जोड़े की एक सूची है। वर्तमान में केवल एक जोड़ी है: {history, N} , जहां N वर्तमान कमांड संख्या है। फ़ंक्शन वर्ण या परमाणु की सूची वापस करना है। यह बाधा Erlang I / O प्रोटोकॉल के कारण है। कोड प्वाइंट 255 से परे यूनिकोड वर्णों को सूची और परमाणु में अनुमति दी गई है। ध्यान दें कि प्रतिबंधित मोड में कॉल Mod:Func(L) को अनुमति दी जानी चाहिए या डिफ़ॉल्ट शेल प्रॉम्प्ट फ़ंक्शन को कहा जाता है।

निर्यात

catch_exception (बूल) -> बूलियन ()

प्रकार

मूल्यांकनकर्ता प्रक्रिया के अपवाद हैंडलिंग सेट करता है। पिछला अपवाद हैंडलिंग वापस आ गया है। डिफ़ॉल्ट ( false ) एक अपवाद होने पर मूल्यांकनकर्ता प्रक्रिया को मारने के लिए है, जो शेल को एक नया मूल्यांकनकर्ता प्रक्रिया बनाने का कारण बनता है। जब अपवाद हैंडलिंग सही पर सेट होती true , तो मूल्यांकनकर्ता प्रक्रिया चालू रहती है, जिसका अर्थ है कि, उदाहरण के लिए, पोर्ट और ईटीएस टेबल और साथ ही मूल्यांकनकर्ता प्रक्रिया से जुड़ी प्रक्रियाएं अपवाद से बची रहती हैं।

इतिहास (एन) -> पूर्णांक ()> = 0

प्रकार

इतिहास सूची में N रखने के लिए पिछले आदेशों की संख्या निर्धारित करता है। पिछला नंबर वापस आ गया है। 20 की कमी।

prompt_func (PromptFunc) -> PromptFunc2

प्रकार

PromptFunc को शेल प्रॉम्प्ट फ़ंक्शन सेट करता है। पिछला प्रॉम्प्ट फ़ंक्शन वापस आ गया है।

परिणाम (एन) -> पूर्णांक ()> = 0

प्रकार

इतिहास सूची में N को रखने के लिए पिछले आदेशों से परिणामों की संख्या निर्धारित करता है। पिछला नंबर वापस आ गया है। 20 की कमी।

start_restricted (मॉड्यूल) -> {त्रुटि, कारण}

प्रकार

एक सामान्य शेल से बाहर निकलता है और एक प्रतिबंधित शेल शुरू करता है। Module local_allowed/3 और non_local_allowed/3 फ़ंक्शन के लिए कॉलबैक Module निर्दिष्ट करता है। फ़ंक्शन को शेल से बुलाया जाना है।

यदि कॉलबैक मॉड्यूल लोड नहीं किया जा सकता है, तो एक त्रुटि टपल लौटाया जाता है। त्रुटि टपल में Reason कॉलबैक मॉड्यूल के कोड को लोड करने की कोशिश करते समय कोड लोडर द्वारा लौटाया गया है।

stop_restricted () -> no_return ()

एक प्रतिबंधित शेल से बाहर निकलता है और एक सामान्य शेल शुरू करता है। फ़ंक्शन को शेल से बुलाया जाना है।

स्ट्रिंग्स (स्ट्रिंग्स) -> स्ट्रिंग्स 2

प्रकार

Strings लिए सूचियों का सुंदर मुद्रण सेट करता है। ध्वज का पिछला मान लौटाया गया है।

ध्वज को STDLIB अनुप्रयोग चर shell_strings द्वारा भी सेट किया जा सकता है। डिफॉल्ट्स टू true , जिसका अर्थ है कि जब संभव हो तो स्ट्रिंग सिंटैक्स का उपयोग करके पूर्णांकों की सूची मुद्रित की जाती है। मूल्य false अर्थ है कि स्ट्रिंग सिंटैक्स का उपयोग करके कोई सूची नहीं छपी है।